diff --git a/.classpath b/.classpath deleted file mode 100644 index 49a9848..0000000 --- a/.classpath +++ /dev/null @@ -1,8 +0,0 @@ - - - - - - - - diff --git a/.github/release-settings.xml b/.github/release-settings.xml new file mode 100644 index 0000000..be56a53 --- /dev/null +++ b/.github/release-settings.xml @@ -0,0 +1,20 @@ + + + + eu.maveniverse.maven.plugins + + + + + sonatype-central-portal + ${env.MAVEN_USER} + ${env.MAVEN_PASSWORD} + + sonatype-cp + njord:template:release-sca + + + + + diff --git a/.github/workflows/basic.yml b/.github/workflows/basic.yml new file mode 100644 index 0000000..7f12ed7 --- /dev/null +++ b/.github/workflows/basic.yml @@ -0,0 +1,24 @@ +name: Java CI + +on: [push, pull_request] + +jobs: + build: + runs-on: ubuntu-latest + strategy: + fail-fast: false + matrix: + java: [ 21 ] + steps: + - uses: actions/checkout@v4.1.1 + - name: Set up JDK + uses: actions/setup-java@v4.1.0 + with: + java-version: ${{ matrix.java }} + distribution: 'adopt' + - name: Build and test with Maven + run: mvn package + - name: Build example + run: javac -cp target/classes/:. example.java + - name: Run example + run: java -cp target/classes/:. example diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml new file mode 100644 index 0000000..d6ad167 --- /dev/null +++ b/.github/workflows/release.yml @@ -0,0 +1,90 @@ +name: Release + +on: + workflow_dispatch: + inputs: + releaseVersion: + description: "Release version, e.g. 0.3.6 (optional — auto-detected from the current POM)" + required: false + +jobs: + release: + runs-on: ubuntu-latest + permissions: + contents: write # to automatically create tags + + steps: + - name: Validate release version + if: ${{ github.event.inputs.releaseVersion != '' }} + run: | + RELEASE=${{ github.event.inputs.releaseVersion }} + if [[ ! $RELEASE =~ ^[0-9]+\.[0-9]+\.[0-9]+(-SNAPSHOT)?$ ]]; then + echo "Error: releaseVersion '$RELEASE' is not in the correct format x.y.z or x.y.z-SNAPSHOT" + exit 1 + fi + + - name: Checkout + uses: actions/checkout@v4 + with: + fetch-depth: 0 + ref: master + + - name: Set up Java + uses: actions/setup-java@v4 + with: + java-version: '21' + distribution: 'adopt' + gpg-private-key: ${{ secrets.GPG_PRIVATE_KEY }} + gpg-passphrase: MAVEN_GPG_PASSPHRASE + + - name: Configure git + run: | + git config user.email "actions@github.com" + git config user.name "GitHub Actions" + + - name: Prepare Release + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + MAVEN_GPG_PASSPHRASE: ${{ secrets.GPG_PASSPHRASE }} + run: | + MVN_ARGS="" + if [ -n "${{ github.event.inputs.releaseVersion }}" ]; then + MVN_ARGS="$MVN_ARGS -DreleaseVersion=${{ github.event.inputs.releaseVersion }}" + fi + mvn -B release:prepare $MVN_ARGS + + - name: Check release.properties + run: | + if [ ! -f release.properties ]; then + echo "release.properties not found" + exit 1 + fi + echo "Contents of release.properties:" + cat release.properties + + - name: Determine release version + id: version + run: | + export TAG=$(grep 'scm.tag=' release.properties | cut -d'=' -f2) + export VERSION=${TAG#JavaFastPFOR-} + + echo "released_tag=${TAG}" >> $GITHUB_OUTPUT + echo "released_version=${VERSION}" >> $GITHUB_OUTPUT + + echo "Releasing tag: ${TAG}" + echo "Releasing version: ${VERSION}" + + - name: Release + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + MAVEN_GPG_PASSPHRASE: ${{ secrets.GPG_PASSPHRASE }} + MAVEN_GPG_KEY: ${{ secrets.GPG_PRIVATE_KEY }} + MAVEN_USER: ${{ secrets.MAVEN_USER }} + MAVEN_PASSWORD: ${{ secrets.MAVEN_PASSWORD }} + run: | + mvn -B release:perform -Darguments="-DskipTests -DaltDeploymentRepository=id::default::njord: -Dnjord.autoPublish=true -Dnjord.publishingType=automatic" -s .github/release-settings.xml + + - name: Create GitHub Release + run: gh release create "${{ steps.version.outputs.released_tag }}" --generate-notes --title "Version ${{ steps.version.outputs.released_version }}" + env: + GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} \ No newline at end of file diff --git a/.gitignore b/.gitignore index 43d16bc..5a78c84 100644 --- a/.gitignore +++ b/.gitignore @@ -1,4 +1,11 @@ +.classpath +.settings +.project *.class +*.csv tags target/ tmp/ +/bin +.idea +*.iml diff --git a/.project b/.project deleted file mode 100644 index 0521b84..0000000 --- a/.project +++ /dev/null @@ -1,17 +0,0 @@ - - - JavaFastPFOR - - - - - - org.eclipse.jdt.core.javabuilder - - - - - - org.eclipse.jdt.core.javanature - - diff --git a/.travis.yml b/.travis.yml index a159cc4..427b879 100644 --- a/.travis.yml +++ b/.travis.yml @@ -1,10 +1,12 @@ language: java jdk: - - oraclejdk7 - - openjdk7 - - openjdk6 + - oraclejdk8 + - oraclejdk9 install: true -script: mvn test +script: mvn clean test jacoco:report + +after_success: + - mvn coveralls:report diff --git a/CHANGELOG b/CHANGELOG index eb8d2f0..1377346 100644 --- a/CHANGELOG +++ b/CHANGELOG @@ -1,4 +1,60 @@ -upcoming +0.1.10 (October 7th 2016) + - Fix for issue 36 https://github.com/lemire/JavaFastPFOR/issues/36 + +0.1.9 (September 14th 2016) + - Tuning GroupSimple9 + +0.1.8 (September 13th 2016) + - Added GroupSimple9 + +0.1.7 (April 22nd 2016) + - Documentation fix. + +0.1.4, 0.1.5, 0.1.6 (November 25th 2015) + - Added IntCompressor and IntegratedIntCompressor for users looking for a simpler API + +0.1.3 (June 19th 2015) + - Fixed issue #29: Composition not working properly when output offset != 0 (Saúl Vargas) + +0.1.2 (October 20th 2014) + - Fix a compatibility issue with the C++ version. + +0.1.1 (September 19th 2014) + - We now have two versions of FastPFOR (with blocks of 128 ints and 256 ints) and the format was streamlined. + - BinaryPacking and IntegratedBinaryPacking now use a block size of 32 (instead of 128). + +0.1.0 (September 18th 2014) + - Introduced skippable versions (for use in a search engine like Terrier) + +0.0.15 (September 9th 2014) + - Improved the performance of VariableByte schemes when used as a ByteIntegerCODEC + +0.0.14 (August 21st 2014) + - FastPFOR and VariableByte codecs made consistent with C++ version at https://github.com/lemire/FastPFor + - VariableByte made to use little endian encoding + +0.0.13 (July 23rd 2014) + - CODECs using differential coding are now in a separate package (me.lemire.integercompression.differential) + +0.0.12 (June 9th 2014) + - Better API documentation + +0.0.11 (Feb. 14th 2014) + - Fix rare bug in FastPFOR (reported by Stefan Ackermann (https://github.com/Stivo)) + - Improved API documentation + +0.0.10 (Jan. 25th 2014) + - cleaning the code and improving the documentation + +0.0.9 (Nov. 15th 2013) + - Improved BenchmarkCVS + - Improved comments slightly + - Fixed a rarely occuring bug in FastPFOR and IntegratedFastPFOR (reported by zhenjl) + +0.0.8 (Nov. 12th 2013) + - variable byte schemes can now be used without an unnecessary copy, if you have a byte[] output array + +0.0.7 - added two new (minor) codecs NewPFD16 and OptPFD16 0.0.6 (Sept. 4th 2013) diff --git a/README.md b/README.md index fb646d3..0246789 100644 --- a/README.md +++ b/README.md @@ -1,11 +1,9 @@ -JavaFastPFOR: A simple integer compression library in Java [![Build Status](https://travis-ci.org/lemire/JavaFastPFOR.png)](https://travis-ci.org/lemire/JavaFastPFOR) +JavaFastPFOR: A simple integer compression library in Java ========================================================== +[![](https://jitpack.io/v/fast-pack/JavaFastPFor.svg)](https://jitpack.io/#fast-pack/JavaFastPFor) [![][license img]][license] [![docs-badge][]][docs] +[![Java CI](https://github.com/lemire/JavaFastPFOR/actions/workflows/basic.yml/badge.svg)](https://github.com/lemire/JavaFastPFOR/actions/workflows/basic.yml) -License -------- -This code is released under the -Apache License Version 2.0 http://www.apache.org/licenses/. What does this do? @@ -13,86 +11,209 @@ What does this do? It is a library to compress and uncompress arrays of integers very fast. The assumption is that most (but not all) values in -your array use less than 32 bits. These sort of arrays often come up +your array use much less than 32 bits, or that the gaps between +the integers use much less than 32 bits. These sort of arrays often come up when using differential coding in databases and information retrieval (e.g., in inverted indexes or column stores). +Please note that random integers are not compressible, by this +library or by any other means. If you ever had the means of +systematically compressing random integers, you could compress +any data source to nothing, by recursive application of your technique. + +This library can decompress integers at a rate of over 1.2 billions per second +(4.5 GB/s). It is significantly faster than generic codecs (such +as Snappy, LZ4 and so on) when compressing arrays of integers. + +The library is used in [LinkedIn Pinot](https://github.com/linkedin/pinot), a realtime distributed OLAP datastore. +Part of this library has been integrated in Parquet (http://parquet.io/). +A modified version of the library is included in the search engine +Terrier (http://terrier.org/). This libary is used by ClueWeb +Tools (https://github.com/lintool/clueweb). It is also used by [Apache NiFi](https://nifi.apache.org). + +This library inspired a compression scheme used by Apache Lucene and Apache Lucene.NET (e.g., see +http://lucene.apache.org/core/4_6_1/core/org/apache/lucene/util/PForDeltaDocIdSet.html ). + +It is a java port of the fastpfor C++ library (https://github.com/lemire/FastPFor). +There is also a Go port (https://github.com/reducedb/encoding). The C++ +library is used by the zsearch engine (http://victorparmar.github.com/zsearch/) +as well as in GMAP and GSNAP (http://research-pub.gene.com/gmap/). + + +Usage +------ + + +```java +package org.example; + +import me.lemire.integercompression.FastPFOR128; +import me.lemire.integercompression.IntWrapper; + +import java.util.Arrays; + +public class Main { + public static void main(String[] args) { + FastPFOR128 fastpfor = new FastPFOR128(); + + int N = 9984; + int[] data = new int[N]; + for (var i = 0; i < N; i += 150) { + data[i] = i; + } + + int[] compressedoutput1 = new int[N + 1024]; + + IntWrapper inputoffset1 = new IntWrapper(0); + IntWrapper outputoffset1 = new IntWrapper(0); + + fastpfor.compress(data, inputoffset1, N, compressedoutput1, outputoffset1); + int compressedsize1 = outputoffset1.get(); + + int[] recovered1 = new int[N]; + inputoffset1 = new IntWrapper(0); + outputoffset1 = new IntWrapper(0); + fastpfor.uncompress(compressedoutput1, outputoffset1, compressedsize1, recovered1, inputoffset1); + + // quick verification: count mismatches + int mismatches = 0; + for (int i = 0; i < N; i++) { + if (data[i] != recovered1[i]) mismatches++; + } + + System.out.println("N=" + N + " compressedSizeWords=" + compressedsize1 + " mismatches=" + mismatches); + System.out.println("first 20 original: " + Arrays.toString(Arrays.copyOf(data, 20))); + System.out.println("first 20 recovered: " + Arrays.toString(Arrays.copyOf(recovered1, 20))); + } +} + +``` + +For more examples, see example.java or the examples folder. + +JavaFastPFOR supports compressing and uncompressing data in chunks (e.g., see ``advancedExample`` in [https://github.com/lemire/JavaFastPFOR/blob/master/example.java](example.java)). + Some CODECs ("integrated codecs") assume that the integers are -in sorted orders. Most others do not. +in sorted orders and use differential coding (they compress deltas). +They can be found in the package me.lemire.integercompression.differential. +Most others do not. +The Java Team at Intel (R) introduced the vector implementation for FastPFOR +based on the Java Vector API that showed significant gains over the +non-vectorized implementation. For an example usage, see +examples/vector/Example.java. The feature requires JDK 19+ and is currently for +advanced users. -Maven central repository +JavaFastPFOR as a dependency ------------------------ -Using this code in your own project is easy with maven, just add -the following code in your pom.xml file: +JavaFastPFOR is available both on Maven Central and JitPack, so you can easily +include it in your project using either source. +We have a demo project using JavaFastPFOR as a dependency (both Maven and Gradle). See... - - - me.lemire.integercompression - JavaFastPFOR - 0.0.6 - - +https://github.com/fast-pack/JavaFastPFORDemo -Naturally, you should replace "version" by the version -you desire. +### Maven Central +You can add JavaFastPFOR directly from Maven Central — no extra repository configuration needed: +**Maven** -You can also download JavaFastPFOR from the Maven central repository: -http://repo1.maven.org/maven2/me/lemire/integercompression/JavaFastPFOR/ +```xml + + me.lemire.integercompression + JavaFastPFOR + 0.3.8 + +``` +**Gradle (Groovy)** -Why? ----- +```groovy +dependencies { + implementation 'me.lemire.integercompression:JavaFastPFOR:0.3.8' +} +``` + +### JitPack + +If you prefer or need to use JitPack, you can include the dependency like this: + +**Maven** -We found no library that implemented state-of-the-art integer coding techniques -such as Binary Packing, NewPFD, OptPFD, Variable Byte, Simple 9 and so on in Java. -We wrote one. +```xml + + + jitpack.io + https://jitpack.io + + + + com.github.fast-pack + JavaFastPFOR + JavaFastPFOR-0.3.8 + +``` -Authors -------- +**Gradle (groovy)** -Main contributors -Daniel Lemire, http://lemire.me/en/ -Muraoka Taro, https://github.com/koron +```groovy +repositories { + mavenCentral() + maven { + url 'https://jitpack.io' + } +} -with contributions by -Di Wu, http://www.facebook.com/diwu1989 +dependencies { + implementation 'com.github.fast-pack:JavaFastPFOR:JavaFastPFOR-0.3.8' +} +``` +Naturally, you should replace "version" by the version +you desire. + + +Thread safety +---- + +Some codecs are thread-safe while others are not. +For this reason, it is best to use one codec per thread. +The memory usage of a codec instance is small in any case. + +Nevertheless, if you want to reuse codec instances, +note that by convention, unless the documentation of a codec specify +that it is not thread-safe, then it can be assumed to be thread-safe. How does it compare to the Kamikaze PForDelta library? ------------------------------------------------------ -In our tests, Kamikaze PForDelta does not fare well. See +In our tests, Kamikaze PForDelta is slower than our implementations. See the benchmarkresults directory for some results. https://github.com/lemire/JavaFastPFOR/blob/master/benchmarkresults/benchmarkresults_icore7_10may2013.txt -Requirements ------------- -A recent Java compiler. Java 7 or better is recommended. +Reference: + http://sna-projects.com/kamikaze/ + -Good instructions on installing Java 7 on Linux: -http://forums.linuxmint.com/viewtopic.php?f=42&t=93052 +Requirements +------------ + +Releases up to 0.1.12 require Java 7 or better. -Usage ------ +The current development versions assume JDK 21 or better. -See example.java for a simple demonstration. How fast is it? --------------- -Compile the code and execute me.lemire.integercompression.Benchmark. - -I recommend running all the benchmarks with the "-server" flag on a desktop machine. +Compile the code and execute `me.lemire.integercompression.benchmarktools.Benchmark`. Speed is always reported in millions of integers per second. @@ -100,11 +221,21 @@ Speed is always reported in millions of integers per second. For Maven users --------------- -mvn compile +``` +mvn compile mvn exec:java +``` -For ant users +You may run our examples as follows: + +``` +mvn package +javac -cp target/classes/:. example.java +java -cp target/classes/:. example +``` + +For ant users (legacy, currently untested) ------------- If you use Apache ant, please try this: @@ -116,13 +247,67 @@ or: $ ant Benchmark -Dbenchmark.target=BenchmarkBitPacking +API Documentation +----------------- + +http://www.javadoc.io/doc/me.lemire.integercompression/JavaFastPFOR/ + + +Citing this work +----------------- + +If you use JavaFastPFOR in your work, please consider citing the project. A recommended BibTeX entry is: + +```bibtex +@misc{lemire2025_javafastpfor, + author = {Daniel Lemire}, + title = {{JavaFastPFOR: A simple integer compression library in Java}}, + year = {2025}, + howpublished = {\url{https://github.com/fast-pack/JavaFastPFOR}}, +} +``` + Want to read more? ------------------ -We wrote a research paper which documents many of the CODECs implemented here: +This library was a key ingredient in the best paper at ECIR 2014 : + +Matteo Catena, Craig Macdonald, Iadh Ounis, On Inverted Index Compression for Search Engine Efficiency, Lecture Notes in Computer Science 8416 (ECIR 2014), 2014. +http://dx.doi.org/10.1007/978-3-319-06028-6_30 + +We wrote several research papers documenting many of the CODECs implemented here: + +* Daniel Lemire, Nathan Kurz, Christoph Rupp, Stream VByte: Faster Byte-Oriented Integer Compression, Information Processing Letters (to appear) https://arxiv.org/abs/1709.08990 +* Daniel Lemire, Leonid Boytsov, Nathan Kurz, SIMD Compression and the Intersection of Sorted Integers, Software Practice & Experience Volume 46, Issue 6, pages 723-749, June 2016 http://arxiv.org/abs/1401.6399 +* Daniel Lemire and Leonid Boytsov, Decoding billions of integers per second through vectorization, Software Practice & Experience 45 (1), 2015. http://arxiv.org/abs/1209.2137 http://onlinelibrary.wiley.com/doi/10.1002/spe.2203/abstract +* Jeff Plaisance, Nathan Kurz, Daniel Lemire, Vectorized VByte Decoding, International Symposium on Web Algorithms 2015, 2015. http://arxiv.org/abs/1503.07387 +* Wayne Xin Zhao, Xudong Zhang, Daniel Lemire, Dongdong Shan, Jian-Yun Nie, Hongfei Yan, Ji-Rong Wen, A General SIMD-based Approach to Accelerating Compression Algorithms, ACM Transactions on Information Systems 33 (3), 2015. http://arxiv.org/abs/1502.01916 + + +Ikhtear Sharif wrote his M.Sc. thesis on this library: + +Ikhtear Sharif, Performance Evaluation of Fast Integer Compression Techniques Over Tables, M.Sc. thesis, UNB 2013. +https://unbscholar.lib.unb.ca/islandora/object/unbscholar%3A9399/datastream/PDF/view + +He also posted his slides online: http://www.slideshare.net/ikhtearSharif/ikhtear-defense + +Other recommended libraries +----------------------------- + +* Fast integer compression in Go: https://github.com/ronanh/intcomp +* Encoding: Integer Compression Libraries for Go https://github.com/zhenjl/encoding +* CSharpFastPFOR: A C# integer compression library https://github.com/Genbox/CSharpFastPFOR +* TurboPFor is a C library that offers lots of interesting optimizations and Java wrappers. Well worth checking! (Uses a GPL license.) https://github.com/powturbo/TurboPFor + +Funding +----------- + +This work was supported by NSERC grant number 26143. -Daniel Lemire and Leonid Boytsov, Decoding billions of integers per second through vectorization, Software Pratice & Experience (to appear) -http://arxiv.org/abs/1209.2137 +[license]:LICENSE +[license img]:https://img.shields.io/badge/License-Apache%202-blue.svg +[docs-badge]:https://img.shields.io/badge/API-docs-blue.svg?style=flat-square +[docs]:http://www.javadoc.io/doc/me.lemire.integercompression/JavaFastPFOR/ diff --git a/benchmarkresults/benchmarkresults_haswell_18sept2014.txt b/benchmarkresults/benchmarkresults_haswell_18sept2014.txt new file mode 100644 index 0000000..a501d5d --- /dev/null +++ b/benchmarkresults/benchmarkresults_haswell_18sept2014.txt @@ -0,0 +1,861 @@ +# benchmark based on the ClusterData model from: +# Vo Ngoc Anh and Alistair Moffat. +# Index compression using 64-bit words. +# Softw. Pract. Exper.40, 2 (February 2010), 131-147. + +# Results will be written into a CSV file: benchmark-20140918T011257.csv + +# sparsity 1 +# generating random data... +# generating random data... ok. +# FastPFOR + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 2.56 246 1061 + +# kamikaze PForDelta +# bits per int, compress speed (mis), decompression speed (mis) + 3.21 66 275 + +# IntegratedBinaryPacking + IntegratedVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 2.96 838 1679 + +# JustCopy +# bits per int, compress speed (mis), decompression speed (mis) + 32.00 1276 1805 + +# VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.00 490 509 + +# IntegratedVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.00 582 774 + +# BinaryPacking + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 2.96 765 1193 + +# NewPFD + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 2.88 139 896 + +# NewPFDS9 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 2.90 166 905 + +# NewPFDS16 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 2.88 139 898 + +# OptPFD + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 2.87 25 938 + +# OptPFDS9 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 2.90 29 960 + +# OptPFDS16 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 2.87 25 882 + +# IntegratedFastPFOR + IntegratedVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 2.63 274 1015 + +# Simple9 +# bits per int, compress speed (mis), decompression speed (mis) + 2.83 280 771 + +# XorBinaryPacking + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 2.84 444 837 + +# DeltaZigzagBinaryPacking + DeltaZigzagVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 3.27 498 652 + +# sparsity 2 +# generating random data... +# generating random data... ok. +# FastPFOR + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 3.51 244 1048 + +# kamikaze PForDelta +# bits per int, compress speed (mis), decompression speed (mis) + 4.18 55 247 + +# IntegratedBinaryPacking + IntegratedVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 3.93 862 1611 + +# JustCopy +# bits per int, compress speed (mis), decompression speed (mis) + 32.00 1286 1816 + +# VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.01 486 508 + +# IntegratedVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.01 575 763 + +# BinaryPacking + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 3.93 774 1159 + +# NewPFD + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 3.83 118 865 + +# NewPFDS9 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 3.86 141 875 + +# NewPFDS16 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 3.83 118 867 + +# OptPFD + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 3.82 18 881 + +# OptPFDS9 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 3.85 22 887 + +# OptPFDS16 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 3.82 18 838 + +# IntegratedFastPFOR + IntegratedVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 3.58 273 990 + +# Simple9 +# bits per int, compress speed (mis), decompression speed (mis) + 3.82 201 656 + +# XorBinaryPacking + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 3.90 442 819 + +# DeltaZigzagBinaryPacking + DeltaZigzagVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 4.50 494 640 + +# sparsity 3 +# generating random data... +# generating random data... ok. +# FastPFOR + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 4.28 244 1030 + +# kamikaze PForDelta +# bits per int, compress speed (mis), decompression speed (mis) + 4.95 51 247 + +# IntegratedBinaryPacking + IntegratedVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 4.71 850 1577 + +# JustCopy +# bits per int, compress speed (mis), decompression speed (mis) + 32.00 1252 1769 + +# VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.02 478 504 + +# IntegratedVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.02 573 762 + +# BinaryPacking + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 4.71 770 1139 + +# NewPFD + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 4.60 107 850 + +# NewPFDS9 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 4.63 127 863 + +# NewPFDS16 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 4.60 107 853 + +# OptPFD + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 4.59 14 865 + +# OptPFDS9 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 4.62 18 882 + +# OptPFDS16 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 4.59 14 844 + +# IntegratedFastPFOR + IntegratedVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 4.34 268 969 + +# Simple9 +# bits per int, compress speed (mis), decompression speed (mis) + 4.72 170 610 + +# XorBinaryPacking + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 4.68 434 783 + +# DeltaZigzagBinaryPacking + DeltaZigzagVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 5.33 472 624 + +# sparsity 4 +# generating random data... +# generating random data... ok. +# FastPFOR + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 5.03 239 1004 + +# kamikaze PForDelta +# bits per int, compress speed (mis), decompression speed (mis) + 5.73 47 251 + +# IntegratedBinaryPacking + IntegratedVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 5.48 846 1556 + +# JustCopy +# bits per int, compress speed (mis), decompression speed (mis) + 32.00 1274 1799 + +# VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.12 439 486 + +# IntegratedVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.12 537 715 + +# BinaryPacking + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 5.48 769 1134 + +# NewPFD + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 5.36 95 817 + +# NewPFDS9 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 5.39 115 838 + +# NewPFDS16 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 5.36 96 827 + +# OptPFD + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 5.34 12 842 + +# OptPFDS9 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 5.37 16 871 + +# OptPFDS16 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 5.34 12 803 + +# IntegratedFastPFOR + IntegratedVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 5.09 268 963 + +# Simple9 +# bits per int, compress speed (mis), decompression speed (mis) + 5.57 150 587 + +# XorBinaryPacking + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 5.47 432 800 + +# DeltaZigzagBinaryPacking + DeltaZigzagVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 6.16 491 635 + +# sparsity 5 +# generating random data... +# generating random data... ok. +# FastPFOR + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 6.00 236 999 + +# kamikaze PForDelta +# bits per int, compress speed (mis), decompression speed (mis) + 6.70 43 242 + +# IntegratedBinaryPacking + IntegratedVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 6.45 863 1584 + +# JustCopy +# bits per int, compress speed (mis), decompression speed (mis) + 32.00 1236 1792 + +# VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.40 369 452 + +# IntegratedVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.40 486 617 + +# BinaryPacking + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 6.45 777 1132 + +# NewPFD + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 6.33 86 808 + +# NewPFDS9 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 6.36 103 828 + +# NewPFDS16 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 6.33 86 813 + +# OptPFD + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 6.31 9 825 + +# OptPFDS9 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 6.34 13 858 + +# OptPFDS16 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 6.31 9 819 + +# IntegratedFastPFOR + IntegratedVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 6.06 265 945 + +# Simple9 +# bits per int, compress speed (mis), decompression speed (mis) + 6.65 139 546 + +# XorBinaryPacking + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 6.45 442 804 + +# DeltaZigzagBinaryPacking + DeltaZigzagVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 7.18 493 635 + +# sparsity 6 +# generating random data... +# generating random data... ok. +# FastPFOR + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 6.76 238 998 + +# kamikaze PForDelta +# bits per int, compress speed (mis), decompression speed (mis) + 7.45 42 251 + +# IntegratedBinaryPacking + IntegratedVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 7.20 854 1525 + +# JustCopy +# bits per int, compress speed (mis), decompression speed (mis) + 32.00 1177 1663 + +# VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 9.10 259 362 + +# IntegratedVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 9.10 380 450 + +# BinaryPacking + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 7.20 718 1098 + +# NewPFD + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 7.08 79 786 + +# NewPFDS9 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 7.11 95 821 + +# NewPFDS16 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 7.08 81 814 + +# OptPFD + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 7.06 8 836 + +# OptPFDS9 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 7.09 11 860 + +# OptPFDS16 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 7.06 8 822 + +# IntegratedFastPFOR + IntegratedVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 6.81 268 962 + +# Simple9 +# bits per int, compress speed (mis), decompression speed (mis) + 7.56 129 509 + +# XorBinaryPacking + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 7.19 433 789 + +# DeltaZigzagBinaryPacking + DeltaZigzagVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 7.93 491 632 + +# sparsity 7 +# generating random data... +# generating random data... ok. +# FastPFOR + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.05 236 985 + +# kamikaze PForDelta +# bits per int, compress speed (mis), decompression speed (mis) + 8.75 39 247 + +# IntegratedBinaryPacking + IntegratedVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.50 861 1526 + +# JustCopy +# bits per int, compress speed (mis), decompression speed (mis) + 32.00 1279 1788 + +# VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 10.11 190 305 + +# IntegratedVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 10.11 311 355 + +# BinaryPacking + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.50 753 1092 + +# NewPFD + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.37 71 792 + +# NewPFDS9 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.40 83 804 + +# NewPFDS16 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.37 72 805 + +# OptPFD + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.35 7 808 + +# OptPFDS9 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.38 10 835 + +# OptPFDS16 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.35 7 796 + +# IntegratedFastPFOR + IntegratedVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.10 259 920 + +# Simple9 +# bits per int, compress speed (mis), decompression speed (mis) + 9.16 111 447 + +# XorBinaryPacking + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.52 435 784 + +# DeltaZigzagBinaryPacking + DeltaZigzagVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 9.32 485 622 + +# sparsity 8 +# generating random data... +# generating random data... ok. +# FastPFOR + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.73 234 972 + +# kamikaze PForDelta +# bits per int, compress speed (mis), decompression speed (mis) + 9.44 37 250 + +# IntegratedBinaryPacking + IntegratedVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 9.19 848 1493 + +# JustCopy +# bits per int, compress speed (mis), decompression speed (mis) + 32.00 1279 1858 + +# VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 11.04 167 307 + +# IntegratedVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 11.04 309 353 + +# BinaryPacking + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 9.19 751 1095 + +# NewPFD + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 9.06 67 770 + +# NewPFDS9 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 9.09 78 781 + +# NewPFDS16 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 9.06 68 792 + +# OptPFD + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 9.03 6 795 + +# OptPFDS9 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 9.07 9 824 + +# OptPFDS16 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 9.03 6 787 + +# IntegratedFastPFOR + IntegratedVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.78 266 936 + +# Simple9 +# bits per int, compress speed (mis), decompression speed (mis) + 10.34 101 427 + +# XorBinaryPacking + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 9.21 437 794 + +# DeltaZigzagBinaryPacking + DeltaZigzagVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 10.01 488 626 + +# sparsity 9 +# generating random data... +# generating random data... ok. +# FastPFOR + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 9.75 234 980 + +# kamikaze PForDelta +# bits per int, compress speed (mis), decompression speed (mis) + 10.48 36 242 + +# IntegratedBinaryPacking + IntegratedVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 10.21 844 1474 + +# JustCopy +# bits per int, compress speed (mis), decompression speed (mis) + 32.00 1262 1795 + +# VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 12.18 145 300 + +# IntegratedVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 12.18 302 340 + +# BinaryPacking + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 10.21 761 1096 + +# NewPFD + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 10.08 63 786 + +# NewPFDS9 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 10.12 72 752 + +# NewPFDS16 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 10.08 63 783 + +# OptPFD + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 10.05 6 787 + +# OptPFDS9 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 10.09 8 798 + +# OptPFDS16 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 10.05 6 779 + +# IntegratedFastPFOR + IntegratedVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 9.80 264 930 + +# Simple9 +# bits per int, compress speed (mis), decompression speed (mis) + 11.77 92 410 + +# XorBinaryPacking + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 10.23 438 789 + +# DeltaZigzagBinaryPacking + DeltaZigzagVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 11.05 486 624 + +# sparsity 10 +# generating random data... +# generating random data... ok. +# FastPFOR + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 10.73 235 979 + +# kamikaze PForDelta +# bits per int, compress speed (mis), decompression speed (mis) + 11.46 35 239 + +# IntegratedBinaryPacking + IntegratedVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 11.18 840 1456 + +# JustCopy +# bits per int, compress speed (mis), decompression speed (mis) + 32.00 1248 1746 + +# VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 13.14 135 312 + +# IntegratedVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 13.14 309 354 + +# BinaryPacking + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 11.18 761 1097 + +# NewPFD + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 11.09 59 802 + +# NewPFDS9 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 11.13 69 814 + +# NewPFDS16 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 11.09 59 771 + +# OptPFD + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 11.04 5 783 + +# OptPFDS9 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 11.08 8 816 + +# OptPFDS16 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 11.04 5 776 + +# IntegratedFastPFOR + IntegratedVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 10.78 265 934 + +# Simple9 +# bits per int, compress speed (mis), decompression speed (mis) + 12.98 89 415 + +# XorBinaryPacking + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 11.20 436 787 + +# DeltaZigzagBinaryPacking + DeltaZigzagVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 12.02 483 620 + +# sparsity 11 +# generating random data... +# generating random data... ok. +# FastPFOR + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 11.79 232 950 + +# kamikaze PForDelta +# bits per int, compress speed (mis), decompression speed (mis) + 12.68 34 256 + +# IntegratedBinaryPacking + IntegratedVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 12.23 842 1450 + +# JustCopy +# bits per int, compress speed (mis), decompression speed (mis) + 32.00 1292 1826 + +# VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 14.00 127 324 + +# IntegratedVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 14.00 308 369 + +# BinaryPacking + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 12.23 760 1092 + +# NewPFD + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 12.35 56 795 + +# NewPFDS9 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 12.38 65 829 + +# NewPFDS16 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 12.35 57 822 + +# OptPFD + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 12.13 5 706 + +# OptPFDS9 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 12.17 7 750 + +# OptPFDS16 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 12.13 5 712 + +# IntegratedFastPFOR + IntegratedVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 11.83 261 919 + +# Simple9 +# bits per int, compress speed (mis), decompression speed (mis) + 14.17 85 401 + +# XorBinaryPacking + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 12.25 436 781 + +# DeltaZigzagBinaryPacking + DeltaZigzagVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 13.08 489 623 + +# sparsity 12 +# generating random data... +# generating random data... ok. +# FastPFOR + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 12.70 226 932 + +# kamikaze PForDelta +# bits per int, compress speed (mis), decompression speed (mis) + 13.76 34 261 + +# IntegratedBinaryPacking + IntegratedVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 13.16 849 1453 + +# JustCopy +# bits per int, compress speed (mis), decompression speed (mis) + 32.00 1208 1804 + +# VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 14.84 117 307 + +# IntegratedVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 14.84 260 352 + +# BinaryPacking + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 13.16 762 1095 + +# NewPFD + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 13.46 56 899 + +# NewPFDS9 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 13.48 63 915 + +# NewPFDS16 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 13.46 56 897 + +# OptPFD + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 13.20 5 681 + +# OptPFDS9 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 13.24 7 735 + +# OptPFDS16 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 13.20 5 699 + +# IntegratedFastPFOR + IntegratedVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 12.75 260 914 + +# Simple9 +# bits per int, compress speed (mis), decompression speed (mis) + 15.51 80 359 + +# XorBinaryPacking + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 13.18 435 781 + +# DeltaZigzagBinaryPacking + DeltaZigzagVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 14.00 489 626 + + +Results were written into a CSV file: benchmark-20140918T011257.csv diff --git a/benchmarkresults/benchmarkresults_icore7_10may2013.txt b/benchmarkresults/benchmarkresults_icore7_10may2013.txt index 5b776fb..d10579e 100644 --- a/benchmarkresults/benchmarkresults_icore7_10may2013.txt +++ b/benchmarkresults/benchmarkresults_icore7_10may2013.txt @@ -3,610 +3,610 @@ # generating random data... ok. # kamikaze PForDelta # bits per int, compress speed (mis), decompression speed (mis) - 3.34 51 262 + 3.34 51 262 # me.lemire.integercompression.IntegratedBinaryPacking+me.lemire.integercompression.IntegratedVariableByte # bits per int, compress speed (mis), decompression speed (mis) - 3.09 639 1183 + 3.09 639 1183 # me.lemire.integercompression.JustCopy # bits per int, compress speed (mis), decompression speed (mis) - 32.00 1151 1468 + 32.00 1151 1468 # me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 8.00 199 299 + 8.00 199 299 # me.lemire.integercompression.IntegratedVariableByte # bits per int, compress speed (mis), decompression speed (mis) - 8.00 148 339 + 8.00 148 339 # me.lemire.integercompression.BinaryPacking+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 3.09 613 920 + 3.09 613 920 # me.lemire.integercompression.NewPFD+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 3.02 143 721 + 3.02 143 721 # me.lemire.integercompression.NewPFDS9+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 3.05 164 705 + 3.05 164 705 # me.lemire.integercompression.OptPFD+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 3.01 26 790 + 3.01 26 790 # me.lemire.integercompression.OptPFDS9+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 3.03 30 816 + 3.03 30 816 # me.lemire.integercompression.FastPFOR+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 2.78 226 811 + 2.78 226 811 # me.lemire.integercompression.Simple9 # bits per int, compress speed (mis), decompression speed (mis) - 2.97 236 604 + 2.97 236 604 # sparsity 2 # generating random data... # generating random data... ok. # kamikaze PForDelta # bits per int, compress speed (mis), decompression speed (mis) - 4.17 47 266 + 4.17 47 266 # me.lemire.integercompression.IntegratedBinaryPacking+me.lemire.integercompression.IntegratedVariableByte # bits per int, compress speed (mis), decompression speed (mis) - 3.92 672 1261 + 3.92 672 1261 # me.lemire.integercompression.JustCopy # bits per int, compress speed (mis), decompression speed (mis) - 32.00 1218 1562 + 32.00 1218 1562 # me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 8.00 204 290 + 8.00 204 290 # me.lemire.integercompression.IntegratedVariableByte # bits per int, compress speed (mis), decompression speed (mis) - 8.00 236 343 + 8.00 236 343 # me.lemire.integercompression.BinaryPacking+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 3.92 505 917 + 3.92 505 917 # me.lemire.integercompression.NewPFD+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 3.82 127 698 + 3.82 127 698 # me.lemire.integercompression.NewPFDS9+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 3.85 151 726 + 3.85 151 726 # me.lemire.integercompression.OptPFD+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 3.81 18 752 + 3.81 18 752 # me.lemire.integercompression.OptPFDS9+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 3.84 23 779 + 3.84 23 779 # me.lemire.integercompression.FastPFOR+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 3.56 228 828 + 3.56 228 828 # me.lemire.integercompression.Simple9 # bits per int, compress speed (mis), decompression speed (mis) - 3.82 182 562 + 3.82 182 562 # sparsity 3 # generating random data... # generating random data... ok. # kamikaze PForDelta # bits per int, compress speed (mis), decompression speed (mis) - 4.96 43 276 + 4.96 43 276 # me.lemire.integercompression.IntegratedBinaryPacking+me.lemire.integercompression.IntegratedVariableByte # bits per int, compress speed (mis), decompression speed (mis) - 4.72 662 1187 + 4.72 662 1187 # me.lemire.integercompression.JustCopy # bits per int, compress speed (mis), decompression speed (mis) - 32.00 1215 1566 + 32.00 1215 1566 # me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 8.02 198 286 + 8.02 198 286 # me.lemire.integercompression.IntegratedVariableByte # bits per int, compress speed (mis), decompression speed (mis) - 8.02 254 340 + 8.02 254 340 # me.lemire.integercompression.BinaryPacking+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 4.72 576 848 + 4.72 576 848 # me.lemire.integercompression.NewPFD+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 4.61 111 654 + 4.61 111 654 # me.lemire.integercompression.NewPFDS9+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 4.64 129 699 + 4.64 129 699 # me.lemire.integercompression.OptPFD+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 4.60 14 732 + 4.60 14 732 # me.lemire.integercompression.OptPFDS9+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 4.63 18 761 + 4.63 18 761 # me.lemire.integercompression.FastPFOR+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 4.36 226 813 + 4.36 226 813 # me.lemire.integercompression.Simple9 # bits per int, compress speed (mis), decompression speed (mis) - 4.76 148 511 + 4.76 148 511 # sparsity 4 # generating random data... # generating random data... ok. # kamikaze PForDelta # bits per int, compress speed (mis), decompression speed (mis) - 5.97 39 270 + 5.97 39 270 # me.lemire.integercompression.IntegratedBinaryPacking+me.lemire.integercompression.IntegratedVariableByte # bits per int, compress speed (mis), decompression speed (mis) - 5.72 656 1148 + 5.72 656 1148 # me.lemire.integercompression.JustCopy # bits per int, compress speed (mis), decompression speed (mis) - 32.00 1212 1555 + 32.00 1212 1555 # me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 8.09 206 287 + 8.09 206 287 # me.lemire.integercompression.IntegratedVariableByte # bits per int, compress speed (mis), decompression speed (mis) - 8.09 213 334 + 8.09 213 334 # me.lemire.integercompression.BinaryPacking+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 5.72 626 891 + 5.72 626 891 # me.lemire.integercompression.NewPFD+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 5.60 105 672 + 5.60 105 672 # me.lemire.integercompression.NewPFDS9+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 5.63 121 701 + 5.63 121 701 # me.lemire.integercompression.OptPFD+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 5.58 10 667 + 5.58 10 667 # me.lemire.integercompression.OptPFDS9+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 5.62 14 736 + 5.62 14 736 # me.lemire.integercompression.FastPFOR+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 5.33 226 805 + 5.33 226 805 # me.lemire.integercompression.Simple9 # bits per int, compress speed (mis), decompression speed (mis) - 5.86 123 464 + 5.86 123 464 # sparsity 5 # generating random data... # generating random data... ok. # kamikaze PForDelta # bits per int, compress speed (mis), decompression speed (mis) - 6.49 39 262 + 6.49 39 262 # me.lemire.integercompression.IntegratedBinaryPacking+me.lemire.integercompression.IntegratedVariableByte # bits per int, compress speed (mis), decompression speed (mis) - 6.25 659 1121 + 6.25 659 1121 # me.lemire.integercompression.JustCopy # bits per int, compress speed (mis), decompression speed (mis) - 32.00 1154 1168 + 32.00 1154 1168 # me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 8.44 192 265 + 8.44 192 265 # me.lemire.integercompression.IntegratedVariableByte # bits per int, compress speed (mis), decompression speed (mis) - 8.44 240 297 + 8.44 240 297 # me.lemire.integercompression.BinaryPacking+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 6.25 631 907 + 6.25 631 907 # me.lemire.integercompression.NewPFD+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 6.13 101 685 + 6.13 101 685 # me.lemire.integercompression.NewPFDS9+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 6.16 116 714 + 6.16 116 714 # me.lemire.integercompression.OptPFD+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 6.11 9 708 + 6.11 9 708 # me.lemire.integercompression.OptPFDS9+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 6.14 13 741 + 6.14 13 741 # me.lemire.integercompression.FastPFOR+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 5.86 225 806 + 5.86 225 806 # me.lemire.integercompression.Simple9 # bits per int, compress speed (mis), decompression speed (mis) - 6.44 120 442 + 6.44 120 442 # sparsity 6 # generating random data... # generating random data... ok. # kamikaze PForDelta # bits per int, compress speed (mis), decompression speed (mis) - 7.64 35 269 + 7.64 35 269 # me.lemire.integercompression.IntegratedBinaryPacking+me.lemire.integercompression.IntegratedVariableByte # bits per int, compress speed (mis), decompression speed (mis) - 7.39 654 1111 + 7.39 654 1111 # me.lemire.integercompression.JustCopy # bits per int, compress speed (mis), decompression speed (mis) - 32.00 1207 1553 + 32.00 1207 1553 # me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 9.06 185 225 + 9.06 185 225 # me.lemire.integercompression.IntegratedVariableByte # bits per int, compress speed (mis), decompression speed (mis) - 9.06 166 248 + 9.06 166 248 # me.lemire.integercompression.BinaryPacking+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 7.39 620 888 + 7.39 620 888 # me.lemire.integercompression.NewPFD+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 7.26 91 679 + 7.26 91 679 # me.lemire.integercompression.NewPFDS9+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 7.30 104 704 + 7.30 104 704 # me.lemire.integercompression.OptPFD+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 7.24 7 704 + 7.24 7 704 # me.lemire.integercompression.OptPFDS9+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 7.28 10 735 + 7.28 10 735 # me.lemire.integercompression.FastPFOR+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 7.00 221 792 + 7.00 221 792 # me.lemire.integercompression.Simple9 # bits per int, compress speed (mis), decompression speed (mis) - 7.76 106 393 + 7.76 106 393 # sparsity 7 # generating random data... # generating random data... ok. # kamikaze PForDelta # bits per int, compress speed (mis), decompression speed (mis) - 8.66 33 266 + 8.66 33 266 # me.lemire.integercompression.IntegratedBinaryPacking+me.lemire.integercompression.IntegratedVariableByte # bits per int, compress speed (mis), decompression speed (mis) - 8.41 675 1165 + 8.41 675 1165 # me.lemire.integercompression.JustCopy # bits per int, compress speed (mis), decompression speed (mis) - 32.00 1210 1553 + 32.00 1210 1553 # me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 10.10 154 194 + 10.10 154 194 # me.lemire.integercompression.IntegratedVariableByte # bits per int, compress speed (mis), decompression speed (mis) - 10.10 176 207 + 10.10 176 207 # me.lemire.integercompression.BinaryPacking+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 8.41 628 896 + 8.41 628 896 # me.lemire.integercompression.NewPFD+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 8.27 84 643 + 8.27 84 643 # me.lemire.integercompression.NewPFDS9+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 8.31 95 685 + 8.31 95 685 # me.lemire.integercompression.OptPFD+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 8.25 6 693 + 8.25 6 693 # me.lemire.integercompression.OptPFDS9+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 8.29 9 723 + 8.29 9 723 # me.lemire.integercompression.FastPFOR+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 8.00 215 773 + 8.00 215 773 # me.lemire.integercompression.Simple9 # bits per int, compress speed (mis), decompression speed (mis) - 9.10 94 357 + 9.10 94 357 # sparsity 8 # generating random data... # generating random data... ok. # kamikaze PForDelta # bits per int, compress speed (mis), decompression speed (mis) - 9.52 32 241 + 9.52 32 241 # me.lemire.integercompression.IntegratedBinaryPacking+me.lemire.integercompression.IntegratedVariableByte # bits per int, compress speed (mis), decompression speed (mis) - 9.26 692 1194 + 9.26 692 1194 # me.lemire.integercompression.JustCopy # bits per int, compress speed (mis), decompression speed (mis) - 32.00 1208 1525 + 32.00 1208 1525 # me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 11.14 138 178 + 11.14 138 178 # me.lemire.integercompression.IntegratedVariableByte # bits per int, compress speed (mis), decompression speed (mis) - 11.14 187 190 + 11.14 187 190 # me.lemire.integercompression.BinaryPacking+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 9.26 647 893 + 9.26 647 893 # me.lemire.integercompression.NewPFD+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 9.14 79 655 + 9.14 79 655 # me.lemire.integercompression.NewPFDS9+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 9.18 88 684 + 9.18 88 684 # me.lemire.integercompression.OptPFD+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 9.11 6 680 + 9.11 6 680 # me.lemire.integercompression.OptPFDS9+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 9.15 8 712 + 9.15 8 712 # me.lemire.integercompression.FastPFOR+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 8.86 220 778 + 8.86 220 778 # me.lemire.integercompression.Simple9 # bits per int, compress speed (mis), decompression speed (mis) - 10.39 86 330 + 10.39 86 330 # sparsity 9 # generating random data... # generating random data... ok. # kamikaze PForDelta # bits per int, compress speed (mis), decompression speed (mis) - 10.46 31 253 + 10.46 31 253 # me.lemire.integercompression.IntegratedBinaryPacking+me.lemire.integercompression.IntegratedVariableByte # bits per int, compress speed (mis), decompression speed (mis) - 10.19 661 1122 + 10.19 661 1122 # me.lemire.integercompression.JustCopy # bits per int, compress speed (mis), decompression speed (mis) - 32.00 1210 1546 + 32.00 1210 1546 # me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 12.27 126 173 + 12.27 126 173 # me.lemire.integercompression.IntegratedVariableByte # bits per int, compress speed (mis), decompression speed (mis) - 12.27 155 181 + 12.27 155 181 # me.lemire.integercompression.BinaryPacking+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 10.19 617 886 + 10.19 617 886 # me.lemire.integercompression.NewPFD+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 10.07 73 634 + 10.07 73 634 # me.lemire.integercompression.NewPFDS9+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 10.11 82 669 + 10.11 82 669 # me.lemire.integercompression.OptPFD+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 10.04 5 663 + 10.04 5 663 # me.lemire.integercompression.OptPFDS9+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 10.08 7 700 + 10.08 7 700 # me.lemire.integercompression.FastPFOR+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 9.79 215 757 + 9.79 215 757 # me.lemire.integercompression.Simple9 # bits per int, compress speed (mis), decompression speed (mis) - 11.79 78 325 + 11.79 78 325 # sparsity 10 # generating random data... # generating random data... ok. # kamikaze PForDelta # bits per int, compress speed (mis), decompression speed (mis) - 11.13 30 243 + 11.13 30 243 # me.lemire.integercompression.IntegratedBinaryPacking+me.lemire.integercompression.IntegratedVariableByte # bits per int, compress speed (mis), decompression speed (mis) - 10.83 628 1028 + 10.83 628 1028 # me.lemire.integercompression.JustCopy # bits per int, compress speed (mis), decompression speed (mis) - 32.00 1167 1498 + 32.00 1167 1498 # me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 12.71 152 179 + 12.71 152 179 # me.lemire.integercompression.IntegratedVariableByte # bits per int, compress speed (mis), decompression speed (mis) - 12.71 151 187 + 12.71 151 187 # me.lemire.integercompression.BinaryPacking+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 10.83 389 820 + 10.83 389 820 # me.lemire.integercompression.NewPFD+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 10.76 72 638 + 10.76 72 638 # me.lemire.integercompression.NewPFDS9+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 10.79 79 683 + 10.79 79 683 # me.lemire.integercompression.OptPFD+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 10.69 5 655 + 10.69 5 655 # me.lemire.integercompression.OptPFDS9+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 10.73 7 682 + 10.73 7 682 # me.lemire.integercompression.FastPFOR+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 10.42 219 767 + 10.42 219 767 # me.lemire.integercompression.Simple9 # bits per int, compress speed (mis), decompression speed (mis) - 12.49 77 332 + 12.49 77 332 # sparsity 11 # generating random data... # generating random data... ok. # kamikaze PForDelta # bits per int, compress speed (mis), decompression speed (mis) - 12.38 29 254 + 12.38 29 254 # me.lemire.integercompression.IntegratedBinaryPacking+me.lemire.integercompression.IntegratedVariableByte # bits per int, compress speed (mis), decompression speed (mis) - 12.01 660 1112 + 12.01 660 1112 # me.lemire.integercompression.JustCopy # bits per int, compress speed (mis), decompression speed (mis) - 32.00 1142 1445 + 32.00 1142 1445 # me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 13.87 143 172 + 13.87 143 172 # me.lemire.integercompression.IntegratedVariableByte # bits per int, compress speed (mis), decompression speed (mis) - 13.87 144 178 + 13.87 144 178 # me.lemire.integercompression.BinaryPacking+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 12.01 582 830 + 12.01 582 830 # me.lemire.integercompression.NewPFD+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 12.04 64 647 + 12.04 64 647 # me.lemire.integercompression.NewPFDS9+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 12.08 69 649 + 12.08 69 649 # me.lemire.integercompression.OptPFD+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 11.91 4 637 + 11.91 4 637 # me.lemire.integercompression.OptPFDS9+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 11.95 7 660 + 11.95 7 660 # me.lemire.integercompression.FastPFOR+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 11.61 217 766 + 11.61 217 766 # me.lemire.integercompression.Simple9 # bits per int, compress speed (mis), decompression speed (mis) - 13.96 73 313 + 13.96 73 313 # sparsity 12 # generating random data... # generating random data... ok. # kamikaze PForDelta # bits per int, compress speed (mis), decompression speed (mis) - 13.57 29 265 + 13.57 29 265 # me.lemire.integercompression.IntegratedBinaryPacking+me.lemire.integercompression.IntegratedVariableByte # bits per int, compress speed (mis), decompression speed (mis) - 13.01 611 1012 + 13.01 611 1012 # me.lemire.integercompression.JustCopy # bits per int, compress speed (mis), decompression speed (mis) - 32.00 1215 1565 + 32.00 1215 1565 # me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 14.73 121 160 + 14.73 121 160 # me.lemire.integercompression.IntegratedVariableByte # bits per int, compress speed (mis), decompression speed (mis) - 14.73 131 166 + 14.73 131 166 # me.lemire.integercompression.BinaryPacking+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 13.01 603 832 + 13.01 603 832 # me.lemire.integercompression.NewPFD+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 13.26 68 737 + 13.26 68 737 # me.lemire.integercompression.NewPFDS9+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 13.29 72 761 + 13.29 72 761 # me.lemire.integercompression.OptPFD+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 13.06 4 591 + 13.06 4 591 # me.lemire.integercompression.OptPFDS9+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 13.10 6 625 + 13.10 6 625 # me.lemire.integercompression.FastPFOR+me.lemire.integercompression.VariableByte # bits per int, compress speed (mis), decompression speed (mis) - 12.61 213 755 + 12.61 213 755 # me.lemire.integercompression.Simple9 # bits per int, compress speed (mis), decompression speed (mis) - 15.38 69 281 + 15.38 69 281 diff --git a/benchmarkresults/benchmarkresults_icore7_12november2013.txt b/benchmarkresults/benchmarkresults_icore7_12november2013.txt new file mode 100644 index 0000000..795650e --- /dev/null +++ b/benchmarkresults/benchmarkresults_icore7_12november2013.txt @@ -0,0 +1,879 @@ +[INFO] Scanning for projects... +[WARNING] POM for 'biz.aQute:bndlib:pom:1.50.0:runtime' is invalid. + +Its dependencies (if any) will NOT be available to the current build. +[INFO] ------------------------------------------------------------------------ +[INFO] Building JavaFastPFOR +[INFO] task-segment: [exec:java] +[INFO] ------------------------------------------------------------------------ +[INFO] Preparing exec:java +[INFO] [enforcer:enforce {execution: enforce-maven}] +[INFO] [exec:java {execution: default-cli}] +# benchmark based on the ClusterData model from: +# Vo Ngoc Anh and Alistair Moffat. +# Index compression using 64-bit words. +# Softw. Pract. Exper.40, 2 (February 2010), 131-147. + +# Results will be written into a CSV file: benchmark-20131112T105209.csv + +# sparsity 1 +# generating random data... +# generating random data... ok. +# kamikaze PForDelta +# bits per int, compress speed (mis), decompression speed (mis) + 3.28 48 218 + +# IntegratedBinaryPacking + IntegratedVariableByte (Integrated) +# bits per int, compress speed (mis), decompression speed (mis) + 3.03 623 1205 + +# JustCopy +# bits per int, compress speed (mis), decompression speed (mis) + 32.00 1154 1331 + +# VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.00 508 554 + +# IntegratedVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.00 592 709 + +# BinaryPacking + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 3.03 596 900 + +# NewPFD + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 2.95 115 701 + +# NewPFDS9 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 2.98 135 726 + +# NewPFDS16 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 2.95 116 726 + +# OptPFD + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 2.94 19 761 + +# OptPFDS9 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 2.97 22 767 + +# OptPFDS16 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 2.94 19 765 + +# IntegratedFastPFOR + IntegratedVariableByte (Integrated) +# bits per int, compress speed (mis), decompression speed (mis) + 2.71 219 797 + +# FastPFOR + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 2.71 217 813 + +# Simple9 +# bits per int, compress speed (mis), decompression speed (mis) + 2.90 254 599 + +# XorBinaryPacking + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 2.92 375 669 + +# DeltaZigzagBinaryPacking + DeltaZigzagVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 3.36 394 503 + +# sparsity 2 +# generating random data... +# generating random data... ok. +# kamikaze PForDelta +# bits per int, compress speed (mis), decompression speed (mis) + 4.09 47 254 + +# IntegratedBinaryPacking + IntegratedVariableByte (Integrated) +# bits per int, compress speed (mis), decompression speed (mis) + 3.84 636 1160 + +# JustCopy +# bits per int, compress speed (mis), decompression speed (mis) + 32.00 1152 1264 + +# VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.01 510 551 + +# IntegratedVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.01 594 704 + +# BinaryPacking + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 3.84 602 875 + +# NewPFD + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 3.74 101 673 + +# NewPFDS9 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 3.77 117 695 + +# NewPFDS16 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 3.74 101 694 + +# OptPFD + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 3.73 15 725 + +# OptPFDS9 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 3.76 18 741 + +# OptPFDS16 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 3.73 15 731 + +# IntegratedFastPFOR + IntegratedVariableByte (Integrated) +# bits per int, compress speed (mis), decompression speed (mis) + 3.48 215 782 + +# FastPFOR + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 3.48 212 789 + +# Simple9 +# bits per int, compress speed (mis), decompression speed (mis) + 3.72 190 530 + +# XorBinaryPacking + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 3.76 375 657 + +# DeltaZigzagBinaryPacking + DeltaZigzagVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 4.32 392 499 + +# sparsity 3 +# generating random data... +# generating random data... ok. +# kamikaze PForDelta +# bits per int, compress speed (mis), decompression speed (mis) + 5.03 42 250 + +# IntegratedBinaryPacking + IntegratedVariableByte (Integrated) +# bits per int, compress speed (mis), decompression speed (mis) + 4.77 643 1141 + +# JustCopy +# bits per int, compress speed (mis), decompression speed (mis) + 32.00 1149 1337 + +# VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.02 506 547 + +# IntegratedVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.02 590 698 + +# BinaryPacking + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 4.77 619 904 + +# NewPFD + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 4.66 89 640 + +# NewPFDS9 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 4.69 103 672 + +# NewPFDS16 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 4.66 89 668 + +# OptPFD + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 4.64 12 700 + +# OptPFDS9 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 4.68 14 712 + +# OptPFDS16 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 4.64 12 704 + +# IntegratedFastPFOR + IntegratedVariableByte (Integrated) +# bits per int, compress speed (mis), decompression speed (mis) + 4.39 212 762 + +# FastPFOR + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 4.39 209 763 + +# Simple9 +# bits per int, compress speed (mis), decompression speed (mis) + 4.81 146 480 + +# XorBinaryPacking + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 4.75 373 646 + +# DeltaZigzagBinaryPacking + DeltaZigzagVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 5.40 386 496 + +# sparsity 4 +# generating random data... +# generating random data... ok. +# kamikaze PForDelta +# bits per int, compress speed (mis), decompression speed (mis) + 5.77 39 245 + +# IntegratedBinaryPacking + IntegratedVariableByte (Integrated) +# bits per int, compress speed (mis), decompression speed (mis) + 5.53 629 1095 + +# JustCopy +# bits per int, compress speed (mis), decompression speed (mis) + 32.00 1148 1332 + +# VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.11 482 522 + +# IntegratedVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.11 557 655 + +# BinaryPacking + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 5.53 617 889 + +# NewPFD + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 5.42 82 659 + +# NewPFDS9 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 5.45 94 684 + +# NewPFDS16 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 5.42 82 686 + +# OptPFD + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 5.40 10 695 + +# OptPFDS9 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 5.43 12 715 + +# OptPFDS16 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 5.40 10 705 + +# IntegratedFastPFOR + IntegratedVariableByte (Integrated) +# bits per int, compress speed (mis), decompression speed (mis) + 5.16 214 776 + +# FastPFOR + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 5.16 211 780 + +# Simple9 +# bits per int, compress speed (mis), decompression speed (mis) + 5.66 128 457 + +# XorBinaryPacking + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 5.53 370 645 + +# DeltaZigzagBinaryPacking + DeltaZigzagVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 6.23 389 493 + +# sparsity 5 +# generating random data... +# generating random data... ok. +# kamikaze PForDelta +# bits per int, compress speed (mis), decompression speed (mis) + 6.57 37 248 + +# IntegratedBinaryPacking + IntegratedVariableByte (Integrated) +# bits per int, compress speed (mis), decompression speed (mis) + 6.32 640 1113 + +# JustCopy +# bits per int, compress speed (mis), decompression speed (mis) + 32.00 1150 1349 + +# VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.41 416 456 + +# IntegratedVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.41 473 548 + +# BinaryPacking + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 6.32 622 898 + +# NewPFD + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 6.20 75 643 + +# NewPFDS9 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 6.23 86 668 + +# NewPFDS16 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 6.20 75 666 + +# OptPFD + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 6.18 8 690 + +# OptPFDS9 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 6.21 11 705 + +# OptPFDS16 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 6.18 8 697 + +# IntegratedFastPFOR + IntegratedVariableByte (Integrated) +# bits per int, compress speed (mis), decompression speed (mis) + 5.93 211 741 + +# FastPFOR + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 5.93 208 772 + +# Simple9 +# bits per int, compress speed (mis), decompression speed (mis) + 6.51 118 426 + +# XorBinaryPacking + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 6.32 374 639 + +# DeltaZigzagBinaryPacking + DeltaZigzagVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 7.05 390 492 + +# sparsity 6 +# generating random data... +# generating random data... ok. +# kamikaze PForDelta +# bits per int, compress speed (mis), decompression speed (mis) + 7.73 35 242 + +# IntegratedBinaryPacking + IntegratedVariableByte (Integrated) +# bits per int, compress speed (mis), decompression speed (mis) + 7.48 630 1071 + +# JustCopy +# bits per int, compress speed (mis), decompression speed (mis) + 32.00 1143 1350 + +# VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 9.04 328 365 + +# IntegratedVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 9.04 365 415 + +# BinaryPacking + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 7.48 620 882 + +# NewPFD + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 7.36 67 641 + +# NewPFDS9 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 7.39 76 668 + +# NewPFDS16 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 7.36 67 667 + +# OptPFD + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 7.33 7 679 + +# OptPFDS9 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 7.37 9 695 + +# OptPFDS16 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 7.33 7 686 + +# IntegratedFastPFOR + IntegratedVariableByte (Integrated) +# bits per int, compress speed (mis), decompression speed (mis) + 7.09 211 749 + +# FastPFOR + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 7.09 208 764 + +# Simple9 +# bits per int, compress speed (mis), decompression speed (mis) + 7.88 101 383 + +# XorBinaryPacking + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 7.49 372 630 + +# DeltaZigzagBinaryPacking + DeltaZigzagVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.27 389 489 + +# sparsity 7 +# generating random data... +# generating random data... ok. +# kamikaze PForDelta +# bits per int, compress speed (mis), decompression speed (mis) + 8.46 33 244 + +# IntegratedBinaryPacking + IntegratedVariableByte (Integrated) +# bits per int, compress speed (mis), decompression speed (mis) + 8.21 628 1052 + +# JustCopy +# bits per int, compress speed (mis), decompression speed (mis) + 32.00 1148 1334 + +# VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 10.01 257 290 + +# IntegratedVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 10.01 284 315 + +# BinaryPacking + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.21 612 859 + +# NewPFD + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.08 63 626 + +# NewPFDS9 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.11 71 665 + +# NewPFDS16 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.08 63 663 + +# OptPFD + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.06 6 675 + +# OptPFDS9 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.09 8 687 + +# OptPFDS16 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.06 6 682 + +# IntegratedFastPFOR + IntegratedVariableByte (Integrated) +# bits per int, compress speed (mis), decompression speed (mis) + 7.81 210 756 + +# FastPFOR + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 7.81 207 759 + +# Simple9 +# bits per int, compress speed (mis), decompression speed (mis) + 8.85 92 353 + +# XorBinaryPacking + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.22 369 622 + +# DeltaZigzagBinaryPacking + DeltaZigzagVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 9.00 389 486 + +# sparsity 8 +# generating random data... +# generating random data... ok. +# kamikaze PForDelta +# bits per int, compress speed (mis), decompression speed (mis) + 9.41 32 234 + +# IntegratedBinaryPacking + IntegratedVariableByte (Integrated) +# bits per int, compress speed (mis), decompression speed (mis) + 9.16 636 1062 + +# JustCopy +# bits per int, compress speed (mis), decompression speed (mis) + 32.00 1151 1326 + +# VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 11.08 231 269 + +# IntegratedVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 11.08 259 288 + +# BinaryPacking + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 9.16 616 873 + +# NewPFD + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 9.04 59 638 + +# NewPFDS9 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 9.07 65 664 + +# NewPFDS16 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 9.04 59 664 + +# OptPFD + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 9.01 5 665 + +# OptPFDS9 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 9.05 7 680 + +# OptPFDS16 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 9.01 5 671 + +# IntegratedFastPFOR + IntegratedVariableByte (Integrated) +# bits per int, compress speed (mis), decompression speed (mis) + 8.77 209 746 + +# FastPFOR + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.77 207 738 + +# Simple9 +# bits per int, compress speed (mis), decompression speed (mis) + 10.25 81 324 + +# XorBinaryPacking + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 9.18 372 625 + +# DeltaZigzagBinaryPacking + DeltaZigzagVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 9.98 387 479 + +# sparsity 9 +# generating random data... +# generating random data... ok. +# kamikaze PForDelta +# bits per int, compress speed (mis), decompression speed (mis) + 10.41 31 238 + +# IntegratedBinaryPacking + IntegratedVariableByte (Integrated) +# bits per int, compress speed (mis), decompression speed (mis) + 10.15 637 1070 + +# JustCopy +# bits per int, compress speed (mis), decompression speed (mis) + 32.00 1145 1413 + +# VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 12.15 221 267 + +# IntegratedVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 12.15 252 284 + +# BinaryPacking + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 10.15 609 849 + +# NewPFD + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 10.03 54 624 + +# NewPFDS9 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 10.06 60 650 + +# NewPFDS16 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 10.03 54 649 + +# OptPFD + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 10.00 5 653 + +# OptPFDS9 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 10.03 7 666 + +# OptPFDS16 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 10.00 5 659 + +# IntegratedFastPFOR + IntegratedVariableByte (Integrated) +# bits per int, compress speed (mis), decompression speed (mis) + 9.75 207 739 + +# FastPFOR + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 9.75 206 743 + +# Simple9 +# bits per int, compress speed (mis), decompression speed (mis) + 11.72 73 313 + +# XorBinaryPacking + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 10.17 369 611 + +# DeltaZigzagBinaryPacking + DeltaZigzagVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 10.98 381 474 + +# sparsity 10 +# generating random data... +# generating random data... ok. +# kamikaze PForDelta +# bits per int, compress speed (mis), decompression speed (mis) + 11.57 29 236 + +# IntegratedBinaryPacking + IntegratedVariableByte (Integrated) +# bits per int, compress speed (mis), decompression speed (mis) + 11.28 626 1033 + +# JustCopy +# bits per int, compress speed (mis), decompression speed (mis) + 32.00 1141 1328 + +# VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 13.18 219 276 + +# IntegratedVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 13.18 254 294 + +# BinaryPacking + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 11.28 610 848 + +# NewPFD + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 11.19 50 617 + +# NewPFDS9 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 11.23 56 638 + +# NewPFDS16 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 11.19 50 640 + +# OptPFD + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 11.13 4 640 + +# OptPFDS9 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 11.17 6 655 + +# OptPFDS16 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 11.13 4 647 + +# IntegratedFastPFOR + IntegratedVariableByte (Integrated) +# bits per int, compress speed (mis), decompression speed (mis) + 10.87 207 736 + +# FastPFOR + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 10.87 204 734 + +# Simple9 +# bits per int, compress speed (mis), decompression speed (mis) + 13.19 68 311 + +# XorBinaryPacking + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 11.30 369 612 + +# DeltaZigzagBinaryPacking + DeltaZigzagVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 12.13 386 477 + +# sparsity 11 +# generating random data... +# generating random data... ok. +# kamikaze PForDelta +# bits per int, compress speed (mis), decompression speed (mis) + 12.41 29 229 + +# IntegratedBinaryPacking + IntegratedVariableByte (Integrated) +# bits per int, compress speed (mis), decompression speed (mis) + 12.01 634 1046 + +# JustCopy +# bits per int, compress speed (mis), decompression speed (mis) + 32.00 1148 1365 + +# VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 13.84 208 261 + +# IntegratedVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 13.84 241 277 + +# BinaryPacking + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 12.01 605 832 + +# NewPFD + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 12.07 49 650 + +# NewPFDS9 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 12.10 54 674 + +# NewPFDS16 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 12.07 49 675 + +# OptPFD + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 11.93 4 604 + +# OptPFDS9 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 11.97 6 618 + +# OptPFDS16 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 11.93 4 611 + +# IntegratedFastPFOR + IntegratedVariableByte (Integrated) +# bits per int, compress speed (mis), decompression speed (mis) + 11.60 206 724 + +# FastPFOR + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 11.60 203 724 + +# Simple9 +# bits per int, compress speed (mis), decompression speed (mis) + 13.98 66 291 + +# XorBinaryPacking + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 12.04 367 603 + +# DeltaZigzagBinaryPacking + DeltaZigzagVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 12.86 385 478 + +# sparsity 12 +# generating random data... +# generating random data... ok. +# kamikaze PForDelta +# bits per int, compress speed (mis), decompression speed (mis) + 13.48 28 236 + +# IntegratedBinaryPacking + IntegratedVariableByte (Integrated) +# bits per int, compress speed (mis), decompression speed (mis) + 12.96 634 1051 + +# JustCopy +# bits per int, compress speed (mis), decompression speed (mis) + 32.00 1150 1307 + +# VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 14.69 202 258 + +# IntegratedVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 14.69 235 272 + +# BinaryPacking + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 12.96 610 849 + +# NewPFD + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 13.17 48 698 + +# NewPFDS9 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 13.20 52 714 + +# NewPFDS16 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 13.17 48 720 + +# OptPFD + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 12.96 4 588 + +# OptPFDS9 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 13.00 6 602 + +# OptPFDS16 + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 12.96 4 597 + +# IntegratedFastPFOR + IntegratedVariableByte (Integrated) +# bits per int, compress speed (mis), decompression speed (mis) + 12.55 206 726 + +# FastPFOR + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 12.55 203 725 + +# Simple9 +# bits per int, compress speed (mis), decompression speed (mis) + 15.40 63 269 + +# XorBinaryPacking + VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 12.99 368 613 + +# DeltaZigzagBinaryPacking + DeltaZigzagVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 13.81 384 476 + + +Results were written into a CSV file: benchmark-20131112T105209.csv +[INFO] ------------------------------------------------------------------------ +[INFO] BUILD SUCCESSFUL +[INFO] ------------------------------------------------------------------------ +[INFO] Total time: 17 minutes 30 seconds +[INFO] Finished at: Tue Nov 12 11:09:38 EST 2013 +[INFO] Final Memory: 20M/230M +[INFO] ------------------------------------------------------------------------ diff --git a/benchmarkresults/benchmarkresults_skippable_haswell_18sept2014.txt b/benchmarkresults/benchmarkresults_skippable_haswell_18sept2014.txt new file mode 100644 index 0000000..7e35696 --- /dev/null +++ b/benchmarkresults/benchmarkresults_skippable_haswell_18sept2014.txt @@ -0,0 +1,513 @@ +# benchmark based on the ClusterData model from: +# Vo Ngoc Anh and Alistair Moffat. +# Index compression using 64-bit words. +# Softw. Pract. Exper.40, 2 (February 2010), 131-147. + +# Results will be written into a CSV file: benchmark-20140918T011322.csv + +# sparsity 1 +# generating random data... +# generating random data... ok. +# IntegratedBinaryPacking + IntegratedVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 3.04 840 1619 +# JustCopy +# bits per int, compress speed (mis), decompression speed (mis) + 32.00 1169 1698 +# VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.00 195 369 +# BinaryPacking+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 3.04 651 1148 +# NewPFD+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 2.96 129 865 +# NewPFDS9+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 2.98 158 877 +# NewPFDS16+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 2.96 130 879 +# OptPFD+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 2.95 25 930 +# OptPFDS9+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 2.97 27 951 +# OptPFDS16+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 2.95 25 935 +# FastPFOR+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 2.82 235 928 +# Simple9 +# bits per int, compress speed (mis), decompression speed (mis) + 2.93 255 740 +# Simple16 +# bits per int, compress speed (mis), decompression speed (mis) + 2.77 147 395 +# sparsity 2 +# generating random data... +# generating random data... ok. +# IntegratedBinaryPacking + IntegratedVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 3.82 831 1555 +# JustCopy +# bits per int, compress speed (mis), decompression speed (mis) + 32.00 1183 1800 +# VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.00 220 372 +# BinaryPacking+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 3.82 659 1139 +# NewPFD+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 3.72 116 855 +# NewPFDS9+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 3.75 136 851 +# NewPFDS16+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 3.72 115 853 +# OptPFD+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 3.71 19 895 +# OptPFDS9+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 3.74 22 917 +# OptPFDS16+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 3.71 19 900 +# FastPFOR+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 3.59 230 908 +# Simple9 +# bits per int, compress speed (mis), decompression speed (mis) + 3.74 195 654 +# Simple16 +# bits per int, compress speed (mis), decompression speed (mis) + 3.49 111 366 +# sparsity 3 +# generating random data... +# generating random data... ok. +# IntegratedBinaryPacking + IntegratedVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 4.78 817 1519 +# JustCopy +# bits per int, compress speed (mis), decompression speed (mis) + 32.00 1019 1759 +# VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.02 238 370 +# BinaryPacking+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 4.78 680 1121 +# NewPFD+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 4.67 98 825 +# NewPFDS9+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 4.70 123 840 +# NewPFDS16+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 4.67 102 834 +# OptPFD+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 4.66 15 861 +# OptPFDS9+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 4.69 18 895 +# OptPFDS16+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 4.66 14 871 +# FastPFOR+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 4.54 231 904 +# Simple9 +# bits per int, compress speed (mis), decompression speed (mis) + 4.84 153 589 +# Simple16 +# bits per int, compress speed (mis), decompression speed (mis) + 4.40 83 339 +# sparsity 4 +# generating random data... +# generating random data... ok. +# IntegratedBinaryPacking + IntegratedVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 5.65 788 1505 +# JustCopy +# bits per int, compress speed (mis), decompression speed (mis) + 32.00 1142 1757 +# VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.09 242 363 +# BinaryPacking+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 5.65 636 1113 +# NewPFD+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 5.52 92 828 +# NewPFDS9+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 5.56 112 826 +# NewPFDS16+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 5.52 94 826 +# OptPFD+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 5.51 12 854 +# OptPFDS9+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 5.54 15 883 +# OptPFDS16+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 5.51 12 858 +# FastPFOR+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 5.39 218 886 +# Simple9 +# bits per int, compress speed (mis), decompression speed (mis) + 5.80 136 566 +# Simple16 +# bits per int, compress speed (mis), decompression speed (mis) + 5.32 68 319 +# sparsity 5 +# generating random data... +# generating random data... ok. +# IntegratedBinaryPacking + IntegratedVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 6.31 804 1490 +# JustCopy +# bits per int, compress speed (mis), decompression speed (mis) + 32.00 1105 1860 +# VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.40 245 330 +# BinaryPacking+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 6.31 673 1121 +# NewPFD+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 6.19 87 832 +# NewPFDS9+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 6.22 107 844 +# NewPFDS16+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 6.19 88 830 +# OptPFD+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 6.17 10 851 +# OptPFDS9+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 6.20 14 883 +# OptPFDS16+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 6.17 10 852 +# FastPFOR+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 6.07 217 875 +# Simple9 +# bits per int, compress speed (mis), decompression speed (mis) + 6.51 130 513 +# Simple16 +# bits per int, compress speed (mis), decompression speed (mis) + 6.13 60 307 +# sparsity 6 +# generating random data... +# generating random data... ok. +# IntegratedBinaryPacking + IntegratedVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 6.99 742 1431 +# JustCopy +# bits per int, compress speed (mis), decompression speed (mis) + 32.00 1163 1660 +# VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.99 205 290 +# BinaryPacking+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 6.99 637 1107 +# NewPFD+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 6.87 82 821 +# NewPFDS9+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 6.90 100 830 +# NewPFDS16+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 6.87 82 818 +# OptPFD+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 6.85 9 834 +# OptPFDS9+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 6.88 12 865 +# OptPFDS16+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 6.85 9 836 +# FastPFOR+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 6.75 224 877 +# Simple9 +# bits per int, compress speed (mis), decompression speed (mis) + 7.33 118 485 +# Simple16 +# bits per int, compress speed (mis), decompression speed (mis) + 6.98 54 296 +# sparsity 7 +# generating random data... +# generating random data... ok. +# IntegratedBinaryPacking + IntegratedVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.31 770 1463 +# JustCopy +# bits per int, compress speed (mis), decompression speed (mis) + 32.00 1074 1832 +# VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 10.01 203 240 +# BinaryPacking+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.31 664 1105 +# NewPFD+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.18 73 796 +# NewPFDS9+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.22 88 808 +# NewPFDS16+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.18 73 792 +# OptPFD+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.16 7 819 +# OptPFDS9+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.20 10 849 +# OptPFDS16+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.16 7 810 +# FastPFOR+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.05 217 851 +# Simple9 +# bits per int, compress speed (mis), decompression speed (mis) + 9.01 103 430 +# Simple16 +# bits per int, compress speed (mis), decompression speed (mis) + 8.61 47 277 +# sparsity 8 +# generating random data... +# generating random data... ok. +# IntegratedBinaryPacking + IntegratedVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.88 800 1414 +# JustCopy +# bits per int, compress speed (mis), decompression speed (mis) + 32.00 1078 1718 +# VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 10.91 211 227 +# BinaryPacking+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.88 671 1083 +# NewPFD+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.76 70 804 +# NewPFDS9+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.80 84 814 +# NewPFDS16+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.76 70 800 +# OptPFD+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.73 7 807 +# OptPFDS9+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.77 9 792 +# OptPFDS16+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.73 7 801 +# FastPFOR+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 8.64 211 837 +# Simple9 +# bits per int, compress speed (mis), decompression speed (mis) + 9.94 96 417 +# Simple16 +# bits per int, compress speed (mis), decompression speed (mis) + 9.51 44 268 +# sparsity 9 +# generating random data... +# generating random data... ok. +# IntegratedBinaryPacking + IntegratedVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 10.19 834 1442 +# JustCopy +# bits per int, compress speed (mis), decompression speed (mis) + 32.00 1200 1632 +# VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 12.16 206 212 +# BinaryPacking+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 10.19 675 1092 +# NewPFD+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 10.07 64 804 +# NewPFDS9+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 10.10 76 814 +# NewPFDS16+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 10.07 63 802 +# OptPFD+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 10.04 6 810 +# OptPFDS9+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 10.08 9 841 +# OptPFDS16+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 10.04 6 808 +# FastPFOR+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 9.94 222 858 +# Simple9 +# bits per int, compress speed (mis), decompression speed (mis) + 11.79 88 397 +# Simple16 +# bits per int, compress speed (mis), decompression speed (mis) + 11.40 38 253 +# sparsity 10 +# generating random data... +# generating random data... ok. +# IntegratedBinaryPacking + IntegratedVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 11.10 814 1406 +# JustCopy +# bits per int, compress speed (mis), decompression speed (mis) + 32.00 1215 1820 +# VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 13.07 207 208 +# BinaryPacking+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 11.10 681 1073 +# NewPFD+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 11.00 60 800 +# NewPFDS9+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 11.04 72 809 +# NewPFDS16+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 11.00 60 796 +# OptPFD+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 10.95 6 785 +# OptPFDS9+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 10.99 8 815 +# OptPFDS16+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 10.95 6 782 +# FastPFOR+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 10.84 226 860 +# Simple9 +# bits per int, compress speed (mis), decompression speed (mis) + 12.93 84 389 +# Simple16 +# bits per int, compress speed (mis), decompression speed (mis) + 12.58 36 245 +# sparsity 11 +# generating random data... +# generating random data... ok. +# IntegratedBinaryPacking + IntegratedVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 12.31 814 1392 +# JustCopy +# bits per int, compress speed (mis), decompression speed (mis) + 32.00 1171 1846 +# VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 14.14 172 201 +# BinaryPacking+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 12.31 668 1071 +# NewPFD+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 12.42 56 825 +# NewPFDS9+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 12.45 67 832 +# NewPFDS16+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 12.42 56 821 +# OptPFD+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 12.22 5 729 +# OptPFDS9+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 12.27 8 758 +# OptPFDS16+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 12.22 5 731 +# FastPFOR+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 12.07 222 836 +# Simple9 +# bits per int, compress speed (mis), decompression speed (mis) + 14.31 81 377 +# Simple16 +# bits per int, compress speed (mis), decompression speed (mis) + 14.05 33 238 +# sparsity 12 +# generating random data... +# generating random data... ok. +# IntegratedBinaryPacking + IntegratedVariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 12.97 805 1375 +# JustCopy +# bits per int, compress speed (mis), decompression speed (mis) + 32.00 1160 1737 +# VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 14.72 186 193 +# BinaryPacking+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 12.97 656 1037 +# NewPFD+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 13.22 56 886 +# NewPFDS9+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 13.24 67 891 +# NewPFDS16+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 13.22 56 883 +# OptPFD+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 12.98 5 704 +# OptPFDS9+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 13.02 8 740 +# OptPFDS16+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 12.98 5 704 +# FastPFOR+VariableByte +# bits per int, compress speed (mis), decompression speed (mis) + 12.73 223 845 +# Simple9 +# bits per int, compress speed (mis), decompression speed (mis) + 15.35 78 347 +# Simple16 +# bits per int, compress speed (mis), decompression speed (mis) + 15.15 31 225 + +Results were written into a CSV file: benchmark-20140918T011322.csv diff --git a/build.xml b/build.xml index 2f964d5..d02cddd 100644 --- a/build.xml +++ b/build.xml @@ -8,13 +8,23 @@ + + + + + + + + + + diff --git a/example.java b/example.java index fd7430e..75dfb05 100644 --- a/example.java +++ b/example.java @@ -1,33 +1,49 @@ import me.lemire.integercompression.*; +import me.lemire.integercompression.differential.*; import java.util.*; public class example { public static void main(String[] args) { + superSimpleExample(); unsortedExample(); basicExample(); + basicExampleHeadless(); advancedExample(); + headlessDemo(); } - + + public static void superSimpleExample() { + IntegratedIntCompressor iic = new IntegratedIntCompressor(); + int[] data = new int[2342351]; + for(int k = 0; k < data.length; ++k) + data[k] = k; + System.out.println("Compressing "+data.length+" integers using friendly interface"); + int[] compressed = iic.compress(data); + int[] recov = iic.uncompress(compressed); + System.out.println("compressed from "+data.length*4/1024+"KB to "+compressed.length*4/1024+"KB"); + if(!Arrays.equals(recov,data)) throw new RuntimeException("bug"); + } + public static void basicExample() { int[] data = new int[2342351]; System.out.println("Compressing "+data.length+" integers in one go"); // data should be sorted for best //results for(int k = 0; k < data.length; ++k) - data[k] = k; + data[k] = k; // Very important: the data is in sorted order!!! If not, you // will get very poor compression with IntegratedBinaryPacking, // you should use another CODEC. - + // next we compose a CODEC. Most of the processing // will be done with binary packing, and leftovers will // be processed using variable byte - IntegratedIntegerCODEC codec = new - IntegratedComposition( - new IntegratedBinaryPacking(), - new IntegratedVariableByte()); + IntegratedIntegerCODEC codec = new + IntegratedComposition( + new IntegratedBinaryPacking(), + new IntegratedVariableByte()); // output vector should be large enough... - int [] compressed = new int[data.length]; + int [] compressed = new int[data.length+1024]; // compressed might not be large enough in some cases // if you get java.lang.ArrayIndexOutOfBoundsException, try // allocating more memory @@ -40,7 +56,7 @@ public static void basicExample() { IntWrapper inputoffset = new IntWrapper(0); IntWrapper outputoffset = new IntWrapper(0); codec.compress(data,inputoffset,data.length,compressed,outputoffset); - // got it! + // got it! // inputoffset should be at data.length but outputoffset tells // us where we are... System.out.println("compressed from "+data.length*4/1024+"KB to "+outputoffset.intValue()*4/1024+"KB"); @@ -51,17 +67,80 @@ public static void basicExample() { * * now uncompressing * + * This assumes that we otherwise know how many integers + * have been compressed, or we can bound it (e.g., you know that + * will never need to decore more than 2000 integers). + * See basicExampleHeadless for a + * more general case where you can manually manage the compressed + * array size. */ int[] recovered = new int[data.length]; IntWrapper recoffset = new IntWrapper(0); codec.uncompress(compressed,new IntWrapper(0),compressed.length,recovered,recoffset); - if(Arrays.equals(data,recovered)) - System.out.println("data is recovered without loss"); + if(Arrays.equals(data,recovered)) + System.out.println("data is recovered without loss"); else - throw new RuntimeException("bug"); // could use assert + throw new RuntimeException("bug"); // could use assert System.out.println(); } - + + + /** + * Like the basicExample, but we store the input array size manually. + */ + public static void basicExampleHeadless() { + int[] data = new int[2342351]; + System.out.println("Compressing " + data.length + " integers in one go using the headless approach"); + // data should be sorted for best + // results + for (int k = 0; k < data.length; ++k) + data[k] = k; + // Very important: the data is in sorted order!!! If not, you + // will get very poor compression with IntegratedBinaryPacking, + // you should use another CODEC. + + // next we compose a CODEC. Most of the processing + // will be done with binary packing, and leftovers will + // be processed using variable byte + SkippableIntegratedComposition codec = new SkippableIntegratedComposition(new IntegratedBinaryPacking(), + new IntegratedVariableByte()); + int[] compressed = new int[codec.maxHeadlessCompressedLength(new IntWrapper(0), data.length)]; + + /** + * + * compressing + * + */ + IntWrapper inputoffset = new IntWrapper(0); + IntWrapper outputoffset = new IntWrapper(1); + compressed[0] = data.length; // we manually store how many integers + codec.headlessCompress(data, inputoffset, data.length, compressed, outputoffset, new IntWrapper(0)); + // got it! + // inputoffset should be at data.length but outputoffset tells + // us where we are... + System.out.println( + "compressed from " + data.length * 4 / 1024 + "KB to " + outputoffset.intValue() * 4 / 1024 + "KB"); + // we can repack the data: (optional) + compressed = Arrays.copyOf(compressed, outputoffset.intValue()); + + /** + * + * now uncompressing + * + */ + int howmany = compressed[0];// we manually stored the number of + // compressed integers + int[] recovered = new int[howmany]; + IntWrapper recoffset = new IntWrapper(0); + codec.headlessUncompress(compressed, new IntWrapper(1), compressed.length, recovered, recoffset, howmany, new IntWrapper(0)); + if (Arrays.equals(data, recovered)) + System.out.println("data is recovered without loss"); + else + throw new RuntimeException("bug"); // could use assert + System.out.println(); + } + + /** * This is an example to show you can compress unsorted integers * as long as most are small. @@ -74,11 +153,11 @@ public static void unsortedExample() { // throw some larger values for(int k = 0; k < N; k+=5) data[k] = 100; for(int k = 0; k < N; k+=533) data[k] = 10000; - int[] compressed = new int [N];// could need more - IntegerCODEC codec = new - Composition( - new FastPFOR(), - new VariableByte()); + int[] compressed = new int [N+1024];// could need more + IntegerCODEC codec = new + Composition( + new FastPFOR(), + new VariableByte()); // compressing IntWrapper inputoffset = new IntWrapper(0); IntWrapper outputoffset = new IntWrapper(0); @@ -90,19 +169,19 @@ public static void unsortedExample() { int[] recovered = new int[N]; IntWrapper recoffset = new IntWrapper(0); codec.uncompress(compressed,new IntWrapper(0),compressed.length,recovered,recoffset); - if(Arrays.equals(data,recovered)) - System.out.println("data is recovered without loss"); + if(Arrays.equals(data,recovered)) + System.out.println("data is recovered without loss"); else - throw new RuntimeException("bug"); // could use assert + throw new RuntimeException("bug"); // could use assert System.out.println(); } /** - * This is like the basic example, but we + * This is like the basic example, but we * show how to process larger arrays in chunks. * - * Some of this code was written by Pavel Klinov. + * Some of this code was written by Pavel Klinov. */ public static void advancedExample() { int TotalSize = 2342351; // some arbitrary number @@ -113,20 +192,20 @@ public static void advancedExample() { // data should be sorted for best //results for(int k = 0; k < data.length; ++k) - data[k] = k; + data[k] = k; // next we compose a CODEC. Most of the processing // will be done with binary packing, and leftovers will // be processed using variable byte, using variable byte // only for the last chunk! - IntegratedIntegerCODEC regularcodec = new - IntegratedBinaryPacking(); + IntegratedIntegerCODEC regularcodec = new + IntegratedBinaryPacking(); IntegratedVariableByte ivb = new IntegratedVariableByte(); - IntegratedIntegerCODEC lastcodec = new - IntegratedComposition(regularcodec,ivb); + IntegratedIntegerCODEC lastcodec = new + IntegratedComposition(regularcodec,ivb); // output vector should be large enough... - int [] compressed = new int[TotalSize]; - - + int [] compressed = new int[TotalSize+1024]; + + /** * * compressing @@ -134,24 +213,24 @@ public static void advancedExample() { */ IntWrapper inputoffset = new IntWrapper(0); IntWrapper outputoffset = new IntWrapper(0); - for(int k = 0; k < TotalSize / ChunkSize; ++k) + for(int k = 0; k < TotalSize / ChunkSize; ++k) regularcodec.compress(data,inputoffset,ChunkSize,compressed,outputoffset); - lastcodec.compress(data, inputoffset, TotalSize % ChunkSize, compressed, outputoffset); - // got it! + lastcodec.compress(data, inputoffset, TotalSize % ChunkSize, compressed, outputoffset); + // got it! // inputoffset should be at data.length but outputoffset tells // us where we are... System.out.println("compressed from "+data.length*4/1024+"KB to "+outputoffset.intValue()*4/1024+"KB"); // we can repack the data: compressed = Arrays.copyOf(compressed,outputoffset.intValue()); - - + + /** * * now uncompressing * * We are *not* assuming that the original array length is known, however * we assume that the chunk size (ChunkSize) is known. - * + * */ int[] recovered = new int[ChunkSize]; IntWrapper compoff = new IntWrapper(0); @@ -161,7 +240,7 @@ public static void advancedExample() { while(compoff.get()> b) & 1 ) == 1) { + answer[pos++] = b + k * 8; + } + } + if(pos != card) throw new RuntimeException("bug"); + return answer; + } + + public static void zipStats(String filename) throws IOException { + Path path = Paths.get(filename); + byte[] input = Files.readAllBytes(path); + System.out.println("I will try to compress the original bitmap using zip."); + + long bef = System.nanoTime(); + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + ZipOutputStream zos = new ZipOutputStream(baos); + zos.setLevel(9); + ZipEntry entry = new ZipEntry(filename); + entry.setSize(input.length); + zos.putNextEntry(entry); + zos.write(input); + zos.closeEntry(); + zos.close(); + byte[] result = baos.toByteArray(); + long aft = System.nanoTime(); + System.out.println("zip encoding speed:"+input.length*1000.0/(aft-bef)+" million of bytes per second"); + System.out.println("zip compression ratio at best level : "+input.length * 1.0 / result.length); + } +} \ No newline at end of file diff --git a/examples/Axelbrooke/README.md b/examples/Axelbrooke/README.md new file mode 100644 index 0000000..fad997e --- /dev/null +++ b/examples/Axelbrooke/README.md @@ -0,0 +1,25 @@ +# Bitset compression example + +A bitset can be considered as an array of integers. +Suppose you want to compress it quickly (at a rate of + millions of integers per second or better). + + The ``CompressBitmap.java`` file shows how it can be done. + +## Usage + +```bash +./run.sh + +loading file example_bitmap.bin as a bitmap +Compressing 1784073 integers +compressed from 6969KB to 1348KB +ratio: 5 +decoding speed:199 millions of integers per second +encoding speed:124 millions of integers per second +note: with a bit of effort, speed can be much higher. + +I will try to compress the original bitmap using zip. +zip encoding speed:0.4458317816544745 million of bytes per second +zip compression ratio at best level : 2.255323798747234 +``` diff --git a/examples/Axelbrooke/example_bitmap.bin b/examples/Axelbrooke/example_bitmap.bin new file mode 100644 index 0000000..7a00138 Binary files /dev/null and b/examples/Axelbrooke/example_bitmap.bin differ diff --git a/examples/Axelbrooke/run.sh b/examples/Axelbrooke/run.sh new file mode 100755 index 0000000..59bcd94 --- /dev/null +++ b/examples/Axelbrooke/run.sh @@ -0,0 +1,3 @@ +#!/usr/bin/env bash +echo "please be patient as I build the library and the example" + mvn -Dmaven.test.skip=true -Dmaven.javadoc.skip=true -f ../../pom.xml package > /dev/null && javac -cp "../../target/*" CompressBitmap.java && java -cp "../../target/*":. CompressBitmap example_bitmap.bin diff --git a/examples/vector/Example.java b/examples/vector/Example.java new file mode 100644 index 0000000..e8d2455 --- /dev/null +++ b/examples/vector/Example.java @@ -0,0 +1,67 @@ +// Copyright (C) 2022 Intel Corporation + +// SPDX-License-Identifier: Apache-2.0 + +import java.util.Arrays; +import me.lemire.integercompression.FastPFOR; +import me.lemire.integercompression.IntWrapper; +import me.lemire.integercompression.Composition; +import me.lemire.integercompression.IntegerCODEC; +import me.lemire.integercompression.VariableByte; +import me.lemire.integercompression.vector.VectorFastPFOR; + +public class Example { + public static void main(String[] args) { + if (args.length == 0) + throw new IllegalArgumentException(); + + // pass 0 for Vector compressor , non-zero for default compressor + int compressorToUse = Integer.parseInt(args[0]); + + final int N = 1310720; + int[] data = new int[N]; + + // 2-bit data + for (int k = 0; k < N; k += 1) + data[k] = 3; + + // a few large values + for (int k = 0; k < N; k += 5) + data[k] = 100; + for (int k = 0; k < N; k += 533) + data[k] = 10000; + + int[] compressed = new int[N + 1024]; + + IntegerCODEC codec = new Composition( + compressorToUse == 0 ? new VectorFastPFOR() : new FastPFOR(), + new VariableByte()); + + IntWrapper inputoffset = new IntWrapper(0); + IntWrapper outputoffset = new IntWrapper(0); + + codec.compress(data, inputoffset, data.length, compressed, outputoffset); + + System.out.println("compressed unsorted integers from " + + data.length * 4 / 1024 + "KB to " + + outputoffset.intValue() * 4 / 1024 + "KB"); + + compressed = Arrays.copyOf(compressed, outputoffset.intValue()); + + int[] recovered = new int[N]; + IntWrapper recoffset = new IntWrapper(0); + + codec.uncompress(compressed, new IntWrapper(0), compressed.length, + recovered, recoffset); + + System.out.println("compressed length = " + compressed.length + + ", uncompressed length = " + recoffset.intValue()); + + if (Arrays.equals(data, recovered)) + System.out.println("data is recovered without loss"); + else + throw new RuntimeException("bug"); // could use assert + + System.out.println(); + } +} diff --git a/examples/vector/README.md b/examples/vector/README.md new file mode 100644 index 0000000..cbcbfeb --- /dev/null +++ b/examples/vector/README.md @@ -0,0 +1,12 @@ +Compile +------- +``` +javac -cp Example.java +``` + +Run +--- +``` +java --add-modules jdk.incubator.vector -cp Example 0 +``` + diff --git a/jitpack.yml b/jitpack.yml new file mode 100644 index 0000000..255e0f4 --- /dev/null +++ b/jitpack.yml @@ -0,0 +1,5 @@ +jdk: + - openjdk21 +before_install: + - sdk install java 21-open + - sdk use java 21-open diff --git a/pom.xml b/pom.xml index 4901bf1..33db8e6 100644 --- a/pom.xml +++ b/pom.xml @@ -1,37 +1,50 @@ - 4.0.0 + 4.0.0 + me.lemire.integercompression + JavaFastPFOR + 0.3.11-SNAPSHOT + jar + + 21 + 21 + 21 + UTF-8 + 0.8.5 + + + + Apache 2 + http://www.apache.org/licenses/LICENSE-2.0.txt + repo + A business-friendly OSS license + + + + scm:git:https://github.com/fast-pack/JavaFastPFOR.git + scm:git:https://github.com/fast-pack/JavaFastPFOR.git + scm:git:https://github.com/fast-pack/JavaFastPFOR.git + HEAD + - me.lemire.integercompression - JavaFastPFOR - 0.0.7-SNAPSHOT - jar + + + sonatype-central-portal + Sonatype Central Portal + https://central.sonatype.com/repository/maven-snapshots/ + + + sonatype-central-portal + Sonatype Central Portal + https://repo.maven.apache.org/maven2/ + + - - 1.5 - 1.5 - UTF-8 - - - - Apache 2 - http://www.apache.org/licenses/LICENSE-2.0.txt - repo - A business-friendly OSS license - - - - scm:git:git@github.com:lemire/JavaFastPFOR.git - scm:git:git@github.com:lemire/JavaFastPFOR.git - scm:git:git@github.com:lemire/JavaFastPFOR.git - - + lemire Daniel Lemire - lemire@gmail.com + daniel@lemire.me http://lemire.me/en/ - LICEF Research Center - http://licef.ca architect developer @@ -43,53 +56,150 @@ - - - junit - junit - 4.10 - test - - - + + + junit + junit + 4.13.1 + test + + + org.roaringbitmap + RoaringBitmap + 0.9.35 + test + + + GitHub Issue Tracking - https://github.com/lemire/JavaFastPFOR/issues + https://github.com/fast-pack/JavaFastPFOR/issues - - org.sonatype.oss - oss-parent - 5 - - - + + + + eu.maveniverse.maven.njord + extension3 + ${njord.version} + + - - - org.apache.felix - maven-bundle-plugin - 2.3.7 - true - - - me.lemire.integercompression.* - * - - + + org.apache.maven.plugins + maven-compiler-plugin + 3.12.1 + + 21 + 21 + + + + default-compile + compile + + compile + + + + me/lemire/integercompression/vector/* + module-info.java + + + + + + + + + org.apache.felix + maven-bundle-plugin + 2.3.7 + true + + + me.lemire.integercompression.* + * + + + + + org.codehaus.mojo + exec-maven-plugin + 1.1 + + me.lemire.integercompression.benchmarktools.Benchmark + + + + org.apache.maven.plugins + maven-javadoc-plugin + 3.6.3 + + me.lemire.integercompression.vector;com.kamikaze.pfordelta:me.lemire.integercompression.benchmarktools + + + + attach-javadocs + + jar + + + + + + org.apache.maven.plugins + maven-source-plugin + 2.1.2 + + + attach-sources + + jar + + + + + + org.jacoco + jacoco-maven-plugin + 0.8.13 + + + me/lemire/integercompression/Kamikaze + com/kamikaze/pfordelta/* + me/lemire/integercompression/benchmarktools/* + + + + + prepare-agent + + prepare-agent + + + + + + org.apache.maven.plugins + maven-release-plugin + 3.0.1 + + deploy + true + - - - org.codehaus.mojo - exec-maven-plugin - 1.1 - - me.lemire.integercompression.Benchmark - - - org.apache.maven.plugins maven-gpg-plugin - 1.4 + 3.2.8 sign-artifacts @@ -100,40 +210,57 @@ - - - org.apache.maven.plugins - maven-javadoc-plugin - 2.8 - - - - attach-javadocs - - jar - - - - - - org.apache.maven.plugins - maven-source-plugin - 2.1.2 - - - attach-sources - - jar - - - - + + + + + eu.maveniverse.maven.plugins + njord + ${njord.version} + + + maven-clean-plugin + 2.5 + + + maven-deploy-plugin + 2.8.1 + + + maven-install-plugin + 2.5.1 + + + maven-jar-plugin + 2.4 + + + maven-javadoc-plugin + 2.9.1 + + + maven-resources-plugin + 2.6 + + + maven-site-plugin + 3.3 + + + maven-source-plugin + 2.2.1 + + + maven-surefire-plugin + 2.17 + + + - JavaFastPFOR - https://github.com/lemire/JavaFastPFOR/ - -It is a library to compress and uncompress arrays of integers -very fast. The assumption is that most (but not all) values in -your array use less than 32 bits. - + JavaFastPFOR + https://github.com/fast-pack/JavaFastPFOR/ + +A library to compress and uncompress arrays of integers +very quickly. + diff --git a/prebuiltbinaries/JavaFastPFOR-0.0.1.jar b/prebuiltbinaries/JavaFastPFOR-0.0.1.jar deleted file mode 100644 index 6ba32b1..0000000 Binary files a/prebuiltbinaries/JavaFastPFOR-0.0.1.jar and /dev/null differ diff --git a/prebuiltbinaries/JavaFastPFOR-0.0.2.jar b/prebuiltbinaries/JavaFastPFOR-0.0.2.jar deleted file mode 100644 index fa86ec5..0000000 Binary files a/prebuiltbinaries/JavaFastPFOR-0.0.2.jar and /dev/null differ diff --git a/prebuiltbinaries/JavaFastPFOR-0.0.5.jar b/prebuiltbinaries/JavaFastPFOR-0.0.5.jar deleted file mode 100644 index 615ebec..0000000 Binary files a/prebuiltbinaries/JavaFastPFOR-0.0.5.jar and /dev/null differ diff --git a/prebuiltbinaries/JavaFastPFOR-0.0.6.jar b/prebuiltbinaries/JavaFastPFOR-0.0.6.jar deleted file mode 100644 index 4eca834..0000000 Binary files a/prebuiltbinaries/JavaFastPFOR-0.0.6.jar and /dev/null differ diff --git a/src/main/java/com/kamikaze/pfordelta/LCPForDelta.java b/src/main/java/com/kamikaze/pfordelta/LCPForDelta.java index abf6c4f..a948097 100644 --- a/src/main/java/com/kamikaze/pfordelta/LCPForDelta.java +++ b/src/main/java/com/kamikaze/pfordelta/LCPForDelta.java @@ -6,7 +6,6 @@ * JavaFastPFOR library for comparison purposes. As the original */ - /** * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with @@ -28,484 +27,604 @@ import java.util.Arrays; /** - * Implementation of the optimized PForDelta algorithm for sorted integer arrays. The basic ideas are based on + * Implementation of the optimized PForDelta algorithm for sorted integer + * arrays. The basic ideas are based on * * 1. Original algorithm from * http://homepages.cwi.nl/~heman/downloads/msthesis.pdf * - * 2. Optimization and - * variation from http://www2008.org/papers/pdf/p387-zhangA.pdf + * 2. Optimization and variation from + * http://www2008.org/papers/pdf/p387-zhangA.pdf * - * 3. Further optimization - * http://www2009.org/proceedings/pdf/p401.pdf + * 3. Further optimization http://www2009.org/proceedings/pdf/p401.pdf * - * As a part of the PForDelta implementation, Simple16 is used to compress exceptions. - * The original Simple16 algorithm can also be found in the above literature. + * As a part of the PForDelta implementation, Simple16 is used to compress + * exceptions. The original Simple16 algorithm can also be found in the above + * literature. * - * This implementation overcomes the problem that Simple16 cannot deal with >2^28 numbers. + * This implementation overcomes the problem that Simple16 cannot deal with + * greater than 2^28 numbers. + * + * This implementation is almost same as PForDelta in the same package, except + * that it is tuned especially for Lucene-4.0 Codec to achieve the best + * performance in Lucene-4.0. * - * This implementation is almost same as PForDelta in the same package, except that it is tuned especially for Lucene-4.0 Codec to achieve - * the best performance in Lucene-4.0. - * * @author hao yan, hyan2008@gmail.com */ -@SuppressWarnings("javadoc") public class LCPForDelta { - // NOTE: we expect the blockSize is always < (1<<(31-POSSIBLE_B_BITS)). For example, in the current default settings, - // the blockSize < (1<<(31-5)), that is, < 2^27 - - //All possible values of b in the PForDelta algorithm - private static final int[] POSSIBLE_B = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 16, 20, 28}; - - // POSSIBLE_B.length < (1<>> 5)]; - - int[] expPosBuffer = new int[blockSize]; - int[] expHighBitsBuffer = new int[blockSize]; - - // compress the b-bit slots - for (int i = 0; i < blockSize; ++i) { - int value = inputBlock[i]; - if (value < expUpperBound) { - writeBits(tmpCompBuffer, value, outputOffset, bits); - } else // exp - { - // store the lower bits-bits of the exception - writeBits(tmpCompBuffer, value & MASK[bits], outputOffset, bits); - // write the position of exception - expPosBuffer[expNum] = i; - // write the higher 32-bits bits of the exception - expHighBitsBuffer[expNum] = (value >>> bits) & MASK[32 - bits]; - expNum++; - } - outputOffset += bits; + protected void setCompBuffer(int[] buffer) { + compBuffer = buffer; } - tmpCompBuffer[0] = ((bits & MASK[POSSIBLE_B_BITS]) << (31 - POSSIBLE_B_BITS)) | (expNum & MASK[31 - POSSIBLE_B_BITS]); - - // compress exceptions - if (expNum > 0) { - int compressedBitSize; + /** + * Compress one block of blockSize integers using PForDelta with the + * optimal parameter b + * + * @param inBlock + * the block to be compressed + * @param blockSize + * the block size + * @return the compressed block + */ + public int compress(int[] inBlock, int blockSize) { + // find the best b that can lead to the smallest overall + // compressed size + int currentB = POSSIBLE_B[0]; + int tmpB = currentB; + boolean hasBigNum = checkBigNumbers(inBlock, blockSize, + POSSIBLE_B[POSSIBLE_B.length - 1]); + if (hasBigNum) { + currentB = 4; + } else { + int optSize = estimateCompressedSize(inBlock, + blockSize, tmpB); + for (int i = 1; i < POSSIBLE_B.length; ++i) { + tmpB = POSSIBLE_B[i]; + int curSize = estimateCompressedSize(inBlock, + blockSize, tmpB); + if (curSize < optSize) { + currentB = tmpB; + optSize = curSize; + } + } + } - compressedBitSize = compressBlockByS16(tmpCompBuffer, outputOffset, expPosBuffer, expNum, blockSize, inputBlock); - outputOffset += compressedBitSize; + // compress the block using the above best b + int compressedSizeInInts = compressOneBlockCore(inBlock, + blockSize, currentB); - compressedBitSize = compressBlockByS16(tmpCompBuffer, outputOffset, expHighBitsBuffer, expNum, blockSize, inputBlock); - outputOffset += compressedBitSize; + return compressedSizeInInts; } - // discard the redundant parts in the tmpCompressedBlock - int compressedSizeInInts = (outputOffset + 31) >>> 5; - - compBuffer = tmpCompBuffer; - return compressedSizeInInts; - } - - public int compressOneBlockCore2(int[] inputBlock, int blockSize, int bits) throws IllegalArgumentException { - int outputOffset = HEADER_SIZE; - int expUpperBound = 1 << bits; - int expNum = 0; - int maxCompBitSize = HEADER_SIZE + blockSize * (MAX_BITS + MAX_BITS + MAX_BITS) + 32; - int[] tmpCompBuffer = new int[(maxCompBitSize >>> 5)]; - - int[] expPosBuffer = new int[blockSize]; - int[] expHighBitsBuffer = new int[blockSize]; - - // compress the b-bit slots - for (int i = 0; i < blockSize; ++i) { - int value = inputBlock[i]; - if (value < expUpperBound) { - writeBits(tmpCompBuffer, value, outputOffset, bits); - } else // exp - { - // store the lower bits-bits of the exception - writeBits(tmpCompBuffer, value & MASK[bits], outputOffset, bits); - // write the position of exception - expPosBuffer[expNum] = i; - // write the higher 32-bits bits of the exception - expHighBitsBuffer[expNum] = (value >>> bits) & MASK[32 - bits]; - expNum++; - } - outputOffset += bits; - } + /** + * The core implementation of compressing a block with blockSize + * integers using PForDelta with the given parameter b + * + * @param inputBlock + * the block to be compressed + * @param blockSize + * the block size + * @param bits + * the the value of the parameter b + * @return the size of the compressed block (the number of ints) + */ + public int compressOneBlockCore(int[] inputBlock, int blockSize, + int bits) { + int outputOffset = HEADER_SIZE; + int expUpperBound = 1 << bits; + int expNum = 0; + int maxCompBitSize = HEADER_SIZE + blockSize + * (MAX_BITS + MAX_BITS + MAX_BITS) + 32; + int[] tmpCompBuffer = new int[(maxCompBitSize >>> 5)]; + + int[] expPosBuffer = new int[blockSize]; + int[] expHighBitsBuffer = new int[blockSize]; + + // compress the b-bit slots + for (int i = 0; i < blockSize; ++i) { + int value = inputBlock[i]; + if (value < expUpperBound) { + writeBits(tmpCompBuffer, value, outputOffset, + bits); + } else // exp + { + // store the lower bits-bits of the exception + writeBits(tmpCompBuffer, value & MASK[bits], + outputOffset, bits); + // write the position of exception + expPosBuffer[expNum] = i; + // write the higher 32-bits bits of the + // exception + expHighBitsBuffer[expNum] = (value >>> bits) + & MASK[32 - bits]; + expNum++; + } + outputOffset += bits; + } + + tmpCompBuffer[0] = ((bits & MASK[POSSIBLE_B_BITS]) << (31 - POSSIBLE_B_BITS)) + | (expNum & MASK[31 - POSSIBLE_B_BITS]); - tmpCompBuffer[0] = ((bits & MASK[POSSIBLE_B_BITS]) << (31 - POSSIBLE_B_BITS)) | (expNum & MASK[31 - POSSIBLE_B_BITS]); + // compress exceptions + if (expNum > 0) { + int compressedBitSize; - // compress exceptions - if (expNum > 0) { - int compressedBitSize; + compressedBitSize = compressBlockByS16(tmpCompBuffer, + outputOffset, expPosBuffer, expNum, blockSize, + inputBlock); + outputOffset += compressedBitSize; + + compressedBitSize = compressBlockByS16(tmpCompBuffer, + outputOffset, expHighBitsBuffer, expNum, + blockSize, inputBlock); + outputOffset += compressedBitSize; + } - int[] expBuffer = new int[expNum * 2]; - System.arraycopy(expPosBuffer, 0, expBuffer, 0, expNum); - System.arraycopy(expHighBitsBuffer, 0, expBuffer, expNum, expNum); + // discard the redundant parts in the tmpCompressedBlock + int compressedSizeInInts = (outputOffset + 31) >>> 5; - compressedBitSize = compressBlockByS16(tmpCompBuffer, outputOffset, expBuffer, expNum * 2, blockSize, inputBlock); - outputOffset += compressedBitSize; + compBuffer = tmpCompBuffer; + return compressedSizeInInts; } - // discard the redundant parts in the tmpCompressedBlock - int compressedSizeInInts = (outputOffset + 31) >>> 5; - - compBuffer = tmpCompBuffer; - return compressedSizeInInts; - } - - /** - * Decompress one block using PForDelta - * - * @param decompBlock the block that was decompressed - * @param inBlock the block to be decompressed - * @param blockSize the number of elements in the decompressed block - */ - public static void decompressOneBlock(int[] decompBlock, int[] inBlock, int blockSize) { - int expNum = inBlock[0] & MASK[31 - POSSIBLE_B_BITS]; - int bits = (inBlock[0] >>> (31 - POSSIBLE_B_BITS)) & (0x1f); - - int[] expPosBuffer = new int[blockSize]; - int[] expHighBitsBuffer = new int[blockSize]; - - // decompress the b-bit slots - int offset = HEADER_SIZE; - int compressedBits = 0; - if (bits == 0) { - Arrays.fill(decompBlock, 0); - } else { - compressedBits = decompressBBitSlots(decompBlock, inBlock, blockSize, bits); - //compressedBits = decompressBBitSlotsWithHardCodes(decompBlock, inBlock, blockSize, bits); + protected int compressOneBlockCore2(int[] inputBlock, int blockSize, + int bits) throws IllegalArgumentException { + int outputOffset = HEADER_SIZE; + int expUpperBound = 1 << bits; + int expNum = 0; + int maxCompBitSize = HEADER_SIZE + blockSize + * (MAX_BITS + MAX_BITS + MAX_BITS) + 32; + int[] tmpCompBuffer = new int[(maxCompBitSize >>> 5)]; + + int[] expPosBuffer = new int[blockSize]; + int[] expHighBitsBuffer = new int[blockSize]; + + // compress the b-bit slots + for (int i = 0; i < blockSize; ++i) { + int value = inputBlock[i]; + if (value < expUpperBound) { + writeBits(tmpCompBuffer, value, outputOffset, + bits); + } else // exp + { + // store the lower bits-bits of the exception + writeBits(tmpCompBuffer, value & MASK[bits], + outputOffset, bits); + // write the position of exception + expPosBuffer[expNum] = i; + // write the higher 32-bits bits of the + // exception + expHighBitsBuffer[expNum] = (value >>> bits) + & MASK[32 - bits]; + expNum++; + } + outputOffset += bits; + } + + tmpCompBuffer[0] = ((bits & MASK[POSSIBLE_B_BITS]) << (31 - POSSIBLE_B_BITS)) + | (expNum & MASK[31 - POSSIBLE_B_BITS]); + + // compress exceptions + if (expNum > 0) { + int compressedBitSize; + + int[] expBuffer = new int[expNum * 2]; + System.arraycopy(expPosBuffer, 0, expBuffer, 0, expNum); + System.arraycopy(expHighBitsBuffer, 0, expBuffer, + expNum, expNum); + + compressedBitSize = compressBlockByS16(tmpCompBuffer, + outputOffset, expBuffer, expNum * 2, blockSize, + inputBlock); + outputOffset += compressedBitSize; + } + + // discard the redundant parts in the tmpCompressedBlock + int compressedSizeInInts = (outputOffset + 31) >>> 5; + + compBuffer = tmpCompBuffer; + return compressedSizeInInts; } - offset += compressedBits; - - // decompress exceptions - if (expNum > 0) { - compressedBits = decompressBlockByS16(expPosBuffer, inBlock, offset, expNum); - offset += compressedBits; - compressedBits = decompressBlockByS16(expHighBitsBuffer, inBlock, offset, expNum); - offset += compressedBits; - - for (int i = 0; i < expNum; i++) { - int curExpPos = expPosBuffer[i]; - int curHighBits = expHighBitsBuffer[i]; - decompBlock[curExpPos] = (decompBlock[curExpPos] & MASK[bits]) | ((curHighBits & MASK[32 - bits]) << bits); - } + + /** + * Decompress one block using PForDelta + * + * @param decompBlock + * the block that was decompressed + * @param inBlock + * the block to be decompressed + * @param blockSize + * the number of elements in the decompressed block + */ + public static void decompressOneBlock(int[] decompBlock, int[] inBlock, + int blockSize) { + int expNum = inBlock[0] & MASK[31 - POSSIBLE_B_BITS]; + int bits = (inBlock[0] >>> (31 - POSSIBLE_B_BITS)) & (0x1f); + + int[] expPosBuffer = new int[blockSize]; + int[] expHighBitsBuffer = new int[blockSize]; + + // decompress the b-bit slots + int offset = HEADER_SIZE; + int compressedBits = 0; + if (bits == 0) { + Arrays.fill(decompBlock, 0); + } else { + compressedBits = decompressBBitSlots(decompBlock, + inBlock, blockSize, bits); + // compressedBits = + // decompressBBitSlotsWithHardCodes(decompBlock, + // inBlock, blockSize, bits); + } + offset += compressedBits; + + // decompress exceptions + if (expNum > 0) { + compressedBits = decompressBlockByS16(expPosBuffer, + inBlock, offset, expNum); + offset += compressedBits; + compressedBits = decompressBlockByS16( + expHighBitsBuffer, inBlock, offset, expNum); + offset += compressedBits; + + for (int i = 0; i < expNum; i++) { + int curExpPos = expPosBuffer[i]; + int curHighBits = expHighBitsBuffer[i]; + decompBlock[curExpPos] = (decompBlock[curExpPos] & MASK[bits]) + | ((curHighBits & MASK[32 - bits]) << bits); + } + } } - } - - public static void decompressOneBlockWithSize(int[] decompBlock, int[] inBlock, int blockSize, int[] expPosBuffer, int[] expHighBitsBuffer, int inBlockLen) { - int expNum = inBlock[0] & MASK[31 - POSSIBLE_B_BITS]; - int bits = (inBlock[0] >>> (31 - POSSIBLE_B_BITS)) & (0x1f); - - // decompress the b-bit slots - int offset = HEADER_SIZE; - int compressedBits = 0; - if (bits == 0) { - Arrays.fill(decompBlock, 0, inBlockLen, 0); - } else { - //compressedBits = decompressBBitSlotsWithHardCodes(decompBlock, inBlock, blockSize, bits); - compressedBits = decompressBBitSlots(decompBlock, inBlock, blockSize, bits); + + protected static void decompressOneBlockWithSize(int[] decompBlock, + int[] inBlock, int blockSize, int[] expPosBuffer, + int[] expHighBitsBuffer, int inBlockLen) { + int expNum = inBlock[0] & MASK[31 - POSSIBLE_B_BITS]; + int bits = (inBlock[0] >>> (31 - POSSIBLE_B_BITS)) & (0x1f); + + // decompress the b-bit slots + int offset = HEADER_SIZE; + int compressedBits = 0; + if (bits == 0) { + Arrays.fill(decompBlock, 0, inBlockLen, 0); + } else { + // compressedBits = + // decompressBBitSlotsWithHardCodes(decompBlock, + // inBlock, blockSize, bits); + compressedBits = decompressBBitSlots(decompBlock, + inBlock, blockSize, bits); + } + offset += compressedBits; + + // decompress exceptions + if (expNum > 0) { + compressedBits = decompressBlockByS16(expPosBuffer, + inBlock, offset, expNum); + offset += compressedBits; + compressedBits = decompressBlockByS16( + expHighBitsBuffer, inBlock, offset, expNum); + offset += compressedBits; + + for (int i = 0; i < expNum; i++) { + int curExpPos = expPosBuffer[i]; + int curHighBits = expHighBitsBuffer[i]; + decompBlock[curExpPos] = (decompBlock[curExpPos] & MASK[bits]) + | ((curHighBits & MASK[32 - bits]) << bits); + } + } } - offset += compressedBits; - - // decompress exceptions - if (expNum > 0) { - compressedBits = decompressBlockByS16(expPosBuffer, inBlock, offset, expNum); - offset += compressedBits; - compressedBits = decompressBlockByS16(expHighBitsBuffer, inBlock, offset, expNum); - offset += compressedBits; - - for (int i = 0; i < expNum; i++) { - int curExpPos = expPosBuffer[i]; - int curHighBits = expHighBitsBuffer[i]; - decompBlock[curExpPos] = (decompBlock[curExpPos] & MASK[bits]) | ((curHighBits & MASK[32 - bits]) << bits); - } + + protected static void decompressOneBlockWithSizeWithIntBuffer( + final int[] decompBlock, final IntBuffer inBlock, + final int blockSize, final int[] expPosBuffer, + final int[] expHighBitsBuffer, final int inBlockLen) { + final int flag = inBlock.get(); + final int expNum = flag & MASK[31 - POSSIBLE_B_BITS]; + final int bits = (flag >>> (31 - POSSIBLE_B_BITS)) & (0x1f); + if (bits == 0) { + Arrays.fill(decompBlock, 0, inBlockLen, 0); + } else { + PForDeltaUnpack128WIthIntBuffer.unpack(decompBlock, + inBlock, bits); + } + + if (expNum > 0) { + // decompress expPos + int num, outOffset = 0, numLeft; + for (numLeft = expNum; numLeft > 0; numLeft -= num) { + num = Simple16WithHardCodes + .s16DecompressWithIntBufferWithHardCodes( + expPosBuffer, outOffset, + inBlock.get(), numLeft); + outOffset += num; + } + + // decompress expHighBits and decompBlock at the same + // time + for (outOffset = 0, numLeft = expNum; numLeft > 0; numLeft -= num) { + num = Simple16WithHardCodes + .s16DecompressWithIntBufferIntegrated2( + decompBlock, outOffset, + inBlock.get(), numLeft, + expPosBuffer, bits); + outOffset += num; + } + } } - } - - public static void decompressOneBlockWithSizeWithIntBuffer(final int[] decompBlock, final IntBuffer inBlock, final int blockSize, final int[] expPosBuffer, final int[] expHighBitsBuffer, final int inBlockLen) { - final int flag = inBlock.get(); - final int expNum = flag & MASK[31 - POSSIBLE_B_BITS]; - final int bits = (flag >>> (31 - POSSIBLE_B_BITS)) & (0x1f); - if (bits == 0) { - Arrays.fill(decompBlock, 0, inBlockLen, 0); - } else { - PForDeltaUnpack128WIthIntBuffer.unpack(decompBlock, inBlock, bits); + + /** + * Estimate the compressed size in ints of a block + * + * @param inputBlock + * the block to be compressed + * @param bits + * the value of the parameter b + * @param blockSize + * the block size + * @return the compressed size in ints + */ + public static int estimateCompressedSize(int[] inputBlock, + int blockSize, int bits) { + int maxNoExp = (1 << bits) - 1; + // Size of the header and the bits-bit slots + int outputOffset = HEADER_SIZE + bits * blockSize; + int expNum = 0; + + for (int i = 0; i < blockSize; ++i) { + if (inputBlock[i] > maxNoExp) { + expNum++; + } + } + outputOffset += (expNum << 5); + + return outputOffset; } - if (expNum > 0) { - // decompress expPos - int num, outOffset = 0, numLeft; - for (numLeft = expNum; numLeft > 0; numLeft -= num) { - num = Simple16WithHardCodes.s16DecompressWithIntBufferWithHardCodes(expPosBuffer, outOffset, inBlock.get(), numLeft); - outOffset += num; - } - - // decompress expHighBits and decompBlock at the same time - for (outOffset = 0, numLeft = expNum; numLeft > 0; numLeft -= num) { - num = Simple16WithHardCodes.s16DecompressWithIntBufferIntegrated2(decompBlock, outOffset, inBlock.get(), numLeft, expPosBuffer, bits); - outOffset += num; - } + /** + * Check if the block contains big numbers that is greater than ((1<< + * bits)-1) + * + * @param inputBlock + * the block to be compressed + * @param bits + * the numbers of bits to decide whether a number is a + * big number + * @param blockSize + * the block size + * @return true if there is any big numbers in the block + */ + public static boolean checkBigNumbers(int[] inputBlock, int blockSize, + int bits) { + int maxNoExp = (1 << bits) - 1; + for (int i = 0; i < blockSize; ++i) { + if (inputBlock[i] > maxNoExp) + return true; + } + return false; } - } - - - /** - * Estimate the compressed size in ints of a block - * - * @param inputBlock the block to be compressed - * @param bits the value of the parameter b - * @param blockSize the block size - * @return the compressed size in ints - * @throws IllegalArgumentException - */ - public static int estimateCompressedSize(int[] inputBlock, int blockSize, int bits) throws IllegalArgumentException { - int maxNoExp = (1 << bits) - 1; - // Size of the header and the bits-bit slots - int outputOffset = HEADER_SIZE + bits * blockSize; - int expNum = 0; - - for (int i = 0; i < blockSize; ++i) { - if (inputBlock[i] > maxNoExp) { - expNum++; - } + + /** + * Decompress b-bit slots + * + * @param outDecompSlots + * decompressed block which is the output + * @param inCompBlock + * the compressed block which is the input + * @param blockSize + * the block size + * @param bits + * the value of the parameter b + * @return the compressed size in bits of the data that has been + * decompressed + */ + public static int decompressBBitSlots(int[] outDecompSlots, + int[] inCompBlock, int blockSize, int bits) { + int compressedBitSize = 0; + int offset = HEADER_SIZE; + for (int i = 0; i < blockSize; i++) { + outDecompSlots[i] = readBits(inCompBlock, offset, bits); + offset += bits; + } + compressedBitSize = bits * blockSize; + + return compressedBitSize; } - outputOffset += (expNum << 5); - - return outputOffset; - } - - /** - * Check if the block contains big numbers that is greater than ((1<< bits)-1) - * - * @param inputBlock the block to be compressed - * @param bits the numbers of bits to decide whether a number is a big number - * @param blockSize the block size - * @return true if there is any big numbers in the block - * @throws IllegalArgumentException - */ - public static boolean checkBigNumbers(int[] inputBlock, int blockSize, int bits) throws IllegalArgumentException { - int maxNoExp = (1 << bits) - 1; - for (int i = 0; i < blockSize; ++i) { - if (inputBlock[i] > maxNoExp) return true; + + protected static int decompressBBitSlotsWithHardCodes( + final int[] outDecompSlots, final int[] inCompBlock, + final int blockSize, final int bits) { + int compressedBitSize = 0; + PForDeltaUnpack128.unpack(outDecompSlots, inCompBlock, bits); + compressedBitSize = bits * blockSize; + return compressedBitSize; } - return false; - } - - - /** - * Decompress b-bit slots - * - * @param outDecompSlots decompressed block which is the output - * @param inCompBlock the compressed block which is the input - * @param blockSize the block size - * @param bits the value of the parameter b - * @return the compressed size in bits of the data that has been decompressed - */ - public static int decompressBBitSlots(int[] outDecompSlots, int[] inCompBlock, int blockSize, int bits) { - int compressedBitSize = 0; - int offset = HEADER_SIZE; - for (int i = 0; i < blockSize; i++) { - outDecompSlots[i] = readBits(inCompBlock, offset, bits); - offset += bits; + + protected static int decompressBBitSlotsWithHardCodesWithIntBuffer( + final int[] outDecompSlots, final IntBuffer inCompBlock, + final int blockSize, final int bits) { + PForDeltaUnpack128WIthIntBuffer.unpack(outDecompSlots, + inCompBlock, bits); + return bits * blockSize; } - compressedBitSize = bits * blockSize; - - return compressedBitSize; - } - - - public static int decompressBBitSlotsWithHardCodes(final int[] outDecompSlots, final int[] inCompBlock, final int blockSize, final int bits) { - int compressedBitSize = 0; - PForDeltaUnpack128.unpack(outDecompSlots, inCompBlock, bits); - compressedBitSize = bits * blockSize; - return compressedBitSize; - } - - public static int decompressBBitSlotsWithHardCodesWithIntBuffer(final int[] outDecompSlots, final IntBuffer inCompBlock, final int blockSize, final int bits) { - PForDeltaUnpack128WIthIntBuffer.unpack(outDecompSlots, inCompBlock, bits); - return bits * blockSize; - } - - - /** - * Compress a block of blockSize integers using Simple16 algorithm - * - * @param outCompBlock the compressed block which is the output - * @param outStartOffsetInBits the start offset in bits of the compressed block - * @param inBlock the block to be compressed - * @param blockSize the block size - * @return the compressed size in bits - */ - private static int compressBlockByS16(int[] outCompBlock, int outStartOffsetInBits, int[] inBlock, int blockSize, int oriBlockSize, int[] oriInputBlock) { - int outOffset = (outStartOffsetInBits + 31) >>> 5; - int num, inOffset = 0, numLeft; - for (numLeft = blockSize; numLeft > 0; numLeft -= num) { - num = Simple16WithHardCodes.s16Compress(outCompBlock, outOffset, inBlock, inOffset, numLeft, blockSize, oriBlockSize, oriInputBlock); - outOffset++; - inOffset += num; + + /** + * Compress a block of blockSize integers using Simple16 algorithm + * + * @param outCompBlock + * the compressed block which is the output + * @param outStartOffsetInBits + * the start offset in bits of the compressed block + * @param inBlock + * the block to be compressed + * @param blockSize + * the block size + * @return the compressed size in bits + */ + private static int compressBlockByS16(int[] outCompBlock, + int outStartOffsetInBits, int[] inBlock, int blockSize, + int oriBlockSize, int[] oriInputBlock) { + int outOffset = (outStartOffsetInBits + 31) >>> 5; + int num, inOffset = 0, numLeft; + for (numLeft = blockSize; numLeft > 0; numLeft -= num) { + num = Simple16WithHardCodes.s16Compress(outCompBlock, + outOffset, inBlock, inOffset, numLeft, + blockSize, oriBlockSize, oriInputBlock); + outOffset++; + inOffset += num; + } + int compressedBitSize = (outOffset << 5) - outStartOffsetInBits; + return compressedBitSize; } - int compressedBitSize = (outOffset << 5) - outStartOffsetInBits; - return compressedBitSize; - } - - /** - * Decompress a block of blockSize integers using Simple16 algorithm - * - * @param outDecompBlock the decompressed block which is the output - * @param inCompBlock the compressed block which is the input - * @param blockSize the block size - * @param inStartOffsetInBits the start offset in bits of the compressed block - * @return the compressed size in bits of the data that has been decompressed - */ - public static int decompressBlockByS16(int[] outDecompBlock, int[] inCompBlock, int inStartOffsetInBits, int blockSize) { - int inOffset = (inStartOffsetInBits + 31) >>> 5; - int num, outOffset = 0, numLeft; - for (numLeft = blockSize; numLeft > 0; numLeft -= num) { - num = Simple16.s16Decompress(outDecompBlock, outOffset, inCompBlock, inOffset, numLeft); - outOffset += num; - inOffset++; + + /** + * Decompress a block of blockSize integers using Simple16 algorithm + * + * @param outDecompBlock + * the decompressed block which is the output + * @param inCompBlock + * the compressed block which is the input + * @param blockSize + * the block size + * @param inStartOffsetInBits + * the start offset in bits of the compressed block + * @return the compressed size in bits of the data that has been + * decompressed + */ + public static int decompressBlockByS16(int[] outDecompBlock, + int[] inCompBlock, int inStartOffsetInBits, int blockSize) { + int inOffset = (inStartOffsetInBits + 31) >>> 5; + int num, outOffset = 0, numLeft; + for (numLeft = blockSize; numLeft > 0; numLeft -= num) { + num = Simple16.s16Decompress(outDecompBlock, outOffset, + inCompBlock, inOffset, numLeft); + outOffset += num; + inOffset++; + } + int compressedBitSize = (inOffset << 5) - inStartOffsetInBits; + return compressedBitSize; } - int compressedBitSize = (inOffset << 5) - inStartOffsetInBits; - return compressedBitSize; - } - - public static void decompressBlockByS16WithIntBuffer(final int[] outDecompBlock, final IntBuffer inCompBlock, final int blockSize) { - int num, outOffset = 0, numLeft; - for (numLeft = blockSize; numLeft > 0; numLeft -= num) { - num = Simple16WithHardCodes.s16DecompressWithIntBuffer(outDecompBlock, outOffset, inCompBlock.get(), numLeft); - outOffset += num; + + protected static void decompressBlockByS16WithIntBuffer( + final int[] outDecompBlock, final IntBuffer inCompBlock, + final int blockSize) { + int num, outOffset = 0, numLeft; + for (numLeft = blockSize; numLeft > 0; numLeft -= num) { + num = Simple16WithHardCodes.s16DecompressWithIntBuffer( + outDecompBlock, outOffset, inCompBlock.get(), + numLeft); + outOffset += num; + } } - } - public static void decompressBlockByS16WithIntBufferIntegrated(final int[] outDecompBlock, final IntBuffer inCompBlock, final int blockSize, int[] expPosBuffer, int oribits) { - int num, outOffset = 0, numLeft; - for (numLeft = blockSize; numLeft > 0; numLeft -= num) { - num = Simple16WithHardCodes.s16DecompressWithIntBufferIntegrated(outDecompBlock, outOffset, inCompBlock.get(), numLeft, expPosBuffer, oribits); - outOffset += num; + protected static void decompressBlockByS16WithIntBufferIntegrated( + final int[] outDecompBlock, final IntBuffer inCompBlock, + final int blockSize, int[] expPosBuffer, int oribits) { + int num, outOffset = 0, numLeft; + for (numLeft = blockSize; numLeft > 0; numLeft -= num) { + num = Simple16WithHardCodes + .s16DecompressWithIntBufferIntegrated( + outDecompBlock, outOffset, + inCompBlock.get(), numLeft, + expPosBuffer, oribits); + outOffset += num; + } } - } - - - /** - * Write a certain number of bits of an integer into an integer array starting from the given start offset - * - * @param out the output array - * @param val the integer to be written - * @param outOffset the start offset in bits in the output array - * @param bits the number of bits to be written (bits>=0) - */ - public static final void writeBits(int[] out, int val, int outOffset, int bits) { - if (bits == 0) - return; - final int index = outOffset >>> 5; - final int skip = outOffset & 0x1f; - val &= (0xffffffff >>> (32 - bits)); - out[index] |= (val << skip); - if (32 - skip < bits) { - out[index + 1] |= (val >>> (32 - skip)); + + /** + * Write a certain number of bits of an integer into an integer array + * starting from the given start offset + * + * @param out + * the output array + * @param val + * the integer to be written + * @param outOffset + * the start offset in bits in the output array + * @param bits + * the number of bits to be written (bits greater or equal to 0) + */ + public static final void writeBits(int[] out, int val, int outOffset, + int bits) { + if (bits == 0) + return; + final int index = outOffset >>> 5; + final int skip = outOffset & 0x1f; + val &= (0xffffffff >>> (32 - bits)); + out[index] |= (val << skip); + if (32 - skip < bits) { + out[index + 1] |= (val >>> (32 - skip)); + } } - } - - /** - * Read a certain number of bits of an integer into an integer array starting from the given start offset - * - * @param in the input array - * @param inOffset the start offset in bits in the input array - * @param bits the number of bits to be read, unlike writeBits(), readBits() does not deal with bits==0 and thus bits must > 0. When bits ==0, the calling functions will just skip the entire bits-bit slots without decoding them - * @return the bits bits of the input - */ - public static final int readBits(int[] in, final int inOffset, final int bits) { - final int index = inOffset >>> 5; - final int skip = inOffset & 0x1f; - int val = in[index] >>> skip; - if (32 - skip < bits) { - val |= (in[index + 1] << (32 - skip)); + + /** + * Read a certain number of bits of an integer into an integer array + * starting from the given start offset + * + * @param in + * the input array + * @param inOffset + * the start offset in bits in the input array + * @param bits + * the number of bits to be read, unlike writeBits(), + * readBits() does not deal with bits==0 and thus bits + * must be greater than 0. When bits ==0, the calling functions will + * just skip the entire bits-bit slots without decoding + * them + * @return the bits bits of the input + */ + public static final int readBits(int[] in, final int inOffset, + final int bits) { + final int index = inOffset >>> 5; + final int skip = inOffset & 0x1f; + int val = in[index] >>> skip; + if (32 - skip < bits) { + val |= (in[index + 1] << (32 - skip)); + } + return val & (0xffffffff >>> (32 - bits)); } - return val & (0xffffffff >>> (32 - bits)); - } - - public static final int readBitsWithBuffer(int[] in, final int inOffset, final int bits) { - final int index = inOffset >>> 5; - final int skip = inOffset & 0x1f; - int val = in[index] >>> skip; - if (32 - skip < bits) { - val |= (in[index + 1] << (32 - skip)); + + protected static final int readBitsWithBuffer(int[] in, + final int inOffset, final int bits) { + final int index = inOffset >>> 5; + final int skip = inOffset & 0x1f; + int val = in[index] >>> skip; + if (32 - skip < bits) { + val |= (in[index + 1] << (32 - skip)); + } + return val & (0xffffffff >>> (32 - bits)); } - return val & (0xffffffff >>> (32 - bits)); - } } - - diff --git a/src/main/java/com/kamikaze/pfordelta/PForDelta.java b/src/main/java/com/kamikaze/pfordelta/PForDelta.java index 69bb56f..9be8e07 100644 --- a/src/main/java/com/kamikaze/pfordelta/PForDelta.java +++ b/src/main/java/com/kamikaze/pfordelta/PForDelta.java @@ -1,6 +1,5 @@ package com.kamikaze.pfordelta; - import java.util.Arrays; /** @@ -10,347 +9,434 @@ */ /** - * Implementation of the optimized PForDelta algorithm for sorted integer arrays. The basic ideas are based on + * Implementation of the optimized PForDelta algorithm for sorted integer + * arrays. The basic ideas are based on * * 1. Original algorithm from * http://homepages.cwi.nl/~heman/downloads/msthesis.pdf * - * 2. Optimization and - * variation from http://www2008.org/papers/pdf/p387-zhangA.pdf + * 2. Optimization and variation from + * http://www2008.org/papers/pdf/p387-zhangA.pdf * - * 3. Further optimization - * http://www2009.org/proceedings/pdf/p401.pdf + * 3. Further optimization http://www2009.org/proceedings/pdf/p401.pdf * - * As a part of the PForDelta implementation, Simple16 is used to compress exceptions. The original Simple16 algorithm can also be found in the above literatures. + * As a part of the PForDelta implementation, Simple16 is used to compress + * exceptions. The original Simple16 algorithm can also be found in the above + * literatures. * - * This implementation overcomes the problem that Simple16 cannot deal with >2^28 numbers. + * This implementation overcomes the problem that Simple16 cannot deal with + * more than 2^28 numbers. * * Author: hao yan hyan2008@gmail.com */ public class PForDelta { - // NOTE: we expect the blockSize is always < (1<<(31-POSSIBLE_B_BITS)). For example, in the current default settings, - // the blockSize < (1<<(31-5)), that is, < 2^27, the commonly used block size is 128 or 256. - - //All possible values of b in the PForDelta algorithm - private static final int[] POSSIBLE_B = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 16, 20, 28}; - - // Max number of bits to store an uncompressed value - private static final int MAX_BITS = 32; - // Header records the value of b and the number of exceptions in the block - private static final int HEADER_NUM = 2; - // Header size in bits - private static final int HEADER_SIZE = MAX_BITS * HEADER_NUM; - - private static final int[] MASK = {0x00000000, - 0x00000001, 0x00000003, 0x00000007, 0x0000000f, 0x0000001f, 0x0000003f, - 0x0000007f, 0x000000ff, 0x000001ff, 0x000003ff, 0x000007ff, 0x00000fff, - 0x00001fff, 0x00003fff, 0x00007fff, 0x0000ffff, 0x0001ffff, 0x0003ffff, - 0x0007ffff, 0x000fffff, 0x001fffff, 0x003fffff, 0x007fffff, 0x00ffffff, - 0x01ffffff, 0x03ffffff, 0x07ffffff, 0x0fffffff, 0x1fffffff, 0x3fffffff, - 0x7fffffff, 0xffffffff}; - - /** - * Compress one block of blockSize integers using PForDelta with the optimal parameter b - * - * @param inBlock the block to be compressed - * @param blockSize the block size - * @return the compressed block - */ - public static int[] compressOneBlockOpt(final int[] inBlock, int blockSize) { - // find the best b that may lead to the smallest overall compressed size - int currentB = POSSIBLE_B[0]; - int[] outBlock = null; - int tmpB = currentB; - // deal with the large exception cases - boolean hasBigNum = checkBigNumbers(inBlock, POSSIBLE_B[POSSIBLE_B.length - 1], blockSize); - if (hasBigNum) { - currentB = 4; - System.out.println("has big num and the currentB is: " + currentB); - } else { - int optSize = estimateCompressedSize(inBlock, tmpB, blockSize); - for (int i = 1; i < POSSIBLE_B.length; ++i) { - tmpB = POSSIBLE_B[i]; - int curSize = estimateCompressedSize(inBlock, tmpB, blockSize); - if (curSize < optSize) { - currentB = tmpB; - optSize = curSize; + // NOTE: we expect the blockSize is always < (1<<(31-POSSIBLE_B_BITS)). + // For example, in the current default settings, + // the blockSize < (1<<(31-5)), that is, < 2^27, the commonly used block + // size is 128 or 256. + + // All possible values of b in the PForDelta algorithm + private static final int[] POSSIBLE_B = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 16, 20, 28 }; + + // Max number of bits to store an uncompressed value + private static final int MAX_BITS = 32; + // Header records the value of b and the number of exceptions in the + // block + private static final int HEADER_NUM = 2; + // Header size in bits + private static final int HEADER_SIZE = MAX_BITS * HEADER_NUM; + + private static final int[] MASK = { 0x00000000, 0x00000001, 0x00000003, + 0x00000007, 0x0000000f, 0x0000001f, 0x0000003f, 0x0000007f, + 0x000000ff, 0x000001ff, 0x000003ff, 0x000007ff, 0x00000fff, + 0x00001fff, 0x00003fff, 0x00007fff, 0x0000ffff, 0x0001ffff, + 0x0003ffff, 0x0007ffff, 0x000fffff, 0x001fffff, 0x003fffff, + 0x007fffff, 0x00ffffff, 0x01ffffff, 0x03ffffff, 0x07ffffff, + 0x0fffffff, 0x1fffffff, 0x3fffffff, 0x7fffffff, 0xffffffff }; + + /** + * Compress one block of blockSize integers using PForDelta with the + * optimal parameter b + * + * @param inBlock + * the block to be compressed + * @param blockSize + * the block size + * @return the compressed block + */ + public static int[] compressOneBlockOpt(final int[] inBlock, + int blockSize) { + // find the best b that may lead to the smallest overall + // compressed size + int currentB = POSSIBLE_B[0]; + int[] outBlock = null; + int tmpB = currentB; + // deal with the large exception cases + boolean hasBigNum = checkBigNumbers(inBlock, + POSSIBLE_B[POSSIBLE_B.length - 1], blockSize); + if (hasBigNum) { + currentB = 4; + System.out.println("has big num and the currentB is: " + + currentB); + } else { + int optSize = estimateCompressedSize(inBlock, tmpB, + blockSize); + for (int i = 1; i < POSSIBLE_B.length; ++i) { + tmpB = POSSIBLE_B[i]; + int curSize = estimateCompressedSize(inBlock, + tmpB, blockSize); + if (curSize < optSize) { + currentB = tmpB; + optSize = curSize; + } + } } - } - } - // compress the block using the above best b - outBlock = compressOneBlock(inBlock, currentB, blockSize); - - return outBlock; - } - - /** - * Decompress one block using PForDelta - * - * @param outBlock the block that was decompressed - * @param inBlock the block to be decompressed - * @param blockSize the number of elements in the decompressed block - * @return the compressed size in bits - */ - public static int decompressOneBlock(int[] outBlock, int[] inBlock, int blockSize) { - int[] expAux = new int[blockSize * 2]; - - int expNum = inBlock[0] & 0x3ff; - int bits = (inBlock[0] >>> 10) & (0x1f); - - // decompress the b-bit slots - int offset = HEADER_SIZE; - int compressedBits = 0; - if (bits == 0) { - Arrays.fill(outBlock, 0); - } else { - compressedBits = decompressBBitSlots(outBlock, inBlock, blockSize, bits); - // Note that blocksize must be ==128 in order to use decompressBBitSlotsWithHardCodes - //compressedBits = decompressBBitSlotsWithHardCodes(outBlock, inBlock, blockSize, bits); - } - offset += compressedBits; - - // decompress exceptions - if (expNum > 0) { - compressedBits = decompressBlockByS16(expAux, inBlock, offset, expNum * 2); - offset += compressedBits; - - for (int i = 0; i < expNum; i++) { - int curExpPos = expAux[i]; - int curHighBits = expAux[i + expNum]; - outBlock[curExpPos] = (outBlock[curExpPos] & MASK[bits]) | ((curHighBits & MASK[32 - bits]) << bits); - } + // compress the block using the above best b + outBlock = compressOneBlock(inBlock, currentB, blockSize); + + return outBlock; } - return offset; - } - - /** - * Estimate the compressed size in ints of a block - * - * @param inputBlock the block to be compressed - * @param bits the value of the parameter b - * @param blockSize the block size - * @return the compressed size in ints - * @throws IllegalArgumentException - */ - public static int estimateCompressedSize(int[] inputBlock, int bits, int blockSize) throws IllegalArgumentException { - int maxNoExp = (1 << bits) - 1; - // Size of the header and the bits-bit slots - int outputOffset = HEADER_SIZE + bits * blockSize; - int expNum = 0; - - for (int i = 0; i < blockSize; ++i) { - if (inputBlock[i] > maxNoExp) { - expNum++; - } + + /** + * Decompress one block using PForDelta + * + * @param outBlock + * the block that was decompressed + * @param inBlock + * the block to be decompressed + * @param blockSize + * the number of elements in the decompressed block + * @return the compressed size in bits + */ + public static int decompressOneBlock(int[] outBlock, int[] inBlock, + int blockSize) { + int[] expAux = new int[blockSize * 2]; + + int expNum = inBlock[0] & 0x3ff; + int bits = (inBlock[0] >>> 10) & (0x1f); + + // decompress the b-bit slots + int offset = HEADER_SIZE; + int compressedBits = 0; + if (bits == 0) { + Arrays.fill(outBlock, 0); + } else { + compressedBits = decompressBBitSlots(outBlock, inBlock, + blockSize, bits); + // Note that blocksize must be ==128 in order to use + // decompressBBitSlotsWithHardCodes + // compressedBits = + // decompressBBitSlotsWithHardCodes(outBlock, inBlock, + // blockSize, bits); + } + offset += compressedBits; + + // decompress exceptions + if (expNum > 0) { + compressedBits = decompressBlockByS16(expAux, inBlock, + offset, expNum * 2); + offset += compressedBits; + + for (int i = 0; i < expNum; i++) { + int curExpPos = expAux[i]; + int curHighBits = expAux[i + expNum]; + outBlock[curExpPos] = (outBlock[curExpPos] & MASK[bits]) + | ((curHighBits & MASK[32 - bits]) << bits); + } + } + return offset; } - outputOffset += (expNum << 5); - - return outputOffset; - } - - /** - * Check if the block contains big numbers that is greater than ((1<< bits)-1) - * - * @param inputBlock the block to be compressed - * @param bits the numbers of bits to decide whether a number is a big number - * @param blockSize the block size - * @return true if there is any big numbers in the block - * @throws IllegalArgumentException - */ - public static boolean checkBigNumbers(int[] inputBlock, int bits, int blockSize) throws IllegalArgumentException { - int maxNoExp = (1 << bits) - 1; - for (int i = 0; i < blockSize; ++i) { - if (inputBlock[i] > maxNoExp) return true; + + /** + * Estimate the compressed size in ints of a block + * + * @param inputBlock + * the block to be compressed + * @param bits + * the value of the parameter b + * @param blockSize + * the block size + * @return the compressed size in ints + */ + public static int estimateCompressedSize(int[] inputBlock, int bits, + int blockSize) { + int maxNoExp = (1 << bits) - 1; + // Size of the header and the bits-bit slots + int outputOffset = HEADER_SIZE + bits * blockSize; + int expNum = 0; + + for (int i = 0; i < blockSize; ++i) { + if (inputBlock[i] > maxNoExp) { + expNum++; + } + } + outputOffset += (expNum << 5); + + return outputOffset; } - return false; - } - - /** - * The core implementation of compressing a block with blockSize integers using PForDelta with the given parameter b - * - * @param inputBlock the block to be compressed - * @param bits the the value of the parameter b - * @param blockSize the block size - * @return the compressed block - * @throws IllegalArgumentException - */ - public static int[] compressOneBlock(int[] inputBlock, int bits, int blockSize) throws IllegalArgumentException { - - int[] expAux = new int[blockSize * 2]; - - int maxCompBitSize = HEADER_SIZE + blockSize * (MAX_BITS + MAX_BITS + MAX_BITS) + 32; - int[] tmpCompressedBlock = new int[(maxCompBitSize >>> 5)]; - - int outputOffset = HEADER_SIZE; - int expUpperBound = 1 << bits; - int expNum = 0; - - for (int elem : inputBlock) { - if (elem >= expUpperBound) { - expNum++; - } + + /** + * Check if the block contains big numbers that is greater than ((1<< + * bits)-1) + * + * @param inputBlock + * the block to be compressed + * @param bits + * the numbers of bits to decide whether a number is a + * big number + * @param blockSize + * the block size + * @return true if there is any big numbers in the block + */ + public static boolean checkBigNumbers(int[] inputBlock, int bits, + int blockSize) { + int maxNoExp = (1 << bits) - 1; + for (int i = 0; i < blockSize; ++i) { + if (inputBlock[i] > maxNoExp) + return true; + } + return false; } - int expIndex = 0; - // compress the b-bit slots - for (int i = 0; i < blockSize; ++i) { - if (inputBlock[i] < expUpperBound) { - writeBits(tmpCompressedBlock, inputBlock[i], outputOffset, bits); - } else // exp - { - // store the lower bits-bits of the exception - writeBits(tmpCompressedBlock, inputBlock[i] & MASK[bits], outputOffset, bits); - // write the position of exception - expAux[expIndex] = i; - // write the higher 32-bits bits of the exception - expAux[expIndex + expNum] = (inputBlock[i] >>> bits) & MASK[32 - bits]; - expIndex++; - } - outputOffset += bits; + /** + * The core implementation of compressing a block with blockSize + * integers using PForDelta with the given parameter b + * + * @param inputBlock + * the block to be compressed + * @param bits + * the the value of the parameter b + * @param blockSize + * the block size + * @return the compressed block + */ + public static int[] compressOneBlock(int[] inputBlock, int bits, + int blockSize) { + + int[] expAux = new int[blockSize * 2]; + + int maxCompBitSize = HEADER_SIZE + blockSize + * (MAX_BITS + MAX_BITS + MAX_BITS) + 32; + int[] tmpCompressedBlock = new int[(maxCompBitSize >>> 5)]; + + int outputOffset = HEADER_SIZE; + int expUpperBound = 1 << bits; + int expNum = 0; + + for (int elem : inputBlock) { + if (elem >= expUpperBound) { + expNum++; + } + } + + int expIndex = 0; + // compress the b-bit slots + for (int i = 0; i < blockSize; ++i) { + if (inputBlock[i] < expUpperBound) { + writeBits(tmpCompressedBlock, inputBlock[i], + outputOffset, bits); + } else // exp + { + // store the lower bits-bits of the exception + writeBits(tmpCompressedBlock, inputBlock[i] + & MASK[bits], outputOffset, bits); + // write the position of exception + expAux[expIndex] = i; + // write the higher 32-bits bits of the + // exception + expAux[expIndex + expNum] = (inputBlock[i] >>> bits) + & MASK[32 - bits]; + expIndex++; + } + outputOffset += bits; + } + + // the first int in the compressed block stores the value of b + // and the number of exceptions + // tmpCompressedBlock[0] = ((bits & MASK[POSSIBLE_B_BITS]) << + // (31-POSSIBLE_B_BITS)) | (expNum & MASK[31-POSSIBLE_B_BITS]); + tmpCompressedBlock[0] = ((bits & MASK[10]) << 10) + | (expNum & 0x3ff); + tmpCompressedBlock[1] = inputBlock[blockSize - 1]; + + // compress exceptions + if (expNum > 0) { + int compressedBitSize = compressBlockByS16( + tmpCompressedBlock, outputOffset, expAux, + expNum * 2); + outputOffset += compressedBitSize; + } + + // discard the redundant parts in the tmpCompressedBlock + int compressedSizeInInts = (outputOffset + 31) >>> 5; + int[] compBlock; + compBlock = new int[compressedSizeInInts]; + System.arraycopy(tmpCompressedBlock, 0, compBlock, 0, + compressedSizeInInts); + + return compBlock; } - // the first int in the compressed block stores the value of b and the number of exceptions - //tmpCompressedBlock[0] = ((bits & MASK[POSSIBLE_B_BITS]) << (31-POSSIBLE_B_BITS)) | (expNum & MASK[31-POSSIBLE_B_BITS]); - tmpCompressedBlock[0] = ((bits & MASK[10]) << 10) | (expNum & 0x3ff); - tmpCompressedBlock[1] = inputBlock[blockSize - 1]; + /** + * Decompress b-bit slots + * + * @param outDecompSlots + * decompressed block which is the output + * @param inCompBlock + * the compressed block which is the input + * @param blockSize + * the block size + * @param bits + * the value of the parameter b + * @return the compressed size in bits of the data that has been + * decompressed + */ + public static int decompressBBitSlots(int[] outDecompSlots, + int[] inCompBlock, int blockSize, int bits) { + int compressedBitSize = 0; + int offset = HEADER_SIZE; + for (int i = 0; i < blockSize; i++) { + outDecompSlots[i] = readBits(inCompBlock, offset, bits); + offset += bits; + } + compressedBitSize = bits * blockSize; - // compress exceptions - if (expNum > 0) { - int compressedBitSize = compressBlockByS16(tmpCompressedBlock, outputOffset, expAux, expNum * 2); - outputOffset += compressedBitSize; + return compressedBitSize; } - // discard the redundant parts in the tmpCompressedBlock - int compressedSizeInInts = (outputOffset + 31) >>> 5; - int[] compBlock; - compBlock = new int[compressedSizeInInts]; - System.arraycopy(tmpCompressedBlock, 0, compBlock, 0, compressedSizeInInts); - - return compBlock; - } - - /** - * Decompress b-bit slots - * - * @param outDecompSlots decompressed block which is the output - * @param inCompBlock the compressed block which is the input - * @param blockSize the block size - * @param bits the value of the parameter b - * @return the compressed size in bits of the data that has been decompressed - */ - public static int decompressBBitSlots(int[] outDecompSlots, int[] inCompBlock, int blockSize, int bits) { - int compressedBitSize = 0; - int offset = HEADER_SIZE; - for (int i = 0; i < blockSize; i++) { - outDecompSlots[i] = readBits(inCompBlock, offset, bits); - offset += bits; + /** + * Compress a block of blockSize integers using Simple16 algorithm + * + * @param outCompBlock + * the compressed block which is the output + * @param outStartOffsetInBits + * the start offset in bits of the compressed block + * @param inBlock + * the block to be compressed + * @param blockSize + * the block size + * @return the compressed size in bits + */ + private static int compressBlockByS16(int[] outCompBlock, + int outStartOffsetInBits, int[] inBlock, int blockSize) { + int outOffset = (outStartOffsetInBits + 31) >>> 5; + int num, inOffset = 0, numLeft; + for (numLeft = blockSize; numLeft > 0; numLeft -= num) { + num = Simple16.s16Compress(outCompBlock, outOffset, + inBlock, inOffset, numLeft, blockSize); + outOffset++; + inOffset += num; + } + int compressedBitSize = (outOffset << 5) - outStartOffsetInBits; + return compressedBitSize; } - compressedBitSize = bits * blockSize; - - return compressedBitSize; - } - - - /** - * Compress a block of blockSize integers using Simple16 algorithm - * - * @param outCompBlock the compressed block which is the output - * @param outStartOffsetInBits the start offset in bits of the compressed block - * @param inBlock the block to be compressed - * @param blockSize the block size - * @return the compressed size in bits - */ - private static int compressBlockByS16(int[] outCompBlock, int outStartOffsetInBits, int[] inBlock, int blockSize) { - int outOffset = (outStartOffsetInBits + 31) >>> 5; - int num, inOffset = 0, numLeft; - for (numLeft = blockSize; numLeft > 0; numLeft -= num) { - num = Simple16.s16Compress(outCompBlock, outOffset, inBlock, inOffset, numLeft, blockSize); - outOffset++; - inOffset += num; + + /** + * Decompress a block of blockSize integers using Simple16 algorithm + * + * @param outDecompBlock + * the decompressed block which is the output + * @param inCompBlock + * the compressed block which is the input + * @param blockSize + * the block size + * @param inStartOffsetInBits + * the start offset in bits of the compressed block + * @return the compressed size in bits of the data that has been + * decompressed + */ + public static int decompressBlockByS16(int[] outDecompBlock, + int[] inCompBlock, int inStartOffsetInBits, int blockSize) { + int inOffset = (inStartOffsetInBits + 31) >>> 5; + int num, outOffset = 0, numLeft; + for (numLeft = blockSize; numLeft > 0; numLeft -= num) { + num = Simple16.s16Decompress(outDecompBlock, outOffset, + inCompBlock, inOffset, numLeft); + outOffset += num; + inOffset++; + } + int compressedBitSize = (inOffset << 5) - inStartOffsetInBits; + return compressedBitSize; } - int compressedBitSize = (outOffset << 5) - outStartOffsetInBits; - return compressedBitSize; - } - - /** - * Decompress a block of blockSize integers using Simple16 algorithm - * - * @param outDecompBlock the decompressed block which is the output - * @param inCompBlock the compressed block which is the input - * @param blockSize the block size - * @param inStartOffsetInBits the start offset in bits of the compressed block - * @return the compressed size in bits of the data that has been decompressed - */ - public static int decompressBlockByS16(int[] outDecompBlock, int[] inCompBlock, int inStartOffsetInBits, int blockSize) { - int inOffset = (inStartOffsetInBits + 31) >>> 5; - int num, outOffset = 0, numLeft; - for (numLeft = blockSize; numLeft > 0; numLeft -= num) { - num = Simple16.s16Decompress(outDecompBlock, outOffset, inCompBlock, inOffset, numLeft); - outOffset += num; - inOffset++; + + /** + * Write a certain number of bits of an integer into an integer array + * starting from the given start offset + * + * @param out + * the output array + * @param val + * the integer to be written + * @param outOffset + * the start offset in bits in the output array + * @param bits + * the number of bits to be written (bits greater or equal to 0) + */ + public static final void writeBits(int[] out, int val, int outOffset, + int bits) { + if (bits == 0) + return; + final int index = outOffset >>> 5; + final int skip = outOffset & 0x1f; + val &= (0xffffffff >>> (32 - bits)); + out[index] |= (val << skip); + if (32 - skip < bits) { + out[index + 1] |= (val >>> (32 - skip)); + } } - int compressedBitSize = (inOffset << 5) - inStartOffsetInBits; - return compressedBitSize; - } - - - /** - * Write a certain number of bits of an integer into an integer array starting from the given start offset - * - * @param out the output array - * @param val the integer to be written - * @param outOffset the start offset in bits in the output array - * @param bits the number of bits to be written (bits>=0) - */ - public static final void writeBits(int[] out, int val, int outOffset, int bits) { - if (bits == 0) - return; - final int index = outOffset >>> 5; - final int skip = outOffset & 0x1f; - val &= (0xffffffff >>> (32 - bits)); - out[index] |= (val << skip); - if (32 - skip < bits) { - out[index + 1] |= (val >>> (32 - skip)); + + /** + * Decompress the b-bit slots using hardcoded unpack methods + * + * @param decompressedSlots + * the decompressed output + * @param compBlock + * the compressed input block + * @param blockSize + * the block size which is 256 by default + * @param bits + * the value of b + * @return the processed data size (the number of bits in the compressed + * form) + */ + static int decompressBBitSlotsWithHardCodes(int[] decompressedSlots, + int[] compBlock, int blockSize, int bits) { + int compressedBitSize = 0; + PForDeltaUnpack128.unpack(decompressedSlots, compBlock, bits); + compressedBitSize = bits * blockSize; + + return compressedBitSize; } - } - - /** - * Decompress the b-bit slots using hardcoded unpack methods - * - * @param decompressedSlots the decompressed output - * @param compBlock the compressed input block - * @param blockSize the block size which is 256 by default - * @param bits the value of b - * @return the processed data size (the number of bits in the compressed form) - */ - static int decompressBBitSlotsWithHardCodes(int[] decompressedSlots, int[] compBlock, int blockSize, int bits) { - int compressedBitSize = 0; - PForDeltaUnpack128.unpack(decompressedSlots, compBlock, bits); - compressedBitSize = bits * blockSize; - - return compressedBitSize; - } - - /** - * Read a certain number of bits of an integer into an integer array starting from the given start offset - * - * @param in the input array - * @param inOffset the start offset in bits in the input array - * @param bits the number of bits to be read, unlike writeBits(), readBits() does not deal with bits==0 and thus bits must > 0. When bits ==0, the calling functions will just skip the entire bits-bit slots without decoding them - * @return the bits bits of the input - */ - public static final int readBits(int[] in, final int inOffset, final int bits) { - final int index = inOffset >>> 5; - final int skip = inOffset & 0x1f; - int val = in[index] >>> skip; - if (32 - skip < bits) { - val |= (in[index + 1] << (32 - skip)); + + /** + * Read a certain number of bits of an integer into an integer array + * starting from the given start offset + * + * @param in + * the input array + * @param inOffset + * the start offset in bits in the input array + * @param bits + * the number of bits to be read, unlike writeBits(), + * readBits() does not deal with bits==0 and thus bits + * must be greater than 0. When bits ==0, the calling functions will + * just skip the entire bits-bit slots without decoding + * them + * @return the bits bits of the input + */ + public static final int readBits(int[] in, final int inOffset, + final int bits) { + final int index = inOffset >>> 5; + final int skip = inOffset & 0x1f; + int val = in[index] >>> skip; + if (32 - skip < bits) { + val |= (in[index + 1] << (32 - skip)); + } + return val & (0xffffffff >>> (32 - bits)); } - return val & (0xffffffff >>> (32 - bits)); - } } - diff --git a/src/main/java/com/kamikaze/pfordelta/PForDeltaUnpack128.java b/src/main/java/com/kamikaze/pfordelta/PForDeltaUnpack128.java index 82d9f30..fe5647c 100644 --- a/src/main/java/com/kamikaze/pfordelta/PForDeltaUnpack128.java +++ b/src/main/java/com/kamikaze/pfordelta/PForDeltaUnpack128.java @@ -1,882 +1,983 @@ package com.kamikaze.pfordelta; /** - * This is a version of the kamikaze PForDelta library that - * was slightly cleaned up by D. Lemire. It is included in the - * JavaFastPFOR library for comparison purposes. As the original + * This is a version of the kamikaze PForDelta library that was slightly cleaned + * up by D. Lemire. It is included in the JavaFastPFOR library for comparison + * purposes. As the original */ -@SuppressWarnings("javadoc") public class PForDeltaUnpack128 { - static public void unpack(int[] out, int[] in, int bits) { - switch (bits) { - case 0: - unpack0(out, in); - break; - case 1: - unpack1(out, in); - break; - case 2: - unpack2(out, in); - break; - case 3: - unpack3(out, in); - break; - case 4: - unpack4(out, in); - break; - case 5: - unpack5(out, in); - break; - case 6: - unpack6(out, in); - break; - case 7: - unpack7(out, in); - break; - case 8: - unpack8(out, in); - break; - case 9: - unpack9(out, in); - break; - case 10: - unpack10(out, in); - break; - case 11: - unpack11(out, in); - break; - case 12: - unpack12(out, in); - break; - case 13: - unpack13(out, in); - break; - case 16: - unpack16(out, in); - break; - case 20: - unpack20(out, in); - break; - case 28: - unpack28(out, in); - break; - default: - break; + static protected void unpack(int[] out, int[] in, int bits) { + switch (bits) { + case 0: + unpack0(out, in); + break; + case 1: + unpack1(out, in); + break; + case 2: + unpack2(out, in); + break; + case 3: + unpack3(out, in); + break; + case 4: + unpack4(out, in); + break; + case 5: + unpack5(out, in); + break; + case 6: + unpack6(out, in); + break; + case 7: + unpack7(out, in); + break; + case 8: + unpack8(out, in); + break; + case 9: + unpack9(out, in); + break; + case 10: + unpack10(out, in); + break; + case 11: + unpack11(out, in); + break; + case 12: + unpack12(out, in); + break; + case 13: + unpack13(out, in); + break; + case 16: + unpack16(out, in); + break; + case 20: + unpack20(out, in); + break; + case 28: + unpack28(out, in); + break; + default: + break; + } } - } - static private void unpack0(int[] out, int[] in) { - } + static private void unpack0(int[] out, int[] in) { + } - static private void unpack1(int[] out, int[] in) { - int i, w; - int outOffset = 0; - final int mask = 1; - for (i = 0, w = 1; i < 4; ++i, w += 1) { - int curInputValue0 = in[w]; - out[0 + outOffset] = curInputValue0 & mask; - out[1 + outOffset] = (curInputValue0 >>> 1) & mask; - out[2 + outOffset] = (curInputValue0 >>> 2) & mask; - out[3 + outOffset] = (curInputValue0 >>> 3) & mask; - out[4 + outOffset] = (curInputValue0 >>> 4) & mask; - out[5 + outOffset] = (curInputValue0 >>> 5) & mask; - out[6 + outOffset] = (curInputValue0 >>> 6) & mask; - out[7 + outOffset] = (curInputValue0 >>> 7) & mask; - out[8 + outOffset] = (curInputValue0 >>> 8) & mask; - out[9 + outOffset] = (curInputValue0 >>> 9) & mask; - out[10 + outOffset] = (curInputValue0 >>> 10) & mask; - out[11 + outOffset] = (curInputValue0 >>> 11) & mask; - out[12 + outOffset] = (curInputValue0 >>> 12) & mask; - out[13 + outOffset] = (curInputValue0 >>> 13) & mask; - out[14 + outOffset] = (curInputValue0 >>> 14) & mask; - out[15 + outOffset] = (curInputValue0 >>> 15) & mask; - out[16 + outOffset] = (curInputValue0 >>> 16) & mask; - out[17 + outOffset] = (curInputValue0 >>> 17) & mask; - out[18 + outOffset] = (curInputValue0 >>> 18) & mask; - out[19 + outOffset] = (curInputValue0 >>> 19) & mask; - out[20 + outOffset] = (curInputValue0 >>> 20) & mask; - out[21 + outOffset] = (curInputValue0 >>> 21) & mask; - out[22 + outOffset] = (curInputValue0 >>> 22) & mask; - out[23 + outOffset] = (curInputValue0 >>> 23) & mask; - out[24 + outOffset] = (curInputValue0 >>> 24) & mask; - out[25 + outOffset] = (curInputValue0 >>> 25) & mask; - out[26 + outOffset] = (curInputValue0 >>> 26) & mask; - out[27 + outOffset] = (curInputValue0 >>> 27) & mask; - out[28 + outOffset] = (curInputValue0 >>> 28) & mask; - out[29 + outOffset] = (curInputValue0 >>> 29) & mask; - out[30 + outOffset] = (curInputValue0 >>> 30) & mask; - out[31 + outOffset] = curInputValue0 >>> 31; - outOffset += 32; + static private void unpack1(int[] out, int[] in) { + int i, w; + int outOffset = 0; + final int mask = 1; + for (i = 0, w = 1; i < 4; ++i, w += 1) { + int curInputValue0 = in[w]; + out[0 + outOffset] = curInputValue0 & mask; + out[1 + outOffset] = (curInputValue0 >>> 1) & mask; + out[2 + outOffset] = (curInputValue0 >>> 2) & mask; + out[3 + outOffset] = (curInputValue0 >>> 3) & mask; + out[4 + outOffset] = (curInputValue0 >>> 4) & mask; + out[5 + outOffset] = (curInputValue0 >>> 5) & mask; + out[6 + outOffset] = (curInputValue0 >>> 6) & mask; + out[7 + outOffset] = (curInputValue0 >>> 7) & mask; + out[8 + outOffset] = (curInputValue0 >>> 8) & mask; + out[9 + outOffset] = (curInputValue0 >>> 9) & mask; + out[10 + outOffset] = (curInputValue0 >>> 10) & mask; + out[11 + outOffset] = (curInputValue0 >>> 11) & mask; + out[12 + outOffset] = (curInputValue0 >>> 12) & mask; + out[13 + outOffset] = (curInputValue0 >>> 13) & mask; + out[14 + outOffset] = (curInputValue0 >>> 14) & mask; + out[15 + outOffset] = (curInputValue0 >>> 15) & mask; + out[16 + outOffset] = (curInputValue0 >>> 16) & mask; + out[17 + outOffset] = (curInputValue0 >>> 17) & mask; + out[18 + outOffset] = (curInputValue0 >>> 18) & mask; + out[19 + outOffset] = (curInputValue0 >>> 19) & mask; + out[20 + outOffset] = (curInputValue0 >>> 20) & mask; + out[21 + outOffset] = (curInputValue0 >>> 21) & mask; + out[22 + outOffset] = (curInputValue0 >>> 22) & mask; + out[23 + outOffset] = (curInputValue0 >>> 23) & mask; + out[24 + outOffset] = (curInputValue0 >>> 24) & mask; + out[25 + outOffset] = (curInputValue0 >>> 25) & mask; + out[26 + outOffset] = (curInputValue0 >>> 26) & mask; + out[27 + outOffset] = (curInputValue0 >>> 27) & mask; + out[28 + outOffset] = (curInputValue0 >>> 28) & mask; + out[29 + outOffset] = (curInputValue0 >>> 29) & mask; + out[30 + outOffset] = (curInputValue0 >>> 30) & mask; + out[31 + outOffset] = curInputValue0 >>> 31; + outOffset += 32; + } } - } - static private void unpack2(int[] out, int[] in) { - int i, w; - int outOffset = 0; - final int mask = 3; - for (i = 0, w = 1; i < 4; ++i, w += 2) { - int curInputValue0 = in[w]; - int curInputValue1 = in[w + 1]; - out[0 + outOffset] = curInputValue0 & mask; - out[1 + outOffset] = (curInputValue0 >>> 2) & mask; - out[2 + outOffset] = (curInputValue0 >>> 4) & mask; - out[3 + outOffset] = (curInputValue0 >>> 6) & mask; - out[4 + outOffset] = (curInputValue0 >>> 8) & mask; - out[5 + outOffset] = (curInputValue0 >>> 10) & mask; - out[6 + outOffset] = (curInputValue0 >>> 12) & mask; - out[7 + outOffset] = (curInputValue0 >>> 14) & mask; - out[8 + outOffset] = (curInputValue0 >>> 16) & mask; - out[9 + outOffset] = (curInputValue0 >>> 18) & mask; - out[10 + outOffset] = (curInputValue0 >>> 20) & mask; - out[11 + outOffset] = (curInputValue0 >>> 22) & mask; - out[12 + outOffset] = (curInputValue0 >>> 24) & mask; - out[13 + outOffset] = (curInputValue0 >>> 26) & mask; - out[14 + outOffset] = (curInputValue0 >>> 28) & mask; - out[15 + outOffset] = curInputValue0 >>> 30; - out[16 + outOffset] = curInputValue1 & mask; - out[17 + outOffset] = (curInputValue1 >>> 2) & mask; - out[18 + outOffset] = (curInputValue1 >>> 4) & mask; - out[19 + outOffset] = (curInputValue1 >>> 6) & mask; - out[20 + outOffset] = (curInputValue1 >>> 8) & mask; - out[21 + outOffset] = (curInputValue1 >>> 10) & mask; - out[22 + outOffset] = (curInputValue1 >>> 12) & mask; - out[23 + outOffset] = (curInputValue1 >>> 14) & mask; - out[24 + outOffset] = (curInputValue1 >>> 16) & mask; - out[25 + outOffset] = (curInputValue1 >>> 18) & mask; - out[26 + outOffset] = (curInputValue1 >>> 20) & mask; - out[27 + outOffset] = (curInputValue1 >>> 22) & mask; - out[28 + outOffset] = (curInputValue1 >>> 24) & mask; - out[29 + outOffset] = (curInputValue1 >>> 26) & mask; - out[30 + outOffset] = (curInputValue1 >>> 28) & mask; - out[31 + outOffset] = curInputValue1 >>> 30; - outOffset += 32; + static private void unpack2(int[] out, int[] in) { + int i, w; + int outOffset = 0; + final int mask = 3; + for (i = 0, w = 1; i < 4; ++i, w += 2) { + int curInputValue0 = in[w]; + int curInputValue1 = in[w + 1]; + out[0 + outOffset] = curInputValue0 & mask; + out[1 + outOffset] = (curInputValue0 >>> 2) & mask; + out[2 + outOffset] = (curInputValue0 >>> 4) & mask; + out[3 + outOffset] = (curInputValue0 >>> 6) & mask; + out[4 + outOffset] = (curInputValue0 >>> 8) & mask; + out[5 + outOffset] = (curInputValue0 >>> 10) & mask; + out[6 + outOffset] = (curInputValue0 >>> 12) & mask; + out[7 + outOffset] = (curInputValue0 >>> 14) & mask; + out[8 + outOffset] = (curInputValue0 >>> 16) & mask; + out[9 + outOffset] = (curInputValue0 >>> 18) & mask; + out[10 + outOffset] = (curInputValue0 >>> 20) & mask; + out[11 + outOffset] = (curInputValue0 >>> 22) & mask; + out[12 + outOffset] = (curInputValue0 >>> 24) & mask; + out[13 + outOffset] = (curInputValue0 >>> 26) & mask; + out[14 + outOffset] = (curInputValue0 >>> 28) & mask; + out[15 + outOffset] = curInputValue0 >>> 30; + out[16 + outOffset] = curInputValue1 & mask; + out[17 + outOffset] = (curInputValue1 >>> 2) & mask; + out[18 + outOffset] = (curInputValue1 >>> 4) & mask; + out[19 + outOffset] = (curInputValue1 >>> 6) & mask; + out[20 + outOffset] = (curInputValue1 >>> 8) & mask; + out[21 + outOffset] = (curInputValue1 >>> 10) & mask; + out[22 + outOffset] = (curInputValue1 >>> 12) & mask; + out[23 + outOffset] = (curInputValue1 >>> 14) & mask; + out[24 + outOffset] = (curInputValue1 >>> 16) & mask; + out[25 + outOffset] = (curInputValue1 >>> 18) & mask; + out[26 + outOffset] = (curInputValue1 >>> 20) & mask; + out[27 + outOffset] = (curInputValue1 >>> 22) & mask; + out[28 + outOffset] = (curInputValue1 >>> 24) & mask; + out[29 + outOffset] = (curInputValue1 >>> 26) & mask; + out[30 + outOffset] = (curInputValue1 >>> 28) & mask; + out[31 + outOffset] = curInputValue1 >>> 30; + outOffset += 32; + } } - } - static private void unpack3(int[] out, int[] in) { - int i, w; - int outOffset = 0; - final int mask = 7; - for (i = 0, w = 1; i < 4; ++i, w += 3) { - int curInputValue0 = in[w]; - int curInputValue1 = in[w + 1]; - int curInputValue2 = in[w + 2]; - out[0 + outOffset] = curInputValue0 & mask; - out[1 + outOffset] = (curInputValue0 >>> 3) & mask; - out[2 + outOffset] = (curInputValue0 >>> 6) & mask; - out[3 + outOffset] = (curInputValue0 >>> 9) & mask; - out[4 + outOffset] = (curInputValue0 >>> 12) & mask; - out[5 + outOffset] = (curInputValue0 >>> 15) & mask; - out[6 + outOffset] = (curInputValue0 >>> 18) & mask; - out[7 + outOffset] = (curInputValue0 >>> 21) & mask; - out[8 + outOffset] = (curInputValue0 >>> 24) & mask; - out[9 + outOffset] = (curInputValue0 >>> 27) & mask; - out[10 + outOffset] = ((curInputValue0 >>> 30) | (curInputValue1 << 2)) & mask; - out[11 + outOffset] = (curInputValue1 >>> 1) & mask; - out[12 + outOffset] = (curInputValue1 >>> 4) & mask; - out[13 + outOffset] = (curInputValue1 >>> 7) & mask; - out[14 + outOffset] = (curInputValue1 >>> 10) & mask; - out[15 + outOffset] = (curInputValue1 >>> 13) & mask; - out[16 + outOffset] = (curInputValue1 >>> 16) & mask; - out[17 + outOffset] = (curInputValue1 >>> 19) & mask; - out[18 + outOffset] = (curInputValue1 >>> 22) & mask; - out[19 + outOffset] = (curInputValue1 >>> 25) & mask; - out[20 + outOffset] = (curInputValue1 >>> 28) & mask; - out[21 + outOffset] = ((curInputValue1 >>> 31) | (curInputValue2 << 1)) & mask; - out[22 + outOffset] = (curInputValue2 >>> 2) & mask; - out[23 + outOffset] = (curInputValue2 >>> 5) & mask; - out[24 + outOffset] = (curInputValue2 >>> 8) & mask; - out[25 + outOffset] = (curInputValue2 >>> 11) & mask; - out[26 + outOffset] = (curInputValue2 >>> 14) & mask; - out[27 + outOffset] = (curInputValue2 >>> 17) & mask; - out[28 + outOffset] = (curInputValue2 >>> 20) & mask; - out[29 + outOffset] = (curInputValue2 >>> 23) & mask; - out[30 + outOffset] = (curInputValue2 >>> 26) & mask; - out[31 + outOffset] = curInputValue2 >>> 29; - outOffset += 32; + static private void unpack3(int[] out, int[] in) { + int i, w; + int outOffset = 0; + final int mask = 7; + for (i = 0, w = 1; i < 4; ++i, w += 3) { + int curInputValue0 = in[w]; + int curInputValue1 = in[w + 1]; + int curInputValue2 = in[w + 2]; + out[0 + outOffset] = curInputValue0 & mask; + out[1 + outOffset] = (curInputValue0 >>> 3) & mask; + out[2 + outOffset] = (curInputValue0 >>> 6) & mask; + out[3 + outOffset] = (curInputValue0 >>> 9) & mask; + out[4 + outOffset] = (curInputValue0 >>> 12) & mask; + out[5 + outOffset] = (curInputValue0 >>> 15) & mask; + out[6 + outOffset] = (curInputValue0 >>> 18) & mask; + out[7 + outOffset] = (curInputValue0 >>> 21) & mask; + out[8 + outOffset] = (curInputValue0 >>> 24) & mask; + out[9 + outOffset] = (curInputValue0 >>> 27) & mask; + out[10 + outOffset] = ((curInputValue0 >>> 30) | (curInputValue1 << 2)) + & mask; + out[11 + outOffset] = (curInputValue1 >>> 1) & mask; + out[12 + outOffset] = (curInputValue1 >>> 4) & mask; + out[13 + outOffset] = (curInputValue1 >>> 7) & mask; + out[14 + outOffset] = (curInputValue1 >>> 10) & mask; + out[15 + outOffset] = (curInputValue1 >>> 13) & mask; + out[16 + outOffset] = (curInputValue1 >>> 16) & mask; + out[17 + outOffset] = (curInputValue1 >>> 19) & mask; + out[18 + outOffset] = (curInputValue1 >>> 22) & mask; + out[19 + outOffset] = (curInputValue1 >>> 25) & mask; + out[20 + outOffset] = (curInputValue1 >>> 28) & mask; + out[21 + outOffset] = ((curInputValue1 >>> 31) | (curInputValue2 << 1)) + & mask; + out[22 + outOffset] = (curInputValue2 >>> 2) & mask; + out[23 + outOffset] = (curInputValue2 >>> 5) & mask; + out[24 + outOffset] = (curInputValue2 >>> 8) & mask; + out[25 + outOffset] = (curInputValue2 >>> 11) & mask; + out[26 + outOffset] = (curInputValue2 >>> 14) & mask; + out[27 + outOffset] = (curInputValue2 >>> 17) & mask; + out[28 + outOffset] = (curInputValue2 >>> 20) & mask; + out[29 + outOffset] = (curInputValue2 >>> 23) & mask; + out[30 + outOffset] = (curInputValue2 >>> 26) & mask; + out[31 + outOffset] = curInputValue2 >>> 29; + outOffset += 32; + } } - } - static private void unpack4(int[] out, int[] in) { - int i, w; - int outOffset = 0; - final int mask = 15; - for (i = 0, w = 1; i < 4; ++i, w += 4) { - int curInputValue0 = in[w]; - int curInputValue1 = in[w + 1]; - int curInputValue2 = in[w + 2]; - int curInputValue3 = in[w + 3]; - out[0 + outOffset] = curInputValue0 & mask; - out[1 + outOffset] = (curInputValue0 >>> 4) & mask; - out[2 + outOffset] = (curInputValue0 >>> 8) & mask; - out[3 + outOffset] = (curInputValue0 >>> 12) & mask; - out[4 + outOffset] = (curInputValue0 >>> 16) & mask; - out[5 + outOffset] = (curInputValue0 >>> 20) & mask; - out[6 + outOffset] = (curInputValue0 >>> 24) & mask; - out[7 + outOffset] = curInputValue0 >>> 28; - out[8 + outOffset] = curInputValue1 & mask; - out[9 + outOffset] = (curInputValue1 >>> 4) & mask; - out[10 + outOffset] = (curInputValue1 >>> 8) & mask; - out[11 + outOffset] = (curInputValue1 >>> 12) & mask; - out[12 + outOffset] = (curInputValue1 >>> 16) & mask; - out[13 + outOffset] = (curInputValue1 >>> 20) & mask; - out[14 + outOffset] = (curInputValue1 >>> 24) & mask; - out[15 + outOffset] = curInputValue1 >>> 28; - out[16 + outOffset] = curInputValue2 & mask; - out[17 + outOffset] = (curInputValue2 >>> 4) & mask; - out[18 + outOffset] = (curInputValue2 >>> 8) & mask; - out[19 + outOffset] = (curInputValue2 >>> 12) & mask; - out[20 + outOffset] = (curInputValue2 >>> 16) & mask; - out[21 + outOffset] = (curInputValue2 >>> 20) & mask; - out[22 + outOffset] = (curInputValue2 >>> 24) & mask; - out[23 + outOffset] = curInputValue2 >>> 28; - out[24 + outOffset] = curInputValue3 & mask; - out[25 + outOffset] = (curInputValue3 >>> 4) & mask; - out[26 + outOffset] = (curInputValue3 >>> 8) & mask; - out[27 + outOffset] = (curInputValue3 >>> 12) & mask; - out[28 + outOffset] = (curInputValue3 >>> 16) & mask; - out[29 + outOffset] = (curInputValue3 >>> 20) & mask; - out[30 + outOffset] = (curInputValue3 >>> 24) & mask; - out[31 + outOffset] = curInputValue3 >>> 28; - outOffset += 32; + static private void unpack4(int[] out, int[] in) { + int i, w; + int outOffset = 0; + final int mask = 15; + for (i = 0, w = 1; i < 4; ++i, w += 4) { + int curInputValue0 = in[w]; + int curInputValue1 = in[w + 1]; + int curInputValue2 = in[w + 2]; + int curInputValue3 = in[w + 3]; + out[0 + outOffset] = curInputValue0 & mask; + out[1 + outOffset] = (curInputValue0 >>> 4) & mask; + out[2 + outOffset] = (curInputValue0 >>> 8) & mask; + out[3 + outOffset] = (curInputValue0 >>> 12) & mask; + out[4 + outOffset] = (curInputValue0 >>> 16) & mask; + out[5 + outOffset] = (curInputValue0 >>> 20) & mask; + out[6 + outOffset] = (curInputValue0 >>> 24) & mask; + out[7 + outOffset] = curInputValue0 >>> 28; + out[8 + outOffset] = curInputValue1 & mask; + out[9 + outOffset] = (curInputValue1 >>> 4) & mask; + out[10 + outOffset] = (curInputValue1 >>> 8) & mask; + out[11 + outOffset] = (curInputValue1 >>> 12) & mask; + out[12 + outOffset] = (curInputValue1 >>> 16) & mask; + out[13 + outOffset] = (curInputValue1 >>> 20) & mask; + out[14 + outOffset] = (curInputValue1 >>> 24) & mask; + out[15 + outOffset] = curInputValue1 >>> 28; + out[16 + outOffset] = curInputValue2 & mask; + out[17 + outOffset] = (curInputValue2 >>> 4) & mask; + out[18 + outOffset] = (curInputValue2 >>> 8) & mask; + out[19 + outOffset] = (curInputValue2 >>> 12) & mask; + out[20 + outOffset] = (curInputValue2 >>> 16) & mask; + out[21 + outOffset] = (curInputValue2 >>> 20) & mask; + out[22 + outOffset] = (curInputValue2 >>> 24) & mask; + out[23 + outOffset] = curInputValue2 >>> 28; + out[24 + outOffset] = curInputValue3 & mask; + out[25 + outOffset] = (curInputValue3 >>> 4) & mask; + out[26 + outOffset] = (curInputValue3 >>> 8) & mask; + out[27 + outOffset] = (curInputValue3 >>> 12) & mask; + out[28 + outOffset] = (curInputValue3 >>> 16) & mask; + out[29 + outOffset] = (curInputValue3 >>> 20) & mask; + out[30 + outOffset] = (curInputValue3 >>> 24) & mask; + out[31 + outOffset] = curInputValue3 >>> 28; + outOffset += 32; + } } - } - static private void unpack5(int[] out, int[] in) { - int i, w; - int outOffset = 0; - final int mask = 31; - for (i = 0, w = 1; i < 4; ++i, w += 5) { - int curInputValue0 = in[w]; - int curInputValue1 = in[w + 1]; - int curInputValue2 = in[w + 2]; - int curInputValue3 = in[w + 3]; - int curInputValue4 = in[w + 4]; - out[0 + outOffset] = curInputValue0 & mask; - out[1 + outOffset] = (curInputValue0 >>> 5) & mask; - out[2 + outOffset] = (curInputValue0 >>> 10) & mask; - out[3 + outOffset] = (curInputValue0 >>> 15) & mask; - out[4 + outOffset] = (curInputValue0 >>> 20) & mask; - out[5 + outOffset] = (curInputValue0 >>> 25) & mask; - out[6 + outOffset] = ((curInputValue0 >>> 30) | (curInputValue1 << 2)) & mask; - out[7 + outOffset] = (curInputValue1 >>> 3) & mask; - out[8 + outOffset] = (curInputValue1 >>> 8) & mask; - out[9 + outOffset] = (curInputValue1 >>> 13) & mask; - out[10 + outOffset] = (curInputValue1 >>> 18) & mask; - out[11 + outOffset] = (curInputValue1 >>> 23) & mask; - out[12 + outOffset] = ((curInputValue1 >>> 28) | (curInputValue2 << 4)) & mask; - out[13 + outOffset] = (curInputValue2 >>> 1) & mask; - out[14 + outOffset] = (curInputValue2 >>> 6) & mask; - out[15 + outOffset] = (curInputValue2 >>> 11) & mask; - out[16 + outOffset] = (curInputValue2 >>> 16) & mask; - out[17 + outOffset] = (curInputValue2 >>> 21) & mask; - out[18 + outOffset] = (curInputValue2 >>> 26) & mask; - out[19 + outOffset] = ((curInputValue2 >>> 31) | (curInputValue3 << 1)) & mask; - out[20 + outOffset] = (curInputValue3 >>> 4) & mask; - out[21 + outOffset] = (curInputValue3 >>> 9) & mask; - out[22 + outOffset] = (curInputValue3 >>> 14) & mask; - out[23 + outOffset] = (curInputValue3 >>> 19) & mask; - out[24 + outOffset] = (curInputValue3 >>> 24) & mask; - out[25 + outOffset] = ((curInputValue3 >>> 29) | (curInputValue4 << 3)) & mask; - out[26 + outOffset] = (curInputValue4 >>> 2) & mask; - out[27 + outOffset] = (curInputValue4 >>> 7) & mask; - out[28 + outOffset] = (curInputValue4 >>> 12) & mask; - out[29 + outOffset] = (curInputValue4 >>> 17) & mask; - out[30 + outOffset] = (curInputValue4 >>> 22) & mask; - out[31 + outOffset] = curInputValue4 >>> 27; - outOffset += 32; + static private void unpack5(int[] out, int[] in) { + int i, w; + int outOffset = 0; + final int mask = 31; + for (i = 0, w = 1; i < 4; ++i, w += 5) { + int curInputValue0 = in[w]; + int curInputValue1 = in[w + 1]; + int curInputValue2 = in[w + 2]; + int curInputValue3 = in[w + 3]; + int curInputValue4 = in[w + 4]; + out[0 + outOffset] = curInputValue0 & mask; + out[1 + outOffset] = (curInputValue0 >>> 5) & mask; + out[2 + outOffset] = (curInputValue0 >>> 10) & mask; + out[3 + outOffset] = (curInputValue0 >>> 15) & mask; + out[4 + outOffset] = (curInputValue0 >>> 20) & mask; + out[5 + outOffset] = (curInputValue0 >>> 25) & mask; + out[6 + outOffset] = ((curInputValue0 >>> 30) | (curInputValue1 << 2)) + & mask; + out[7 + outOffset] = (curInputValue1 >>> 3) & mask; + out[8 + outOffset] = (curInputValue1 >>> 8) & mask; + out[9 + outOffset] = (curInputValue1 >>> 13) & mask; + out[10 + outOffset] = (curInputValue1 >>> 18) & mask; + out[11 + outOffset] = (curInputValue1 >>> 23) & mask; + out[12 + outOffset] = ((curInputValue1 >>> 28) | (curInputValue2 << 4)) + & mask; + out[13 + outOffset] = (curInputValue2 >>> 1) & mask; + out[14 + outOffset] = (curInputValue2 >>> 6) & mask; + out[15 + outOffset] = (curInputValue2 >>> 11) & mask; + out[16 + outOffset] = (curInputValue2 >>> 16) & mask; + out[17 + outOffset] = (curInputValue2 >>> 21) & mask; + out[18 + outOffset] = (curInputValue2 >>> 26) & mask; + out[19 + outOffset] = ((curInputValue2 >>> 31) | (curInputValue3 << 1)) + & mask; + out[20 + outOffset] = (curInputValue3 >>> 4) & mask; + out[21 + outOffset] = (curInputValue3 >>> 9) & mask; + out[22 + outOffset] = (curInputValue3 >>> 14) & mask; + out[23 + outOffset] = (curInputValue3 >>> 19) & mask; + out[24 + outOffset] = (curInputValue3 >>> 24) & mask; + out[25 + outOffset] = ((curInputValue3 >>> 29) | (curInputValue4 << 3)) + & mask; + out[26 + outOffset] = (curInputValue4 >>> 2) & mask; + out[27 + outOffset] = (curInputValue4 >>> 7) & mask; + out[28 + outOffset] = (curInputValue4 >>> 12) & mask; + out[29 + outOffset] = (curInputValue4 >>> 17) & mask; + out[30 + outOffset] = (curInputValue4 >>> 22) & mask; + out[31 + outOffset] = curInputValue4 >>> 27; + outOffset += 32; + } } - } - static private void unpack6(int[] out, int[] in) { - int i, w; - int outOffset = 0; - final int mask = 63; - for (i = 0, w = 1; i < 4; ++i, w += 6) { - int curInputValue0 = in[w]; - int curInputValue1 = in[w + 1]; - int curInputValue2 = in[w + 2]; - int curInputValue3 = in[w + 3]; - int curInputValue4 = in[w + 4]; - int curInputValue5 = in[w + 5]; - out[0 + outOffset] = curInputValue0 & mask; - out[1 + outOffset] = (curInputValue0 >>> 6) & mask; - out[2 + outOffset] = (curInputValue0 >>> 12) & mask; - out[3 + outOffset] = (curInputValue0 >>> 18) & mask; - out[4 + outOffset] = (curInputValue0 >>> 24) & mask; - out[5 + outOffset] = ((curInputValue0 >>> 30) | (curInputValue1 << 2)) & mask; - out[6 + outOffset] = (curInputValue1 >>> 4) & mask; - out[7 + outOffset] = (curInputValue1 >>> 10) & mask; - out[8 + outOffset] = (curInputValue1 >>> 16) & mask; - out[9 + outOffset] = (curInputValue1 >>> 22) & mask; - out[10 + outOffset] = ((curInputValue1 >>> 28) | (curInputValue2 << 4)) & mask; - out[11 + outOffset] = (curInputValue2 >>> 2) & mask; - out[12 + outOffset] = (curInputValue2 >>> 8) & mask; - out[13 + outOffset] = (curInputValue2 >>> 14) & mask; - out[14 + outOffset] = (curInputValue2 >>> 20) & mask; - out[15 + outOffset] = curInputValue2 >>> 26; - out[16 + outOffset] = curInputValue3 & mask; - out[17 + outOffset] = (curInputValue3 >>> 6) & mask; - out[18 + outOffset] = (curInputValue3 >>> 12) & mask; - out[19 + outOffset] = (curInputValue3 >>> 18) & mask; - out[20 + outOffset] = (curInputValue3 >>> 24) & mask; - out[21 + outOffset] = ((curInputValue3 >>> 30) | (curInputValue4 << 2)) & mask; - out[22 + outOffset] = (curInputValue4 >>> 4) & mask; - out[23 + outOffset] = (curInputValue4 >>> 10) & mask; - out[24 + outOffset] = (curInputValue4 >>> 16) & mask; - out[25 + outOffset] = (curInputValue4 >>> 22) & mask; - out[26 + outOffset] = ((curInputValue4 >>> 28) | (curInputValue5 << 4)) & mask; - out[27 + outOffset] = (curInputValue5 >>> 2) & mask; - out[28 + outOffset] = (curInputValue5 >>> 8) & mask; - out[29 + outOffset] = (curInputValue5 >>> 14) & mask; - out[30 + outOffset] = (curInputValue5 >>> 20) & mask; - out[31 + outOffset] = curInputValue5 >>> 26; - outOffset += 32; + static private void unpack6(int[] out, int[] in) { + int i, w; + int outOffset = 0; + final int mask = 63; + for (i = 0, w = 1; i < 4; ++i, w += 6) { + int curInputValue0 = in[w]; + int curInputValue1 = in[w + 1]; + int curInputValue2 = in[w + 2]; + int curInputValue3 = in[w + 3]; + int curInputValue4 = in[w + 4]; + int curInputValue5 = in[w + 5]; + out[0 + outOffset] = curInputValue0 & mask; + out[1 + outOffset] = (curInputValue0 >>> 6) & mask; + out[2 + outOffset] = (curInputValue0 >>> 12) & mask; + out[3 + outOffset] = (curInputValue0 >>> 18) & mask; + out[4 + outOffset] = (curInputValue0 >>> 24) & mask; + out[5 + outOffset] = ((curInputValue0 >>> 30) | (curInputValue1 << 2)) + & mask; + out[6 + outOffset] = (curInputValue1 >>> 4) & mask; + out[7 + outOffset] = (curInputValue1 >>> 10) & mask; + out[8 + outOffset] = (curInputValue1 >>> 16) & mask; + out[9 + outOffset] = (curInputValue1 >>> 22) & mask; + out[10 + outOffset] = ((curInputValue1 >>> 28) | (curInputValue2 << 4)) + & mask; + out[11 + outOffset] = (curInputValue2 >>> 2) & mask; + out[12 + outOffset] = (curInputValue2 >>> 8) & mask; + out[13 + outOffset] = (curInputValue2 >>> 14) & mask; + out[14 + outOffset] = (curInputValue2 >>> 20) & mask; + out[15 + outOffset] = curInputValue2 >>> 26; + out[16 + outOffset] = curInputValue3 & mask; + out[17 + outOffset] = (curInputValue3 >>> 6) & mask; + out[18 + outOffset] = (curInputValue3 >>> 12) & mask; + out[19 + outOffset] = (curInputValue3 >>> 18) & mask; + out[20 + outOffset] = (curInputValue3 >>> 24) & mask; + out[21 + outOffset] = ((curInputValue3 >>> 30) | (curInputValue4 << 2)) + & mask; + out[22 + outOffset] = (curInputValue4 >>> 4) & mask; + out[23 + outOffset] = (curInputValue4 >>> 10) & mask; + out[24 + outOffset] = (curInputValue4 >>> 16) & mask; + out[25 + outOffset] = (curInputValue4 >>> 22) & mask; + out[26 + outOffset] = ((curInputValue4 >>> 28) | (curInputValue5 << 4)) + & mask; + out[27 + outOffset] = (curInputValue5 >>> 2) & mask; + out[28 + outOffset] = (curInputValue5 >>> 8) & mask; + out[29 + outOffset] = (curInputValue5 >>> 14) & mask; + out[30 + outOffset] = (curInputValue5 >>> 20) & mask; + out[31 + outOffset] = curInputValue5 >>> 26; + outOffset += 32; + } } - } - static private void unpack7(int[] out, int[] in) { - int i, w; - int outOffset = 0; - final int mask = 127; - for (i = 0, w = 1; i < 4; ++i, w += 7) { - int curInputValue0 = in[w]; - int curInputValue1 = in[w + 1]; - int curInputValue2 = in[w + 2]; - int curInputValue3 = in[w + 3]; - int curInputValue4 = in[w + 4]; - int curInputValue5 = in[w + 5]; - int curInputValue6 = in[w + 6]; - out[0 + outOffset] = curInputValue0 & mask; - out[1 + outOffset] = (curInputValue0 >>> 7) & mask; - out[2 + outOffset] = (curInputValue0 >>> 14) & mask; - out[3 + outOffset] = (curInputValue0 >>> 21) & mask; - out[4 + outOffset] = ((curInputValue0 >>> 28) | (curInputValue1 << 4)) & mask; - out[5 + outOffset] = (curInputValue1 >>> 3) & mask; - out[6 + outOffset] = (curInputValue1 >>> 10) & mask; - out[7 + outOffset] = (curInputValue1 >>> 17) & mask; - out[8 + outOffset] = (curInputValue1 >>> 24) & mask; - out[9 + outOffset] = ((curInputValue1 >>> 31) | (curInputValue2 << 1)) & mask; - out[10 + outOffset] = (curInputValue2 >>> 6) & mask; - out[11 + outOffset] = (curInputValue2 >>> 13) & mask; - out[12 + outOffset] = (curInputValue2 >>> 20) & mask; - out[13 + outOffset] = ((curInputValue2 >>> 27) | (curInputValue3 << 5)) & mask; - out[14 + outOffset] = (curInputValue3 >>> 2) & mask; - out[15 + outOffset] = (curInputValue3 >>> 9) & mask; - out[16 + outOffset] = (curInputValue3 >>> 16) & mask; - out[17 + outOffset] = (curInputValue3 >>> 23) & mask; - out[18 + outOffset] = ((curInputValue3 >>> 30) | (curInputValue4 << 2)) & mask; - out[19 + outOffset] = (curInputValue4 >>> 5) & mask; - out[20 + outOffset] = (curInputValue4 >>> 12) & mask; - out[21 + outOffset] = (curInputValue4 >>> 19) & mask; - out[22 + outOffset] = ((curInputValue4 >>> 26) | (curInputValue5 << 6)) & mask; - out[23 + outOffset] = (curInputValue5 >>> 1) & mask; - out[24 + outOffset] = (curInputValue5 >>> 8) & mask; - out[25 + outOffset] = (curInputValue5 >>> 15) & mask; - out[26 + outOffset] = (curInputValue5 >>> 22) & mask; - out[27 + outOffset] = ((curInputValue5 >>> 29) | (curInputValue6 << 3)) & mask; - out[28 + outOffset] = (curInputValue6 >>> 4) & mask; - out[29 + outOffset] = (curInputValue6 >>> 11) & mask; - out[30 + outOffset] = (curInputValue6 >>> 18) & mask; - out[31 + outOffset] = curInputValue6 >>> 25; - outOffset += 32; + static private void unpack7(int[] out, int[] in) { + int i, w; + int outOffset = 0; + final int mask = 127; + for (i = 0, w = 1; i < 4; ++i, w += 7) { + int curInputValue0 = in[w]; + int curInputValue1 = in[w + 1]; + int curInputValue2 = in[w + 2]; + int curInputValue3 = in[w + 3]; + int curInputValue4 = in[w + 4]; + int curInputValue5 = in[w + 5]; + int curInputValue6 = in[w + 6]; + out[0 + outOffset] = curInputValue0 & mask; + out[1 + outOffset] = (curInputValue0 >>> 7) & mask; + out[2 + outOffset] = (curInputValue0 >>> 14) & mask; + out[3 + outOffset] = (curInputValue0 >>> 21) & mask; + out[4 + outOffset] = ((curInputValue0 >>> 28) | (curInputValue1 << 4)) + & mask; + out[5 + outOffset] = (curInputValue1 >>> 3) & mask; + out[6 + outOffset] = (curInputValue1 >>> 10) & mask; + out[7 + outOffset] = (curInputValue1 >>> 17) & mask; + out[8 + outOffset] = (curInputValue1 >>> 24) & mask; + out[9 + outOffset] = ((curInputValue1 >>> 31) | (curInputValue2 << 1)) + & mask; + out[10 + outOffset] = (curInputValue2 >>> 6) & mask; + out[11 + outOffset] = (curInputValue2 >>> 13) & mask; + out[12 + outOffset] = (curInputValue2 >>> 20) & mask; + out[13 + outOffset] = ((curInputValue2 >>> 27) | (curInputValue3 << 5)) + & mask; + out[14 + outOffset] = (curInputValue3 >>> 2) & mask; + out[15 + outOffset] = (curInputValue3 >>> 9) & mask; + out[16 + outOffset] = (curInputValue3 >>> 16) & mask; + out[17 + outOffset] = (curInputValue3 >>> 23) & mask; + out[18 + outOffset] = ((curInputValue3 >>> 30) | (curInputValue4 << 2)) + & mask; + out[19 + outOffset] = (curInputValue4 >>> 5) & mask; + out[20 + outOffset] = (curInputValue4 >>> 12) & mask; + out[21 + outOffset] = (curInputValue4 >>> 19) & mask; + out[22 + outOffset] = ((curInputValue4 >>> 26) | (curInputValue5 << 6)) + & mask; + out[23 + outOffset] = (curInputValue5 >>> 1) & mask; + out[24 + outOffset] = (curInputValue5 >>> 8) & mask; + out[25 + outOffset] = (curInputValue5 >>> 15) & mask; + out[26 + outOffset] = (curInputValue5 >>> 22) & mask; + out[27 + outOffset] = ((curInputValue5 >>> 29) | (curInputValue6 << 3)) + & mask; + out[28 + outOffset] = (curInputValue6 >>> 4) & mask; + out[29 + outOffset] = (curInputValue6 >>> 11) & mask; + out[30 + outOffset] = (curInputValue6 >>> 18) & mask; + out[31 + outOffset] = curInputValue6 >>> 25; + outOffset += 32; + } } - } - static private void unpack8(int[] out, int[] in) { - int i, w; - int outOffset = 0; - final int mask = 255; - for (i = 0, w = 1; i < 4; ++i, w += 8) { - int curInputValue0 = in[w]; - int curInputValue1 = in[w + 1]; - int curInputValue2 = in[w + 2]; - int curInputValue3 = in[w + 3]; - int curInputValue4 = in[w + 4]; - int curInputValue5 = in[w + 5]; - int curInputValue6 = in[w + 6]; - int curInputValue7 = in[w + 7]; - out[0 + outOffset] = curInputValue0 & mask; - out[1 + outOffset] = (curInputValue0 >>> 8) & mask; - out[2 + outOffset] = (curInputValue0 >>> 16) & mask; - out[3 + outOffset] = curInputValue0 >>> 24; - out[4 + outOffset] = curInputValue1 & mask; - out[5 + outOffset] = (curInputValue1 >>> 8) & mask; - out[6 + outOffset] = (curInputValue1 >>> 16) & mask; - out[7 + outOffset] = curInputValue1 >>> 24; - out[8 + outOffset] = curInputValue2 & mask; - out[9 + outOffset] = (curInputValue2 >>> 8) & mask; - out[10 + outOffset] = (curInputValue2 >>> 16) & mask; - out[11 + outOffset] = curInputValue2 >>> 24; - out[12 + outOffset] = curInputValue3 & mask; - out[13 + outOffset] = (curInputValue3 >>> 8) & mask; - out[14 + outOffset] = (curInputValue3 >>> 16) & mask; - out[15 + outOffset] = curInputValue3 >>> 24; - out[16 + outOffset] = curInputValue4 & mask; - out[17 + outOffset] = (curInputValue4 >>> 8) & mask; - out[18 + outOffset] = (curInputValue4 >>> 16) & mask; - out[19 + outOffset] = curInputValue4 >>> 24; - out[20 + outOffset] = curInputValue5 & mask; - out[21 + outOffset] = (curInputValue5 >>> 8) & mask; - out[22 + outOffset] = (curInputValue5 >>> 16) & mask; - out[23 + outOffset] = curInputValue5 >>> 24; - out[24 + outOffset] = curInputValue6 & mask; - out[25 + outOffset] = (curInputValue6 >>> 8) & mask; - out[26 + outOffset] = (curInputValue6 >>> 16) & mask; - out[27 + outOffset] = curInputValue6 >>> 24; - out[28 + outOffset] = curInputValue7 & mask; - out[29 + outOffset] = (curInputValue7 >>> 8) & mask; - out[30 + outOffset] = (curInputValue7 >>> 16) & mask; - out[31 + outOffset] = curInputValue7 >>> 24; - outOffset += 32; + static private void unpack8(int[] out, int[] in) { + int i, w; + int outOffset = 0; + final int mask = 255; + for (i = 0, w = 1; i < 4; ++i, w += 8) { + int curInputValue0 = in[w]; + int curInputValue1 = in[w + 1]; + int curInputValue2 = in[w + 2]; + int curInputValue3 = in[w + 3]; + int curInputValue4 = in[w + 4]; + int curInputValue5 = in[w + 5]; + int curInputValue6 = in[w + 6]; + int curInputValue7 = in[w + 7]; + out[0 + outOffset] = curInputValue0 & mask; + out[1 + outOffset] = (curInputValue0 >>> 8) & mask; + out[2 + outOffset] = (curInputValue0 >>> 16) & mask; + out[3 + outOffset] = curInputValue0 >>> 24; + out[4 + outOffset] = curInputValue1 & mask; + out[5 + outOffset] = (curInputValue1 >>> 8) & mask; + out[6 + outOffset] = (curInputValue1 >>> 16) & mask; + out[7 + outOffset] = curInputValue1 >>> 24; + out[8 + outOffset] = curInputValue2 & mask; + out[9 + outOffset] = (curInputValue2 >>> 8) & mask; + out[10 + outOffset] = (curInputValue2 >>> 16) & mask; + out[11 + outOffset] = curInputValue2 >>> 24; + out[12 + outOffset] = curInputValue3 & mask; + out[13 + outOffset] = (curInputValue3 >>> 8) & mask; + out[14 + outOffset] = (curInputValue3 >>> 16) & mask; + out[15 + outOffset] = curInputValue3 >>> 24; + out[16 + outOffset] = curInputValue4 & mask; + out[17 + outOffset] = (curInputValue4 >>> 8) & mask; + out[18 + outOffset] = (curInputValue4 >>> 16) & mask; + out[19 + outOffset] = curInputValue4 >>> 24; + out[20 + outOffset] = curInputValue5 & mask; + out[21 + outOffset] = (curInputValue5 >>> 8) & mask; + out[22 + outOffset] = (curInputValue5 >>> 16) & mask; + out[23 + outOffset] = curInputValue5 >>> 24; + out[24 + outOffset] = curInputValue6 & mask; + out[25 + outOffset] = (curInputValue6 >>> 8) & mask; + out[26 + outOffset] = (curInputValue6 >>> 16) & mask; + out[27 + outOffset] = curInputValue6 >>> 24; + out[28 + outOffset] = curInputValue7 & mask; + out[29 + outOffset] = (curInputValue7 >>> 8) & mask; + out[30 + outOffset] = (curInputValue7 >>> 16) & mask; + out[31 + outOffset] = curInputValue7 >>> 24; + outOffset += 32; + } } - } - static private void unpack9(int[] out, int[] in) { - int i, w; - int outOffset = 0; - final int mask = 511; - for (i = 0, w = 1; i < 4; ++i, w += 9) { - int curInputValue0 = in[w]; - int curInputValue1 = in[w + 1]; - int curInputValue2 = in[w + 2]; - int curInputValue3 = in[w + 3]; - int curInputValue4 = in[w + 4]; - int curInputValue5 = in[w + 5]; - int curInputValue6 = in[w + 6]; - int curInputValue7 = in[w + 7]; - int curInputValue8 = in[w + 8]; - out[0 + outOffset] = curInputValue0 & mask; - out[1 + outOffset] = (curInputValue0 >>> 9) & mask; - out[2 + outOffset] = (curInputValue0 >>> 18) & mask; - out[3 + outOffset] = ((curInputValue0 >>> 27) | (curInputValue1 << 5)) & mask; - out[4 + outOffset] = (curInputValue1 >>> 4) & mask; - out[5 + outOffset] = (curInputValue1 >>> 13) & mask; - out[6 + outOffset] = (curInputValue1 >>> 22) & mask; - out[7 + outOffset] = ((curInputValue1 >>> 31) | (curInputValue2 << 1)) & mask; - out[8 + outOffset] = (curInputValue2 >>> 8) & mask; - out[9 + outOffset] = (curInputValue2 >>> 17) & mask; - out[10 + outOffset] = ((curInputValue2 >>> 26) | (curInputValue3 << 6)) & mask; - out[11 + outOffset] = (curInputValue3 >>> 3) & mask; - out[12 + outOffset] = (curInputValue3 >>> 12) & mask; - out[13 + outOffset] = (curInputValue3 >>> 21) & mask; - out[14 + outOffset] = ((curInputValue3 >>> 30) | (curInputValue4 << 2)) & mask; - out[15 + outOffset] = (curInputValue4 >>> 7) & mask; - out[16 + outOffset] = (curInputValue4 >>> 16) & mask; - out[17 + outOffset] = ((curInputValue4 >>> 25) | (curInputValue5 << 7)) & mask; - out[18 + outOffset] = (curInputValue5 >>> 2) & mask; - out[19 + outOffset] = (curInputValue5 >>> 11) & mask; - out[20 + outOffset] = (curInputValue5 >>> 20) & mask; - out[21 + outOffset] = ((curInputValue5 >>> 29) | (curInputValue6 << 3)) & mask; - out[22 + outOffset] = (curInputValue6 >>> 6) & mask; - out[23 + outOffset] = (curInputValue6 >>> 15) & mask; - out[24 + outOffset] = ((curInputValue6 >>> 24) | (curInputValue7 << 8)) & mask; - out[25 + outOffset] = (curInputValue7 >>> 1) & mask; - out[26 + outOffset] = (curInputValue7 >>> 10) & mask; - out[27 + outOffset] = (curInputValue7 >>> 19) & mask; - out[28 + outOffset] = ((curInputValue7 >>> 28) | (curInputValue8 << 4)) & mask; - out[29 + outOffset] = (curInputValue8 >>> 5) & mask; - out[30 + outOffset] = (curInputValue8 >>> 14) & mask; - out[31 + outOffset] = curInputValue8 >>> 23; - outOffset += 32; + static private void unpack9(int[] out, int[] in) { + int i, w; + int outOffset = 0; + final int mask = 511; + for (i = 0, w = 1; i < 4; ++i, w += 9) { + int curInputValue0 = in[w]; + int curInputValue1 = in[w + 1]; + int curInputValue2 = in[w + 2]; + int curInputValue3 = in[w + 3]; + int curInputValue4 = in[w + 4]; + int curInputValue5 = in[w + 5]; + int curInputValue6 = in[w + 6]; + int curInputValue7 = in[w + 7]; + int curInputValue8 = in[w + 8]; + out[0 + outOffset] = curInputValue0 & mask; + out[1 + outOffset] = (curInputValue0 >>> 9) & mask; + out[2 + outOffset] = (curInputValue0 >>> 18) & mask; + out[3 + outOffset] = ((curInputValue0 >>> 27) | (curInputValue1 << 5)) + & mask; + out[4 + outOffset] = (curInputValue1 >>> 4) & mask; + out[5 + outOffset] = (curInputValue1 >>> 13) & mask; + out[6 + outOffset] = (curInputValue1 >>> 22) & mask; + out[7 + outOffset] = ((curInputValue1 >>> 31) | (curInputValue2 << 1)) + & mask; + out[8 + outOffset] = (curInputValue2 >>> 8) & mask; + out[9 + outOffset] = (curInputValue2 >>> 17) & mask; + out[10 + outOffset] = ((curInputValue2 >>> 26) | (curInputValue3 << 6)) + & mask; + out[11 + outOffset] = (curInputValue3 >>> 3) & mask; + out[12 + outOffset] = (curInputValue3 >>> 12) & mask; + out[13 + outOffset] = (curInputValue3 >>> 21) & mask; + out[14 + outOffset] = ((curInputValue3 >>> 30) | (curInputValue4 << 2)) + & mask; + out[15 + outOffset] = (curInputValue4 >>> 7) & mask; + out[16 + outOffset] = (curInputValue4 >>> 16) & mask; + out[17 + outOffset] = ((curInputValue4 >>> 25) | (curInputValue5 << 7)) + & mask; + out[18 + outOffset] = (curInputValue5 >>> 2) & mask; + out[19 + outOffset] = (curInputValue5 >>> 11) & mask; + out[20 + outOffset] = (curInputValue5 >>> 20) & mask; + out[21 + outOffset] = ((curInputValue5 >>> 29) | (curInputValue6 << 3)) + & mask; + out[22 + outOffset] = (curInputValue6 >>> 6) & mask; + out[23 + outOffset] = (curInputValue6 >>> 15) & mask; + out[24 + outOffset] = ((curInputValue6 >>> 24) | (curInputValue7 << 8)) + & mask; + out[25 + outOffset] = (curInputValue7 >>> 1) & mask; + out[26 + outOffset] = (curInputValue7 >>> 10) & mask; + out[27 + outOffset] = (curInputValue7 >>> 19) & mask; + out[28 + outOffset] = ((curInputValue7 >>> 28) | (curInputValue8 << 4)) + & mask; + out[29 + outOffset] = (curInputValue8 >>> 5) & mask; + out[30 + outOffset] = (curInputValue8 >>> 14) & mask; + out[31 + outOffset] = curInputValue8 >>> 23; + outOffset += 32; + } } - } - static private void unpack10(int[] out, int[] in) { - int i, w; - int outOffset = 0; - final int mask = 1023; - for (i = 0, w = 1; i < 4; ++i, w += 10) { - int curInputValue0 = in[w]; - int curInputValue1 = in[w + 1]; - int curInputValue2 = in[w + 2]; - int curInputValue3 = in[w + 3]; - int curInputValue4 = in[w + 4]; - int curInputValue5 = in[w + 5]; - int curInputValue6 = in[w + 6]; - int curInputValue7 = in[w + 7]; - int curInputValue8 = in[w + 8]; - int curInputValue9 = in[w + 9]; - out[0 + outOffset] = curInputValue0 & mask; - out[1 + outOffset] = (curInputValue0 >>> 10) & mask; - out[2 + outOffset] = (curInputValue0 >>> 20) & mask; - out[3 + outOffset] = ((curInputValue0 >>> 30) | (curInputValue1 << 2)) & mask; - out[4 + outOffset] = (curInputValue1 >>> 8) & mask; - out[5 + outOffset] = (curInputValue1 >>> 18) & mask; - out[6 + outOffset] = ((curInputValue1 >>> 28) | (curInputValue2 << 4)) & mask; - out[7 + outOffset] = (curInputValue2 >>> 6) & mask; - out[8 + outOffset] = (curInputValue2 >>> 16) & mask; - out[9 + outOffset] = ((curInputValue2 >>> 26) | (curInputValue3 << 6)) & mask; - out[10 + outOffset] = (curInputValue3 >>> 4) & mask; - out[11 + outOffset] = (curInputValue3 >>> 14) & mask; - out[12 + outOffset] = ((curInputValue3 >>> 24) | (curInputValue4 << 8)) & mask; - out[13 + outOffset] = (curInputValue4 >>> 2) & mask; - out[14 + outOffset] = (curInputValue4 >>> 12) & mask; - out[15 + outOffset] = curInputValue4 >>> 22; - out[16 + outOffset] = curInputValue5 & mask; - out[17 + outOffset] = (curInputValue5 >>> 10) & mask; - out[18 + outOffset] = (curInputValue5 >>> 20) & mask; - out[19 + outOffset] = ((curInputValue5 >>> 30) | (curInputValue6 << 2)) & mask; - out[20 + outOffset] = (curInputValue6 >>> 8) & mask; - out[21 + outOffset] = (curInputValue6 >>> 18) & mask; - out[22 + outOffset] = ((curInputValue6 >>> 28) | (curInputValue7 << 4)) & mask; - out[23 + outOffset] = (curInputValue7 >>> 6) & mask; - out[24 + outOffset] = (curInputValue7 >>> 16) & mask; - out[25 + outOffset] = ((curInputValue7 >>> 26) | (curInputValue8 << 6)) & mask; - out[26 + outOffset] = (curInputValue8 >>> 4) & mask; - out[27 + outOffset] = (curInputValue8 >>> 14) & mask; - out[28 + outOffset] = ((curInputValue8 >>> 24) | (curInputValue9 << 8)) & mask; - out[29 + outOffset] = (curInputValue9 >>> 2) & mask; - out[30 + outOffset] = (curInputValue9 >>> 12) & mask; - out[31 + outOffset] = curInputValue9 >>> 22; - outOffset += 32; + static private void unpack10(int[] out, int[] in) { + int i, w; + int outOffset = 0; + final int mask = 1023; + for (i = 0, w = 1; i < 4; ++i, w += 10) { + int curInputValue0 = in[w]; + int curInputValue1 = in[w + 1]; + int curInputValue2 = in[w + 2]; + int curInputValue3 = in[w + 3]; + int curInputValue4 = in[w + 4]; + int curInputValue5 = in[w + 5]; + int curInputValue6 = in[w + 6]; + int curInputValue7 = in[w + 7]; + int curInputValue8 = in[w + 8]; + int curInputValue9 = in[w + 9]; + out[0 + outOffset] = curInputValue0 & mask; + out[1 + outOffset] = (curInputValue0 >>> 10) & mask; + out[2 + outOffset] = (curInputValue0 >>> 20) & mask; + out[3 + outOffset] = ((curInputValue0 >>> 30) | (curInputValue1 << 2)) + & mask; + out[4 + outOffset] = (curInputValue1 >>> 8) & mask; + out[5 + outOffset] = (curInputValue1 >>> 18) & mask; + out[6 + outOffset] = ((curInputValue1 >>> 28) | (curInputValue2 << 4)) + & mask; + out[7 + outOffset] = (curInputValue2 >>> 6) & mask; + out[8 + outOffset] = (curInputValue2 >>> 16) & mask; + out[9 + outOffset] = ((curInputValue2 >>> 26) | (curInputValue3 << 6)) + & mask; + out[10 + outOffset] = (curInputValue3 >>> 4) & mask; + out[11 + outOffset] = (curInputValue3 >>> 14) & mask; + out[12 + outOffset] = ((curInputValue3 >>> 24) | (curInputValue4 << 8)) + & mask; + out[13 + outOffset] = (curInputValue4 >>> 2) & mask; + out[14 + outOffset] = (curInputValue4 >>> 12) & mask; + out[15 + outOffset] = curInputValue4 >>> 22; + out[16 + outOffset] = curInputValue5 & mask; + out[17 + outOffset] = (curInputValue5 >>> 10) & mask; + out[18 + outOffset] = (curInputValue5 >>> 20) & mask; + out[19 + outOffset] = ((curInputValue5 >>> 30) | (curInputValue6 << 2)) + & mask; + out[20 + outOffset] = (curInputValue6 >>> 8) & mask; + out[21 + outOffset] = (curInputValue6 >>> 18) & mask; + out[22 + outOffset] = ((curInputValue6 >>> 28) | (curInputValue7 << 4)) + & mask; + out[23 + outOffset] = (curInputValue7 >>> 6) & mask; + out[24 + outOffset] = (curInputValue7 >>> 16) & mask; + out[25 + outOffset] = ((curInputValue7 >>> 26) | (curInputValue8 << 6)) + & mask; + out[26 + outOffset] = (curInputValue8 >>> 4) & mask; + out[27 + outOffset] = (curInputValue8 >>> 14) & mask; + out[28 + outOffset] = ((curInputValue8 >>> 24) | (curInputValue9 << 8)) + & mask; + out[29 + outOffset] = (curInputValue9 >>> 2) & mask; + out[30 + outOffset] = (curInputValue9 >>> 12) & mask; + out[31 + outOffset] = curInputValue9 >>> 22; + outOffset += 32; + } } - } - static private void unpack11(int[] out, int[] in) { - int i, w; - int outOffset = 0; - final int mask = 2047; - for (i = 0, w = 1; i < 4; ++i, w += 11) { - int curInputValue0 = in[w]; - int curInputValue1 = in[w + 1]; - int curInputValue2 = in[w + 2]; - int curInputValue3 = in[w + 3]; - int curInputValue4 = in[w + 4]; - int curInputValue5 = in[w + 5]; - int curInputValue6 = in[w + 6]; - int curInputValue7 = in[w + 7]; - int curInputValue8 = in[w + 8]; - int curInputValue9 = in[w + 9]; - int curInputValue10 = in[w + 10]; - out[0 + outOffset] = curInputValue0 & mask; - out[1 + outOffset] = (curInputValue0 >>> 11) & mask; - out[2 + outOffset] = ((curInputValue0 >>> 22) | (curInputValue1 << 10)) & mask; - out[3 + outOffset] = (curInputValue1 >>> 1) & mask; - out[4 + outOffset] = (curInputValue1 >>> 12) & mask; - out[5 + outOffset] = ((curInputValue1 >>> 23) | (curInputValue2 << 9)) & mask; - out[6 + outOffset] = (curInputValue2 >>> 2) & mask; - out[7 + outOffset] = (curInputValue2 >>> 13) & mask; - out[8 + outOffset] = ((curInputValue2 >>> 24) | (curInputValue3 << 8)) & mask; - out[9 + outOffset] = (curInputValue3 >>> 3) & mask; - out[10 + outOffset] = (curInputValue3 >>> 14) & mask; - out[11 + outOffset] = ((curInputValue3 >>> 25) | (curInputValue4 << 7)) & mask; - out[12 + outOffset] = (curInputValue4 >>> 4) & mask; - out[13 + outOffset] = (curInputValue4 >>> 15) & mask; - out[14 + outOffset] = ((curInputValue4 >>> 26) | (curInputValue5 << 6)) & mask; - out[15 + outOffset] = (curInputValue5 >>> 5) & mask; - out[16 + outOffset] = (curInputValue5 >>> 16) & mask; - out[17 + outOffset] = ((curInputValue5 >>> 27) | (curInputValue6 << 5)) & mask; - out[18 + outOffset] = (curInputValue6 >>> 6) & mask; - out[19 + outOffset] = (curInputValue6 >>> 17) & mask; - out[20 + outOffset] = ((curInputValue6 >>> 28) | (curInputValue7 << 4)) & mask; - out[21 + outOffset] = (curInputValue7 >>> 7) & mask; - out[22 + outOffset] = (curInputValue7 >>> 18) & mask; - out[23 + outOffset] = ((curInputValue7 >>> 29) | (curInputValue8 << 3)) & mask; - out[24 + outOffset] = (curInputValue8 >>> 8) & mask; - out[25 + outOffset] = (curInputValue8 >>> 19) & mask; - out[26 + outOffset] = ((curInputValue8 >>> 30) | (curInputValue9 << 2)) & mask; - out[27 + outOffset] = (curInputValue9 >>> 9) & mask; - out[28 + outOffset] = (curInputValue9 >>> 20) & mask; - out[29 + outOffset] = ((curInputValue9 >>> 31) | (curInputValue10 << 1)) & mask; - out[30 + outOffset] = (curInputValue10 >>> 10) & mask; - out[31 + outOffset] = curInputValue10 >>> 21; - outOffset += 32; + static private void unpack11(int[] out, int[] in) { + int i, w; + int outOffset = 0; + final int mask = 2047; + for (i = 0, w = 1; i < 4; ++i, w += 11) { + int curInputValue0 = in[w]; + int curInputValue1 = in[w + 1]; + int curInputValue2 = in[w + 2]; + int curInputValue3 = in[w + 3]; + int curInputValue4 = in[w + 4]; + int curInputValue5 = in[w + 5]; + int curInputValue6 = in[w + 6]; + int curInputValue7 = in[w + 7]; + int curInputValue8 = in[w + 8]; + int curInputValue9 = in[w + 9]; + int curInputValue10 = in[w + 10]; + out[0 + outOffset] = curInputValue0 & mask; + out[1 + outOffset] = (curInputValue0 >>> 11) & mask; + out[2 + outOffset] = ((curInputValue0 >>> 22) | (curInputValue1 << 10)) + & mask; + out[3 + outOffset] = (curInputValue1 >>> 1) & mask; + out[4 + outOffset] = (curInputValue1 >>> 12) & mask; + out[5 + outOffset] = ((curInputValue1 >>> 23) | (curInputValue2 << 9)) + & mask; + out[6 + outOffset] = (curInputValue2 >>> 2) & mask; + out[7 + outOffset] = (curInputValue2 >>> 13) & mask; + out[8 + outOffset] = ((curInputValue2 >>> 24) | (curInputValue3 << 8)) + & mask; + out[9 + outOffset] = (curInputValue3 >>> 3) & mask; + out[10 + outOffset] = (curInputValue3 >>> 14) & mask; + out[11 + outOffset] = ((curInputValue3 >>> 25) | (curInputValue4 << 7)) + & mask; + out[12 + outOffset] = (curInputValue4 >>> 4) & mask; + out[13 + outOffset] = (curInputValue4 >>> 15) & mask; + out[14 + outOffset] = ((curInputValue4 >>> 26) | (curInputValue5 << 6)) + & mask; + out[15 + outOffset] = (curInputValue5 >>> 5) & mask; + out[16 + outOffset] = (curInputValue5 >>> 16) & mask; + out[17 + outOffset] = ((curInputValue5 >>> 27) | (curInputValue6 << 5)) + & mask; + out[18 + outOffset] = (curInputValue6 >>> 6) & mask; + out[19 + outOffset] = (curInputValue6 >>> 17) & mask; + out[20 + outOffset] = ((curInputValue6 >>> 28) | (curInputValue7 << 4)) + & mask; + out[21 + outOffset] = (curInputValue7 >>> 7) & mask; + out[22 + outOffset] = (curInputValue7 >>> 18) & mask; + out[23 + outOffset] = ((curInputValue7 >>> 29) | (curInputValue8 << 3)) + & mask; + out[24 + outOffset] = (curInputValue8 >>> 8) & mask; + out[25 + outOffset] = (curInputValue8 >>> 19) & mask; + out[26 + outOffset] = ((curInputValue8 >>> 30) | (curInputValue9 << 2)) + & mask; + out[27 + outOffset] = (curInputValue9 >>> 9) & mask; + out[28 + outOffset] = (curInputValue9 >>> 20) & mask; + out[29 + outOffset] = ((curInputValue9 >>> 31) | (curInputValue10 << 1)) + & mask; + out[30 + outOffset] = (curInputValue10 >>> 10) & mask; + out[31 + outOffset] = curInputValue10 >>> 21; + outOffset += 32; + } } - } - static private void unpack12(int[] out, int[] in) { - int i, w; - int outOffset = 0; - final int mask = 4095; - for (i = 0, w = 1; i < 4; ++i, w += 12) { - int curInputValue0 = in[w]; - int curInputValue1 = in[w + 1]; - int curInputValue2 = in[w + 2]; - int curInputValue3 = in[w + 3]; - int curInputValue4 = in[w + 4]; - int curInputValue5 = in[w + 5]; - int curInputValue6 = in[w + 6]; - int curInputValue7 = in[w + 7]; - int curInputValue8 = in[w + 8]; - int curInputValue9 = in[w + 9]; - int curInputValue10 = in[w + 10]; - int curInputValue11 = in[w + 11]; - out[0 + outOffset] = curInputValue0 & mask; - out[1 + outOffset] = (curInputValue0 >>> 12) & mask; - out[2 + outOffset] = ((curInputValue0 >>> 24) | (curInputValue1 << 8)) & mask; - out[3 + outOffset] = (curInputValue1 >>> 4) & mask; - out[4 + outOffset] = (curInputValue1 >>> 16) & mask; - out[5 + outOffset] = ((curInputValue1 >>> 28) | (curInputValue2 << 4)) & mask; - out[6 + outOffset] = (curInputValue2 >>> 8) & mask; - out[7 + outOffset] = curInputValue2 >>> 20; - out[8 + outOffset] = curInputValue3 & mask; - out[9 + outOffset] = (curInputValue3 >>> 12) & mask; - out[10 + outOffset] = ((curInputValue3 >>> 24) | (curInputValue4 << 8)) & mask; - out[11 + outOffset] = (curInputValue4 >>> 4) & mask; - out[12 + outOffset] = (curInputValue4 >>> 16) & mask; - out[13 + outOffset] = ((curInputValue4 >>> 28) | (curInputValue5 << 4)) & mask; - out[14 + outOffset] = (curInputValue5 >>> 8) & mask; - out[15 + outOffset] = curInputValue5 >>> 20; - out[16 + outOffset] = curInputValue6 & mask; - out[17 + outOffset] = (curInputValue6 >>> 12) & mask; - out[18 + outOffset] = ((curInputValue6 >>> 24) | (curInputValue7 << 8)) & mask; - out[19 + outOffset] = (curInputValue7 >>> 4) & mask; - out[20 + outOffset] = (curInputValue7 >>> 16) & mask; - out[21 + outOffset] = ((curInputValue7 >>> 28) | (curInputValue8 << 4)) & mask; - out[22 + outOffset] = (curInputValue8 >>> 8) & mask; - out[23 + outOffset] = curInputValue8 >>> 20; - out[24 + outOffset] = curInputValue9 & mask; - out[25 + outOffset] = (curInputValue9 >>> 12) & mask; - out[26 + outOffset] = ((curInputValue9 >>> 24) | (curInputValue10 << 8)) & mask; - out[27 + outOffset] = (curInputValue10 >>> 4) & mask; - out[28 + outOffset] = (curInputValue10 >>> 16) & mask; - out[29 + outOffset] = ((curInputValue10 >>> 28) | (curInputValue11 << 4)) & mask; - out[30 + outOffset] = (curInputValue11 >>> 8) & mask; - out[31 + outOffset] = curInputValue11 >>> 20; - outOffset += 32; + static private void unpack12(int[] out, int[] in) { + int i, w; + int outOffset = 0; + final int mask = 4095; + for (i = 0, w = 1; i < 4; ++i, w += 12) { + int curInputValue0 = in[w]; + int curInputValue1 = in[w + 1]; + int curInputValue2 = in[w + 2]; + int curInputValue3 = in[w + 3]; + int curInputValue4 = in[w + 4]; + int curInputValue5 = in[w + 5]; + int curInputValue6 = in[w + 6]; + int curInputValue7 = in[w + 7]; + int curInputValue8 = in[w + 8]; + int curInputValue9 = in[w + 9]; + int curInputValue10 = in[w + 10]; + int curInputValue11 = in[w + 11]; + out[0 + outOffset] = curInputValue0 & mask; + out[1 + outOffset] = (curInputValue0 >>> 12) & mask; + out[2 + outOffset] = ((curInputValue0 >>> 24) | (curInputValue1 << 8)) + & mask; + out[3 + outOffset] = (curInputValue1 >>> 4) & mask; + out[4 + outOffset] = (curInputValue1 >>> 16) & mask; + out[5 + outOffset] = ((curInputValue1 >>> 28) | (curInputValue2 << 4)) + & mask; + out[6 + outOffset] = (curInputValue2 >>> 8) & mask; + out[7 + outOffset] = curInputValue2 >>> 20; + out[8 + outOffset] = curInputValue3 & mask; + out[9 + outOffset] = (curInputValue3 >>> 12) & mask; + out[10 + outOffset] = ((curInputValue3 >>> 24) | (curInputValue4 << 8)) + & mask; + out[11 + outOffset] = (curInputValue4 >>> 4) & mask; + out[12 + outOffset] = (curInputValue4 >>> 16) & mask; + out[13 + outOffset] = ((curInputValue4 >>> 28) | (curInputValue5 << 4)) + & mask; + out[14 + outOffset] = (curInputValue5 >>> 8) & mask; + out[15 + outOffset] = curInputValue5 >>> 20; + out[16 + outOffset] = curInputValue6 & mask; + out[17 + outOffset] = (curInputValue6 >>> 12) & mask; + out[18 + outOffset] = ((curInputValue6 >>> 24) | (curInputValue7 << 8)) + & mask; + out[19 + outOffset] = (curInputValue7 >>> 4) & mask; + out[20 + outOffset] = (curInputValue7 >>> 16) & mask; + out[21 + outOffset] = ((curInputValue7 >>> 28) | (curInputValue8 << 4)) + & mask; + out[22 + outOffset] = (curInputValue8 >>> 8) & mask; + out[23 + outOffset] = curInputValue8 >>> 20; + out[24 + outOffset] = curInputValue9 & mask; + out[25 + outOffset] = (curInputValue9 >>> 12) & mask; + out[26 + outOffset] = ((curInputValue9 >>> 24) | (curInputValue10 << 8)) + & mask; + out[27 + outOffset] = (curInputValue10 >>> 4) & mask; + out[28 + outOffset] = (curInputValue10 >>> 16) & mask; + out[29 + outOffset] = ((curInputValue10 >>> 28) | (curInputValue11 << 4)) + & mask; + out[30 + outOffset] = (curInputValue11 >>> 8) & mask; + out[31 + outOffset] = curInputValue11 >>> 20; + outOffset += 32; + } } - } - static private void unpack13(int[] out, int[] in) { - int i, w; - int outOffset = 0; - final int mask = 8191; - for (i = 0, w = 1; i < 4; ++i, w += 13) { - int curInputValue0 = in[w]; - int curInputValue1 = in[w + 1]; - int curInputValue2 = in[w + 2]; - int curInputValue3 = in[w + 3]; - int curInputValue4 = in[w + 4]; - int curInputValue5 = in[w + 5]; - int curInputValue6 = in[w + 6]; - int curInputValue7 = in[w + 7]; - int curInputValue8 = in[w + 8]; - int curInputValue9 = in[w + 9]; - int curInputValue10 = in[w + 10]; - int curInputValue11 = in[w + 11]; - int curInputValue12 = in[w + 12]; - out[0 + outOffset] = curInputValue0 & mask; - out[1 + outOffset] = (curInputValue0 >>> 13) & mask; - out[2 + outOffset] = ((curInputValue0 >>> 26) | (curInputValue1 << 6)) & mask; - out[3 + outOffset] = (curInputValue1 >>> 7) & mask; - out[4 + outOffset] = ((curInputValue1 >>> 20) | (curInputValue2 << 12)) & mask; - out[5 + outOffset] = (curInputValue2 >>> 1) & mask; - out[6 + outOffset] = (curInputValue2 >>> 14) & mask; - out[7 + outOffset] = ((curInputValue2 >>> 27) | (curInputValue3 << 5)) & mask; - out[8 + outOffset] = (curInputValue3 >>> 8) & mask; - out[9 + outOffset] = ((curInputValue3 >>> 21) | (curInputValue4 << 11)) & mask; - out[10 + outOffset] = (curInputValue4 >>> 2) & mask; - out[11 + outOffset] = (curInputValue4 >>> 15) & mask; - out[12 + outOffset] = ((curInputValue4 >>> 28) | (curInputValue5 << 4)) & mask; - out[13 + outOffset] = (curInputValue5 >>> 9) & mask; - out[14 + outOffset] = ((curInputValue5 >>> 22) | (curInputValue6 << 10)) & mask; - out[15 + outOffset] = (curInputValue6 >>> 3) & mask; - out[16 + outOffset] = (curInputValue6 >>> 16) & mask; - out[17 + outOffset] = ((curInputValue6 >>> 29) | (curInputValue7 << 3)) & mask; - out[18 + outOffset] = (curInputValue7 >>> 10) & mask; - out[19 + outOffset] = ((curInputValue7 >>> 23) | (curInputValue8 << 9)) & mask; - out[20 + outOffset] = (curInputValue8 >>> 4) & mask; - out[21 + outOffset] = (curInputValue8 >>> 17) & mask; - out[22 + outOffset] = ((curInputValue8 >>> 30) | (curInputValue9 << 2)) & mask; - out[23 + outOffset] = (curInputValue9 >>> 11) & mask; - out[24 + outOffset] = ((curInputValue9 >>> 24) | (curInputValue10 << 8)) & mask; - out[25 + outOffset] = (curInputValue10 >>> 5) & mask; - out[26 + outOffset] = (curInputValue10 >>> 18) & mask; - out[27 + outOffset] = ((curInputValue10 >>> 31) | (curInputValue11 << 1)) & mask; - out[28 + outOffset] = (curInputValue11 >>> 12) & mask; - out[29 + outOffset] = ((curInputValue11 >>> 25) | (curInputValue12 << 7)) & mask; - out[30 + outOffset] = (curInputValue12 >>> 6) & mask; - out[31 + outOffset] = curInputValue12 >>> 19; - outOffset += 32; + static private void unpack13(int[] out, int[] in) { + int i, w; + int outOffset = 0; + final int mask = 8191; + for (i = 0, w = 1; i < 4; ++i, w += 13) { + int curInputValue0 = in[w]; + int curInputValue1 = in[w + 1]; + int curInputValue2 = in[w + 2]; + int curInputValue3 = in[w + 3]; + int curInputValue4 = in[w + 4]; + int curInputValue5 = in[w + 5]; + int curInputValue6 = in[w + 6]; + int curInputValue7 = in[w + 7]; + int curInputValue8 = in[w + 8]; + int curInputValue9 = in[w + 9]; + int curInputValue10 = in[w + 10]; + int curInputValue11 = in[w + 11]; + int curInputValue12 = in[w + 12]; + out[0 + outOffset] = curInputValue0 & mask; + out[1 + outOffset] = (curInputValue0 >>> 13) & mask; + out[2 + outOffset] = ((curInputValue0 >>> 26) | (curInputValue1 << 6)) + & mask; + out[3 + outOffset] = (curInputValue1 >>> 7) & mask; + out[4 + outOffset] = ((curInputValue1 >>> 20) | (curInputValue2 << 12)) + & mask; + out[5 + outOffset] = (curInputValue2 >>> 1) & mask; + out[6 + outOffset] = (curInputValue2 >>> 14) & mask; + out[7 + outOffset] = ((curInputValue2 >>> 27) | (curInputValue3 << 5)) + & mask; + out[8 + outOffset] = (curInputValue3 >>> 8) & mask; + out[9 + outOffset] = ((curInputValue3 >>> 21) | (curInputValue4 << 11)) + & mask; + out[10 + outOffset] = (curInputValue4 >>> 2) & mask; + out[11 + outOffset] = (curInputValue4 >>> 15) & mask; + out[12 + outOffset] = ((curInputValue4 >>> 28) | (curInputValue5 << 4)) + & mask; + out[13 + outOffset] = (curInputValue5 >>> 9) & mask; + out[14 + outOffset] = ((curInputValue5 >>> 22) | (curInputValue6 << 10)) + & mask; + out[15 + outOffset] = (curInputValue6 >>> 3) & mask; + out[16 + outOffset] = (curInputValue6 >>> 16) & mask; + out[17 + outOffset] = ((curInputValue6 >>> 29) | (curInputValue7 << 3)) + & mask; + out[18 + outOffset] = (curInputValue7 >>> 10) & mask; + out[19 + outOffset] = ((curInputValue7 >>> 23) | (curInputValue8 << 9)) + & mask; + out[20 + outOffset] = (curInputValue8 >>> 4) & mask; + out[21 + outOffset] = (curInputValue8 >>> 17) & mask; + out[22 + outOffset] = ((curInputValue8 >>> 30) | (curInputValue9 << 2)) + & mask; + out[23 + outOffset] = (curInputValue9 >>> 11) & mask; + out[24 + outOffset] = ((curInputValue9 >>> 24) | (curInputValue10 << 8)) + & mask; + out[25 + outOffset] = (curInputValue10 >>> 5) & mask; + out[26 + outOffset] = (curInputValue10 >>> 18) & mask; + out[27 + outOffset] = ((curInputValue10 >>> 31) | (curInputValue11 << 1)) + & mask; + out[28 + outOffset] = (curInputValue11 >>> 12) & mask; + out[29 + outOffset] = ((curInputValue11 >>> 25) | (curInputValue12 << 7)) + & mask; + out[30 + outOffset] = (curInputValue12 >>> 6) & mask; + out[31 + outOffset] = curInputValue12 >>> 19; + outOffset += 32; + } } - } - static private void unpack16(int[] out, int[] in) { - int i, w; - int outOffset = 0; - final int mask = 65535; - for (i = 0, w = 1; i < 4; ++i, w += 16) { - int curInputValue0 = in[w]; - int curInputValue1 = in[w + 1]; - int curInputValue2 = in[w + 2]; - int curInputValue3 = in[w + 3]; - int curInputValue4 = in[w + 4]; - int curInputValue5 = in[w + 5]; - int curInputValue6 = in[w + 6]; - int curInputValue7 = in[w + 7]; - int curInputValue8 = in[w + 8]; - int curInputValue9 = in[w + 9]; - int curInputValue10 = in[w + 10]; - int curInputValue11 = in[w + 11]; - int curInputValue12 = in[w + 12]; - int curInputValue13 = in[w + 13]; - int curInputValue14 = in[w + 14]; - int curInputValue15 = in[w + 15]; - out[0 + outOffset] = curInputValue0 & mask; - out[1 + outOffset] = curInputValue0 >>> 16; - out[2 + outOffset] = curInputValue1 & mask; - out[3 + outOffset] = curInputValue1 >>> 16; - out[4 + outOffset] = curInputValue2 & mask; - out[5 + outOffset] = curInputValue2 >>> 16; - out[6 + outOffset] = curInputValue3 & mask; - out[7 + outOffset] = curInputValue3 >>> 16; - out[8 + outOffset] = curInputValue4 & mask; - out[9 + outOffset] = curInputValue4 >>> 16; - out[10 + outOffset] = curInputValue5 & mask; - out[11 + outOffset] = curInputValue5 >>> 16; - out[12 + outOffset] = curInputValue6 & mask; - out[13 + outOffset] = curInputValue6 >>> 16; - out[14 + outOffset] = curInputValue7 & mask; - out[15 + outOffset] = curInputValue7 >>> 16; - out[16 + outOffset] = curInputValue8 & mask; - out[17 + outOffset] = curInputValue8 >>> 16; - out[18 + outOffset] = curInputValue9 & mask; - out[19 + outOffset] = curInputValue9 >>> 16; - out[20 + outOffset] = curInputValue10 & mask; - out[21 + outOffset] = curInputValue10 >>> 16; - out[22 + outOffset] = curInputValue11 & mask; - out[23 + outOffset] = curInputValue11 >>> 16; - out[24 + outOffset] = curInputValue12 & mask; - out[25 + outOffset] = curInputValue12 >>> 16; - out[26 + outOffset] = curInputValue13 & mask; - out[27 + outOffset] = curInputValue13 >>> 16; - out[28 + outOffset] = curInputValue14 & mask; - out[29 + outOffset] = curInputValue14 >>> 16; - out[30 + outOffset] = curInputValue15 & mask; - out[31 + outOffset] = curInputValue15 >>> 16; - outOffset += 32; + static private void unpack16(int[] out, int[] in) { + int i, w; + int outOffset = 0; + final int mask = 65535; + for (i = 0, w = 1; i < 4; ++i, w += 16) { + int curInputValue0 = in[w]; + int curInputValue1 = in[w + 1]; + int curInputValue2 = in[w + 2]; + int curInputValue3 = in[w + 3]; + int curInputValue4 = in[w + 4]; + int curInputValue5 = in[w + 5]; + int curInputValue6 = in[w + 6]; + int curInputValue7 = in[w + 7]; + int curInputValue8 = in[w + 8]; + int curInputValue9 = in[w + 9]; + int curInputValue10 = in[w + 10]; + int curInputValue11 = in[w + 11]; + int curInputValue12 = in[w + 12]; + int curInputValue13 = in[w + 13]; + int curInputValue14 = in[w + 14]; + int curInputValue15 = in[w + 15]; + out[0 + outOffset] = curInputValue0 & mask; + out[1 + outOffset] = curInputValue0 >>> 16; + out[2 + outOffset] = curInputValue1 & mask; + out[3 + outOffset] = curInputValue1 >>> 16; + out[4 + outOffset] = curInputValue2 & mask; + out[5 + outOffset] = curInputValue2 >>> 16; + out[6 + outOffset] = curInputValue3 & mask; + out[7 + outOffset] = curInputValue3 >>> 16; + out[8 + outOffset] = curInputValue4 & mask; + out[9 + outOffset] = curInputValue4 >>> 16; + out[10 + outOffset] = curInputValue5 & mask; + out[11 + outOffset] = curInputValue5 >>> 16; + out[12 + outOffset] = curInputValue6 & mask; + out[13 + outOffset] = curInputValue6 >>> 16; + out[14 + outOffset] = curInputValue7 & mask; + out[15 + outOffset] = curInputValue7 >>> 16; + out[16 + outOffset] = curInputValue8 & mask; + out[17 + outOffset] = curInputValue8 >>> 16; + out[18 + outOffset] = curInputValue9 & mask; + out[19 + outOffset] = curInputValue9 >>> 16; + out[20 + outOffset] = curInputValue10 & mask; + out[21 + outOffset] = curInputValue10 >>> 16; + out[22 + outOffset] = curInputValue11 & mask; + out[23 + outOffset] = curInputValue11 >>> 16; + out[24 + outOffset] = curInputValue12 & mask; + out[25 + outOffset] = curInputValue12 >>> 16; + out[26 + outOffset] = curInputValue13 & mask; + out[27 + outOffset] = curInputValue13 >>> 16; + out[28 + outOffset] = curInputValue14 & mask; + out[29 + outOffset] = curInputValue14 >>> 16; + out[30 + outOffset] = curInputValue15 & mask; + out[31 + outOffset] = curInputValue15 >>> 16; + outOffset += 32; + } } - } - static private void unpack20(int[] out, int[] in) { - int i, w; - int outOffset = 0; - final int mask = 1048575; - for (i = 0, w = 1; i < 4; ++i, w += 20) { - int curInputValue0 = in[w]; - int curInputValue1 = in[w + 1]; - int curInputValue2 = in[w + 2]; - int curInputValue3 = in[w + 3]; - int curInputValue4 = in[w + 4]; - int curInputValue5 = in[w + 5]; - int curInputValue6 = in[w + 6]; - int curInputValue7 = in[w + 7]; - int curInputValue8 = in[w + 8]; - int curInputValue9 = in[w + 9]; - int curInputValue10 = in[w + 10]; - int curInputValue11 = in[w + 11]; - int curInputValue12 = in[w + 12]; - int curInputValue13 = in[w + 13]; - int curInputValue14 = in[w + 14]; - int curInputValue15 = in[w + 15]; - int curInputValue16 = in[w + 16]; - int curInputValue17 = in[w + 17]; - int curInputValue18 = in[w + 18]; - int curInputValue19 = in[w + 19]; - out[0 + outOffset] = curInputValue0 & mask; - out[1 + outOffset] = ((curInputValue0 >>> 20) | (curInputValue1 << 12)) & mask; - out[2 + outOffset] = (curInputValue1 >>> 8) & mask; - out[3 + outOffset] = ((curInputValue1 >>> 28) | (curInputValue2 << 4)) & mask; - out[4 + outOffset] = ((curInputValue2 >>> 16) | (curInputValue3 << 16)) & mask; - out[5 + outOffset] = (curInputValue3 >>> 4) & mask; - out[6 + outOffset] = ((curInputValue3 >>> 24) | (curInputValue4 << 8)) & mask; - out[7 + outOffset] = curInputValue4 >>> 12; - out[8 + outOffset] = curInputValue5 & mask; - out[9 + outOffset] = ((curInputValue5 >>> 20) | (curInputValue6 << 12)) & mask; - out[10 + outOffset] = (curInputValue6 >>> 8) & mask; - out[11 + outOffset] = ((curInputValue6 >>> 28) | (curInputValue7 << 4)) & mask; - out[12 + outOffset] = ((curInputValue7 >>> 16) | (curInputValue8 << 16)) & mask; - out[13 + outOffset] = (curInputValue8 >>> 4) & mask; - out[14 + outOffset] = ((curInputValue8 >>> 24) | (curInputValue9 << 8)) & mask; - out[15 + outOffset] = curInputValue9 >>> 12; - out[16 + outOffset] = curInputValue10 & mask; - out[17 + outOffset] = ((curInputValue10 >>> 20) | (curInputValue11 << 12)) & mask; - out[18 + outOffset] = (curInputValue11 >>> 8) & mask; - out[19 + outOffset] = ((curInputValue11 >>> 28) | (curInputValue12 << 4)) & mask; - out[20 + outOffset] = ((curInputValue12 >>> 16) | (curInputValue13 << 16)) & mask; - out[21 + outOffset] = (curInputValue13 >>> 4) & mask; - out[22 + outOffset] = ((curInputValue13 >>> 24) | (curInputValue14 << 8)) & mask; - out[23 + outOffset] = curInputValue14 >>> 12; - out[24 + outOffset] = curInputValue15 & mask; - out[25 + outOffset] = ((curInputValue15 >>> 20) | (curInputValue16 << 12)) & mask; - out[26 + outOffset] = (curInputValue16 >>> 8) & mask; - out[27 + outOffset] = ((curInputValue16 >>> 28) | (curInputValue17 << 4)) & mask; - out[28 + outOffset] = ((curInputValue17 >>> 16) | (curInputValue18 << 16)) & mask; - out[29 + outOffset] = (curInputValue18 >>> 4) & mask; - out[30 + outOffset] = ((curInputValue18 >>> 24) | (curInputValue19 << 8)) & mask; - out[31 + outOffset] = curInputValue19 >>> 12; - outOffset += 32; + static private void unpack20(int[] out, int[] in) { + int i, w; + int outOffset = 0; + final int mask = 1048575; + for (i = 0, w = 1; i < 4; ++i, w += 20) { + int curInputValue0 = in[w]; + int curInputValue1 = in[w + 1]; + int curInputValue2 = in[w + 2]; + int curInputValue3 = in[w + 3]; + int curInputValue4 = in[w + 4]; + int curInputValue5 = in[w + 5]; + int curInputValue6 = in[w + 6]; + int curInputValue7 = in[w + 7]; + int curInputValue8 = in[w + 8]; + int curInputValue9 = in[w + 9]; + int curInputValue10 = in[w + 10]; + int curInputValue11 = in[w + 11]; + int curInputValue12 = in[w + 12]; + int curInputValue13 = in[w + 13]; + int curInputValue14 = in[w + 14]; + int curInputValue15 = in[w + 15]; + int curInputValue16 = in[w + 16]; + int curInputValue17 = in[w + 17]; + int curInputValue18 = in[w + 18]; + int curInputValue19 = in[w + 19]; + out[0 + outOffset] = curInputValue0 & mask; + out[1 + outOffset] = ((curInputValue0 >>> 20) | (curInputValue1 << 12)) + & mask; + out[2 + outOffset] = (curInputValue1 >>> 8) & mask; + out[3 + outOffset] = ((curInputValue1 >>> 28) | (curInputValue2 << 4)) + & mask; + out[4 + outOffset] = ((curInputValue2 >>> 16) | (curInputValue3 << 16)) + & mask; + out[5 + outOffset] = (curInputValue3 >>> 4) & mask; + out[6 + outOffset] = ((curInputValue3 >>> 24) | (curInputValue4 << 8)) + & mask; + out[7 + outOffset] = curInputValue4 >>> 12; + out[8 + outOffset] = curInputValue5 & mask; + out[9 + outOffset] = ((curInputValue5 >>> 20) | (curInputValue6 << 12)) + & mask; + out[10 + outOffset] = (curInputValue6 >>> 8) & mask; + out[11 + outOffset] = ((curInputValue6 >>> 28) | (curInputValue7 << 4)) + & mask; + out[12 + outOffset] = ((curInputValue7 >>> 16) | (curInputValue8 << 16)) + & mask; + out[13 + outOffset] = (curInputValue8 >>> 4) & mask; + out[14 + outOffset] = ((curInputValue8 >>> 24) | (curInputValue9 << 8)) + & mask; + out[15 + outOffset] = curInputValue9 >>> 12; + out[16 + outOffset] = curInputValue10 & mask; + out[17 + outOffset] = ((curInputValue10 >>> 20) | (curInputValue11 << 12)) + & mask; + out[18 + outOffset] = (curInputValue11 >>> 8) & mask; + out[19 + outOffset] = ((curInputValue11 >>> 28) | (curInputValue12 << 4)) + & mask; + out[20 + outOffset] = ((curInputValue12 >>> 16) | (curInputValue13 << 16)) + & mask; + out[21 + outOffset] = (curInputValue13 >>> 4) & mask; + out[22 + outOffset] = ((curInputValue13 >>> 24) | (curInputValue14 << 8)) + & mask; + out[23 + outOffset] = curInputValue14 >>> 12; + out[24 + outOffset] = curInputValue15 & mask; + out[25 + outOffset] = ((curInputValue15 >>> 20) | (curInputValue16 << 12)) + & mask; + out[26 + outOffset] = (curInputValue16 >>> 8) & mask; + out[27 + outOffset] = ((curInputValue16 >>> 28) | (curInputValue17 << 4)) + & mask; + out[28 + outOffset] = ((curInputValue17 >>> 16) | (curInputValue18 << 16)) + & mask; + out[29 + outOffset] = (curInputValue18 >>> 4) & mask; + out[30 + outOffset] = ((curInputValue18 >>> 24) | (curInputValue19 << 8)) + & mask; + out[31 + outOffset] = curInputValue19 >>> 12; + outOffset += 32; + } } - } - static private void unpack28(int[] out, int[] in) { - int i, w; - int outOffset = 0; - final int mask = 268435455; - for (i = 0, w = 1; i < 4; ++i, w += 28) { - int curInputValue0 = in[w]; - int curInputValue1 = in[w + 1]; - int curInputValue2 = in[w + 2]; - int curInputValue3 = in[w + 3]; - int curInputValue4 = in[w + 4]; - int curInputValue5 = in[w + 5]; - int curInputValue6 = in[w + 6]; - int curInputValue7 = in[w + 7]; - int curInputValue8 = in[w + 8]; - int curInputValue9 = in[w + 9]; - int curInputValue10 = in[w + 10]; - int curInputValue11 = in[w + 11]; - int curInputValue12 = in[w + 12]; - int curInputValue13 = in[w + 13]; - int curInputValue14 = in[w + 14]; - int curInputValue15 = in[w + 15]; - int curInputValue16 = in[w + 16]; - int curInputValue17 = in[w + 17]; - int curInputValue18 = in[w + 18]; - int curInputValue19 = in[w + 19]; - int curInputValue20 = in[w + 20]; - int curInputValue21 = in[w + 21]; - int curInputValue22 = in[w + 22]; - int curInputValue23 = in[w + 23]; - int curInputValue24 = in[w + 24]; - int curInputValue25 = in[w + 25]; - int curInputValue26 = in[w + 26]; - int curInputValue27 = in[w + 27]; - out[0 + outOffset] = curInputValue0 & mask; - out[1 + outOffset] = ((curInputValue0 >>> 28) | (curInputValue1 << 4)) & mask; - out[2 + outOffset] = ((curInputValue1 >>> 24) | (curInputValue2 << 8)) & mask; - out[3 + outOffset] = ((curInputValue2 >>> 20) | (curInputValue3 << 12)) & mask; - out[4 + outOffset] = ((curInputValue3 >>> 16) | (curInputValue4 << 16)) & mask; - out[5 + outOffset] = ((curInputValue4 >>> 12) | (curInputValue5 << 20)) & mask; - out[6 + outOffset] = ((curInputValue5 >>> 8) | (curInputValue6 << 24)) & mask; - out[7 + outOffset] = curInputValue6 >>> 4; - out[8 + outOffset] = curInputValue7 & mask; - out[9 + outOffset] = ((curInputValue7 >>> 28) | (curInputValue8 << 4)) & mask; - out[10 + outOffset] = ((curInputValue8 >>> 24) | (curInputValue9 << 8)) & mask; - out[11 + outOffset] = ((curInputValue9 >>> 20) | (curInputValue10 << 12)) & mask; - out[12 + outOffset] = ((curInputValue10 >>> 16) | (curInputValue11 << 16)) & mask; - out[13 + outOffset] = ((curInputValue11 >>> 12) | (curInputValue12 << 20)) & mask; - out[14 + outOffset] = ((curInputValue12 >>> 8) | (curInputValue13 << 24)) & mask; - out[15 + outOffset] = curInputValue13 >>> 4; - out[16 + outOffset] = curInputValue14 & mask; - out[17 + outOffset] = ((curInputValue14 >>> 28) | (curInputValue15 << 4)) & mask; - out[18 + outOffset] = ((curInputValue15 >>> 24) | (curInputValue16 << 8)) & mask; - out[19 + outOffset] = ((curInputValue16 >>> 20) | (curInputValue17 << 12)) & mask; - out[20 + outOffset] = ((curInputValue17 >>> 16) | (curInputValue18 << 16)) & mask; - out[21 + outOffset] = ((curInputValue18 >>> 12) | (curInputValue19 << 20)) & mask; - out[22 + outOffset] = ((curInputValue19 >>> 8) | (curInputValue20 << 24)) & mask; - out[23 + outOffset] = curInputValue20 >>> 4; - out[24 + outOffset] = curInputValue21 & mask; - out[25 + outOffset] = ((curInputValue21 >>> 28) | (curInputValue22 << 4)) & mask; - out[26 + outOffset] = ((curInputValue22 >>> 24) | (curInputValue23 << 8)) & mask; - out[27 + outOffset] = ((curInputValue23 >>> 20) | (curInputValue24 << 12)) & mask; - out[28 + outOffset] = ((curInputValue24 >>> 16) | (curInputValue25 << 16)) & mask; - out[29 + outOffset] = ((curInputValue25 >>> 12) | (curInputValue26 << 20)) & mask; - out[30 + outOffset] = ((curInputValue26 >>> 8) | (curInputValue27 << 24)) & mask; - out[31 + outOffset] = curInputValue27 >>> 4; - outOffset += 32; + static private void unpack28(int[] out, int[] in) { + int i, w; + int outOffset = 0; + final int mask = 268435455; + for (i = 0, w = 1; i < 4; ++i, w += 28) { + int curInputValue0 = in[w]; + int curInputValue1 = in[w + 1]; + int curInputValue2 = in[w + 2]; + int curInputValue3 = in[w + 3]; + int curInputValue4 = in[w + 4]; + int curInputValue5 = in[w + 5]; + int curInputValue6 = in[w + 6]; + int curInputValue7 = in[w + 7]; + int curInputValue8 = in[w + 8]; + int curInputValue9 = in[w + 9]; + int curInputValue10 = in[w + 10]; + int curInputValue11 = in[w + 11]; + int curInputValue12 = in[w + 12]; + int curInputValue13 = in[w + 13]; + int curInputValue14 = in[w + 14]; + int curInputValue15 = in[w + 15]; + int curInputValue16 = in[w + 16]; + int curInputValue17 = in[w + 17]; + int curInputValue18 = in[w + 18]; + int curInputValue19 = in[w + 19]; + int curInputValue20 = in[w + 20]; + int curInputValue21 = in[w + 21]; + int curInputValue22 = in[w + 22]; + int curInputValue23 = in[w + 23]; + int curInputValue24 = in[w + 24]; + int curInputValue25 = in[w + 25]; + int curInputValue26 = in[w + 26]; + int curInputValue27 = in[w + 27]; + out[0 + outOffset] = curInputValue0 & mask; + out[1 + outOffset] = ((curInputValue0 >>> 28) | (curInputValue1 << 4)) + & mask; + out[2 + outOffset] = ((curInputValue1 >>> 24) | (curInputValue2 << 8)) + & mask; + out[3 + outOffset] = ((curInputValue2 >>> 20) | (curInputValue3 << 12)) + & mask; + out[4 + outOffset] = ((curInputValue3 >>> 16) | (curInputValue4 << 16)) + & mask; + out[5 + outOffset] = ((curInputValue4 >>> 12) | (curInputValue5 << 20)) + & mask; + out[6 + outOffset] = ((curInputValue5 >>> 8) | (curInputValue6 << 24)) + & mask; + out[7 + outOffset] = curInputValue6 >>> 4; + out[8 + outOffset] = curInputValue7 & mask; + out[9 + outOffset] = ((curInputValue7 >>> 28) | (curInputValue8 << 4)) + & mask; + out[10 + outOffset] = ((curInputValue8 >>> 24) | (curInputValue9 << 8)) + & mask; + out[11 + outOffset] = ((curInputValue9 >>> 20) | (curInputValue10 << 12)) + & mask; + out[12 + outOffset] = ((curInputValue10 >>> 16) | (curInputValue11 << 16)) + & mask; + out[13 + outOffset] = ((curInputValue11 >>> 12) | (curInputValue12 << 20)) + & mask; + out[14 + outOffset] = ((curInputValue12 >>> 8) | (curInputValue13 << 24)) + & mask; + out[15 + outOffset] = curInputValue13 >>> 4; + out[16 + outOffset] = curInputValue14 & mask; + out[17 + outOffset] = ((curInputValue14 >>> 28) | (curInputValue15 << 4)) + & mask; + out[18 + outOffset] = ((curInputValue15 >>> 24) | (curInputValue16 << 8)) + & mask; + out[19 + outOffset] = ((curInputValue16 >>> 20) | (curInputValue17 << 12)) + & mask; + out[20 + outOffset] = ((curInputValue17 >>> 16) | (curInputValue18 << 16)) + & mask; + out[21 + outOffset] = ((curInputValue18 >>> 12) | (curInputValue19 << 20)) + & mask; + out[22 + outOffset] = ((curInputValue19 >>> 8) | (curInputValue20 << 24)) + & mask; + out[23 + outOffset] = curInputValue20 >>> 4; + out[24 + outOffset] = curInputValue21 & mask; + out[25 + outOffset] = ((curInputValue21 >>> 28) | (curInputValue22 << 4)) + & mask; + out[26 + outOffset] = ((curInputValue22 >>> 24) | (curInputValue23 << 8)) + & mask; + out[27 + outOffset] = ((curInputValue23 >>> 20) | (curInputValue24 << 12)) + & mask; + out[28 + outOffset] = ((curInputValue24 >>> 16) | (curInputValue25 << 16)) + & mask; + out[29 + outOffset] = ((curInputValue25 >>> 12) | (curInputValue26 << 20)) + & mask; + out[30 + outOffset] = ((curInputValue26 >>> 8) | (curInputValue27 << 24)) + & mask; + out[31 + outOffset] = curInputValue27 >>> 4; + outOffset += 32; + } } - } } diff --git a/src/main/java/com/kamikaze/pfordelta/PForDeltaUnpack128WIthIntBuffer.java b/src/main/java/com/kamikaze/pfordelta/PForDeltaUnpack128WIthIntBuffer.java index 1d1cebb..4b7a483 100644 --- a/src/main/java/com/kamikaze/pfordelta/PForDeltaUnpack128WIthIntBuffer.java +++ b/src/main/java/com/kamikaze/pfordelta/PForDeltaUnpack128WIthIntBuffer.java @@ -1,6 +1,5 @@ package com.kamikaze.pfordelta; - /** * This is a version of the kamikaze PForDelta library that * was slightly cleaned up by D. Lemire. It is included in the @@ -10,864 +9,966 @@ import java.nio.IntBuffer; /** - * PForDeltaUnpack128WIthIntBuffer is almost the same as PForDeltaUnpack128, except that it use IntBuffer as input instead of int[]. + * PForDeltaUnpack128WIthIntBuffer is almost the same as PForDeltaUnpack128, + * except that it use IntBuffer as input instead of int[]. */ -@SuppressWarnings("javadoc") public class PForDeltaUnpack128WIthIntBuffer { - static public void unpack(int[] out, IntBuffer in, int bits) { - switch (bits) { - case 0: - unpack0(out, in); - break; - case 1: - unpack1(out, in); - break; - case 2: - unpack2(out, in); - break; - case 3: - unpack3(out, in); - break; - case 4: - unpack4(out, in); - break; - case 5: - unpack5(out, in); - break; - case 6: - unpack6(out, in); - break; - case 7: - unpack7(out, in); - break; - case 8: - unpack8(out, in); - break; - case 9: - unpack9(out, in); - break; - case 10: - unpack10(out, in); - break; - case 11: - unpack11(out, in); - break; - case 12: - unpack12(out, in); - break; - case 13: - unpack13(out, in); - break; - case 16: - unpack16(out, in); - break; - case 20: - unpack20(out, in); - break; - case 28: - unpack28(out, in); - break; - default: - break; + static protected void unpack(int[] out, IntBuffer in, int bits) { + switch (bits) { + case 0: + unpack0(out, in); + break; + case 1: + unpack1(out, in); + break; + case 2: + unpack2(out, in); + break; + case 3: + unpack3(out, in); + break; + case 4: + unpack4(out, in); + break; + case 5: + unpack5(out, in); + break; + case 6: + unpack6(out, in); + break; + case 7: + unpack7(out, in); + break; + case 8: + unpack8(out, in); + break; + case 9: + unpack9(out, in); + break; + case 10: + unpack10(out, in); + break; + case 11: + unpack11(out, in); + break; + case 12: + unpack12(out, in); + break; + case 13: + unpack13(out, in); + break; + case 16: + unpack16(out, in); + break; + case 20: + unpack20(out, in); + break; + case 28: + unpack28(out, in); + break; + default: + break; + } } - } - static private void unpack0(int[] out, IntBuffer in) { - } + static private void unpack0(int[] out, IntBuffer in) { + } - static private void unpack1(int[] out, IntBuffer in) { - int outOffset = 0; - final int mask = 1; - for (int i = 0; i < 4; ++i) { - int curInputValue0 = in.get(); - out[0 + outOffset] = curInputValue0 & mask; - out[1 + outOffset] = (curInputValue0 >>> 1) & mask; - out[2 + outOffset] = (curInputValue0 >>> 2) & mask; - out[3 + outOffset] = (curInputValue0 >>> 3) & mask; - out[4 + outOffset] = (curInputValue0 >>> 4) & mask; - out[5 + outOffset] = (curInputValue0 >>> 5) & mask; - out[6 + outOffset] = (curInputValue0 >>> 6) & mask; - out[7 + outOffset] = (curInputValue0 >>> 7) & mask; - out[8 + outOffset] = (curInputValue0 >>> 8) & mask; - out[9 + outOffset] = (curInputValue0 >>> 9) & mask; - out[10 + outOffset] = (curInputValue0 >>> 10) & mask; - out[11 + outOffset] = (curInputValue0 >>> 11) & mask; - out[12 + outOffset] = (curInputValue0 >>> 12) & mask; - out[13 + outOffset] = (curInputValue0 >>> 13) & mask; - out[14 + outOffset] = (curInputValue0 >>> 14) & mask; - out[15 + outOffset] = (curInputValue0 >>> 15) & mask; - out[16 + outOffset] = (curInputValue0 >>> 16) & mask; - out[17 + outOffset] = (curInputValue0 >>> 17) & mask; - out[18 + outOffset] = (curInputValue0 >>> 18) & mask; - out[19 + outOffset] = (curInputValue0 >>> 19) & mask; - out[20 + outOffset] = (curInputValue0 >>> 20) & mask; - out[21 + outOffset] = (curInputValue0 >>> 21) & mask; - out[22 + outOffset] = (curInputValue0 >>> 22) & mask; - out[23 + outOffset] = (curInputValue0 >>> 23) & mask; - out[24 + outOffset] = (curInputValue0 >>> 24) & mask; - out[25 + outOffset] = (curInputValue0 >>> 25) & mask; - out[26 + outOffset] = (curInputValue0 >>> 26) & mask; - out[27 + outOffset] = (curInputValue0 >>> 27) & mask; - out[28 + outOffset] = (curInputValue0 >>> 28) & mask; - out[29 + outOffset] = (curInputValue0 >>> 29) & mask; - out[30 + outOffset] = (curInputValue0 >>> 30) & mask; - out[31 + outOffset] = curInputValue0 >>> 31; - outOffset += 32; + static private void unpack1(int[] out, IntBuffer in) { + int outOffset = 0; + final int mask = 1; + for (int i = 0; i < 4; ++i) { + int curInputValue0 = in.get(); + out[0 + outOffset] = curInputValue0 & mask; + out[1 + outOffset] = (curInputValue0 >>> 1) & mask; + out[2 + outOffset] = (curInputValue0 >>> 2) & mask; + out[3 + outOffset] = (curInputValue0 >>> 3) & mask; + out[4 + outOffset] = (curInputValue0 >>> 4) & mask; + out[5 + outOffset] = (curInputValue0 >>> 5) & mask; + out[6 + outOffset] = (curInputValue0 >>> 6) & mask; + out[7 + outOffset] = (curInputValue0 >>> 7) & mask; + out[8 + outOffset] = (curInputValue0 >>> 8) & mask; + out[9 + outOffset] = (curInputValue0 >>> 9) & mask; + out[10 + outOffset] = (curInputValue0 >>> 10) & mask; + out[11 + outOffset] = (curInputValue0 >>> 11) & mask; + out[12 + outOffset] = (curInputValue0 >>> 12) & mask; + out[13 + outOffset] = (curInputValue0 >>> 13) & mask; + out[14 + outOffset] = (curInputValue0 >>> 14) & mask; + out[15 + outOffset] = (curInputValue0 >>> 15) & mask; + out[16 + outOffset] = (curInputValue0 >>> 16) & mask; + out[17 + outOffset] = (curInputValue0 >>> 17) & mask; + out[18 + outOffset] = (curInputValue0 >>> 18) & mask; + out[19 + outOffset] = (curInputValue0 >>> 19) & mask; + out[20 + outOffset] = (curInputValue0 >>> 20) & mask; + out[21 + outOffset] = (curInputValue0 >>> 21) & mask; + out[22 + outOffset] = (curInputValue0 >>> 22) & mask; + out[23 + outOffset] = (curInputValue0 >>> 23) & mask; + out[24 + outOffset] = (curInputValue0 >>> 24) & mask; + out[25 + outOffset] = (curInputValue0 >>> 25) & mask; + out[26 + outOffset] = (curInputValue0 >>> 26) & mask; + out[27 + outOffset] = (curInputValue0 >>> 27) & mask; + out[28 + outOffset] = (curInputValue0 >>> 28) & mask; + out[29 + outOffset] = (curInputValue0 >>> 29) & mask; + out[30 + outOffset] = (curInputValue0 >>> 30) & mask; + out[31 + outOffset] = curInputValue0 >>> 31; + outOffset += 32; + } } - } - static private void unpack2(int[] out, IntBuffer in) { - int outOffset = 0; - final int mask = 3; - for (int i = 0; i < 4; ++i) { - int curInputValue0 = in.get(); - int curInputValue1 = in.get(); - out[0 + outOffset] = curInputValue0 & mask; - out[1 + outOffset] = (curInputValue0 >>> 2) & mask; - out[2 + outOffset] = (curInputValue0 >>> 4) & mask; - out[3 + outOffset] = (curInputValue0 >>> 6) & mask; - out[4 + outOffset] = (curInputValue0 >>> 8) & mask; - out[5 + outOffset] = (curInputValue0 >>> 10) & mask; - out[6 + outOffset] = (curInputValue0 >>> 12) & mask; - out[7 + outOffset] = (curInputValue0 >>> 14) & mask; - out[8 + outOffset] = (curInputValue0 >>> 16) & mask; - out[9 + outOffset] = (curInputValue0 >>> 18) & mask; - out[10 + outOffset] = (curInputValue0 >>> 20) & mask; - out[11 + outOffset] = (curInputValue0 >>> 22) & mask; - out[12 + outOffset] = (curInputValue0 >>> 24) & mask; - out[13 + outOffset] = (curInputValue0 >>> 26) & mask; - out[14 + outOffset] = (curInputValue0 >>> 28) & mask; - out[15 + outOffset] = curInputValue0 >>> 30; - out[16 + outOffset] = curInputValue1 & mask; - out[17 + outOffset] = (curInputValue1 >>> 2) & mask; - out[18 + outOffset] = (curInputValue1 >>> 4) & mask; - out[19 + outOffset] = (curInputValue1 >>> 6) & mask; - out[20 + outOffset] = (curInputValue1 >>> 8) & mask; - out[21 + outOffset] = (curInputValue1 >>> 10) & mask; - out[22 + outOffset] = (curInputValue1 >>> 12) & mask; - out[23 + outOffset] = (curInputValue1 >>> 14) & mask; - out[24 + outOffset] = (curInputValue1 >>> 16) & mask; - out[25 + outOffset] = (curInputValue1 >>> 18) & mask; - out[26 + outOffset] = (curInputValue1 >>> 20) & mask; - out[27 + outOffset] = (curInputValue1 >>> 22) & mask; - out[28 + outOffset] = (curInputValue1 >>> 24) & mask; - out[29 + outOffset] = (curInputValue1 >>> 26) & mask; - out[30 + outOffset] = (curInputValue1 >>> 28) & mask; - out[31 + outOffset] = curInputValue1 >>> 30; - outOffset += 32; + static private void unpack2(int[] out, IntBuffer in) { + int outOffset = 0; + final int mask = 3; + for (int i = 0; i < 4; ++i) { + int curInputValue0 = in.get(); + int curInputValue1 = in.get(); + out[0 + outOffset] = curInputValue0 & mask; + out[1 + outOffset] = (curInputValue0 >>> 2) & mask; + out[2 + outOffset] = (curInputValue0 >>> 4) & mask; + out[3 + outOffset] = (curInputValue0 >>> 6) & mask; + out[4 + outOffset] = (curInputValue0 >>> 8) & mask; + out[5 + outOffset] = (curInputValue0 >>> 10) & mask; + out[6 + outOffset] = (curInputValue0 >>> 12) & mask; + out[7 + outOffset] = (curInputValue0 >>> 14) & mask; + out[8 + outOffset] = (curInputValue0 >>> 16) & mask; + out[9 + outOffset] = (curInputValue0 >>> 18) & mask; + out[10 + outOffset] = (curInputValue0 >>> 20) & mask; + out[11 + outOffset] = (curInputValue0 >>> 22) & mask; + out[12 + outOffset] = (curInputValue0 >>> 24) & mask; + out[13 + outOffset] = (curInputValue0 >>> 26) & mask; + out[14 + outOffset] = (curInputValue0 >>> 28) & mask; + out[15 + outOffset] = curInputValue0 >>> 30; + out[16 + outOffset] = curInputValue1 & mask; + out[17 + outOffset] = (curInputValue1 >>> 2) & mask; + out[18 + outOffset] = (curInputValue1 >>> 4) & mask; + out[19 + outOffset] = (curInputValue1 >>> 6) & mask; + out[20 + outOffset] = (curInputValue1 >>> 8) & mask; + out[21 + outOffset] = (curInputValue1 >>> 10) & mask; + out[22 + outOffset] = (curInputValue1 >>> 12) & mask; + out[23 + outOffset] = (curInputValue1 >>> 14) & mask; + out[24 + outOffset] = (curInputValue1 >>> 16) & mask; + out[25 + outOffset] = (curInputValue1 >>> 18) & mask; + out[26 + outOffset] = (curInputValue1 >>> 20) & mask; + out[27 + outOffset] = (curInputValue1 >>> 22) & mask; + out[28 + outOffset] = (curInputValue1 >>> 24) & mask; + out[29 + outOffset] = (curInputValue1 >>> 26) & mask; + out[30 + outOffset] = (curInputValue1 >>> 28) & mask; + out[31 + outOffset] = curInputValue1 >>> 30; + outOffset += 32; + } } - } - static private void unpack3(int[] out, IntBuffer in) { - int outOffset = 0; - final int mask = 7; - for (int i = 0; i < 4; ++i) { - int curInputValue0 = in.get(); - int curInputValue1 = in.get(); - int curInputValue2 = in.get(); - out[0 + outOffset] = curInputValue0 & mask; - out[1 + outOffset] = (curInputValue0 >>> 3) & mask; - out[2 + outOffset] = (curInputValue0 >>> 6) & mask; - out[3 + outOffset] = (curInputValue0 >>> 9) & mask; - out[4 + outOffset] = (curInputValue0 >>> 12) & mask; - out[5 + outOffset] = (curInputValue0 >>> 15) & mask; - out[6 + outOffset] = (curInputValue0 >>> 18) & mask; - out[7 + outOffset] = (curInputValue0 >>> 21) & mask; - out[8 + outOffset] = (curInputValue0 >>> 24) & mask; - out[9 + outOffset] = (curInputValue0 >>> 27) & mask; - out[10 + outOffset] = ((curInputValue0 >>> 30) | (curInputValue1 << 2)) & mask; - out[11 + outOffset] = (curInputValue1 >>> 1) & mask; - out[12 + outOffset] = (curInputValue1 >>> 4) & mask; - out[13 + outOffset] = (curInputValue1 >>> 7) & mask; - out[14 + outOffset] = (curInputValue1 >>> 10) & mask; - out[15 + outOffset] = (curInputValue1 >>> 13) & mask; - out[16 + outOffset] = (curInputValue1 >>> 16) & mask; - out[17 + outOffset] = (curInputValue1 >>> 19) & mask; - out[18 + outOffset] = (curInputValue1 >>> 22) & mask; - out[19 + outOffset] = (curInputValue1 >>> 25) & mask; - out[20 + outOffset] = (curInputValue1 >>> 28) & mask; - out[21 + outOffset] = ((curInputValue1 >>> 31) | (curInputValue2 << 1)) & mask; - out[22 + outOffset] = (curInputValue2 >>> 2) & mask; - out[23 + outOffset] = (curInputValue2 >>> 5) & mask; - out[24 + outOffset] = (curInputValue2 >>> 8) & mask; - out[25 + outOffset] = (curInputValue2 >>> 11) & mask; - out[26 + outOffset] = (curInputValue2 >>> 14) & mask; - out[27 + outOffset] = (curInputValue2 >>> 17) & mask; - out[28 + outOffset] = (curInputValue2 >>> 20) & mask; - out[29 + outOffset] = (curInputValue2 >>> 23) & mask; - out[30 + outOffset] = (curInputValue2 >>> 26) & mask; - out[31 + outOffset] = curInputValue2 >>> 29; - outOffset += 32; + static private void unpack3(int[] out, IntBuffer in) { + int outOffset = 0; + final int mask = 7; + for (int i = 0; i < 4; ++i) { + int curInputValue0 = in.get(); + int curInputValue1 = in.get(); + int curInputValue2 = in.get(); + out[0 + outOffset] = curInputValue0 & mask; + out[1 + outOffset] = (curInputValue0 >>> 3) & mask; + out[2 + outOffset] = (curInputValue0 >>> 6) & mask; + out[3 + outOffset] = (curInputValue0 >>> 9) & mask; + out[4 + outOffset] = (curInputValue0 >>> 12) & mask; + out[5 + outOffset] = (curInputValue0 >>> 15) & mask; + out[6 + outOffset] = (curInputValue0 >>> 18) & mask; + out[7 + outOffset] = (curInputValue0 >>> 21) & mask; + out[8 + outOffset] = (curInputValue0 >>> 24) & mask; + out[9 + outOffset] = (curInputValue0 >>> 27) & mask; + out[10 + outOffset] = ((curInputValue0 >>> 30) | (curInputValue1 << 2)) + & mask; + out[11 + outOffset] = (curInputValue1 >>> 1) & mask; + out[12 + outOffset] = (curInputValue1 >>> 4) & mask; + out[13 + outOffset] = (curInputValue1 >>> 7) & mask; + out[14 + outOffset] = (curInputValue1 >>> 10) & mask; + out[15 + outOffset] = (curInputValue1 >>> 13) & mask; + out[16 + outOffset] = (curInputValue1 >>> 16) & mask; + out[17 + outOffset] = (curInputValue1 >>> 19) & mask; + out[18 + outOffset] = (curInputValue1 >>> 22) & mask; + out[19 + outOffset] = (curInputValue1 >>> 25) & mask; + out[20 + outOffset] = (curInputValue1 >>> 28) & mask; + out[21 + outOffset] = ((curInputValue1 >>> 31) | (curInputValue2 << 1)) + & mask; + out[22 + outOffset] = (curInputValue2 >>> 2) & mask; + out[23 + outOffset] = (curInputValue2 >>> 5) & mask; + out[24 + outOffset] = (curInputValue2 >>> 8) & mask; + out[25 + outOffset] = (curInputValue2 >>> 11) & mask; + out[26 + outOffset] = (curInputValue2 >>> 14) & mask; + out[27 + outOffset] = (curInputValue2 >>> 17) & mask; + out[28 + outOffset] = (curInputValue2 >>> 20) & mask; + out[29 + outOffset] = (curInputValue2 >>> 23) & mask; + out[30 + outOffset] = (curInputValue2 >>> 26) & mask; + out[31 + outOffset] = curInputValue2 >>> 29; + outOffset += 32; + } } - } - static private void unpack4(int[] out, IntBuffer in) { - int outOffset = 0; - final int mask = 15; - for (int i = 0; i < 4; ++i) { - int curInputValue0 = in.get(); - int curInputValue1 = in.get(); - int curInputValue2 = in.get(); - int curInputValue3 = in.get(); - out[0 + outOffset] = curInputValue0 & mask; - out[1 + outOffset] = (curInputValue0 >>> 4) & mask; - out[2 + outOffset] = (curInputValue0 >>> 8) & mask; - out[3 + outOffset] = (curInputValue0 >>> 12) & mask; - out[4 + outOffset] = (curInputValue0 >>> 16) & mask; - out[5 + outOffset] = (curInputValue0 >>> 20) & mask; - out[6 + outOffset] = (curInputValue0 >>> 24) & mask; - out[7 + outOffset] = curInputValue0 >>> 28; - out[8 + outOffset] = curInputValue1 & mask; - out[9 + outOffset] = (curInputValue1 >>> 4) & mask; - out[10 + outOffset] = (curInputValue1 >>> 8) & mask; - out[11 + outOffset] = (curInputValue1 >>> 12) & mask; - out[12 + outOffset] = (curInputValue1 >>> 16) & mask; - out[13 + outOffset] = (curInputValue1 >>> 20) & mask; - out[14 + outOffset] = (curInputValue1 >>> 24) & mask; - out[15 + outOffset] = curInputValue1 >>> 28; - out[16 + outOffset] = curInputValue2 & mask; - out[17 + outOffset] = (curInputValue2 >>> 4) & mask; - out[18 + outOffset] = (curInputValue2 >>> 8) & mask; - out[19 + outOffset] = (curInputValue2 >>> 12) & mask; - out[20 + outOffset] = (curInputValue2 >>> 16) & mask; - out[21 + outOffset] = (curInputValue2 >>> 20) & mask; - out[22 + outOffset] = (curInputValue2 >>> 24) & mask; - out[23 + outOffset] = curInputValue2 >>> 28; - out[24 + outOffset] = curInputValue3 & mask; - out[25 + outOffset] = (curInputValue3 >>> 4) & mask; - out[26 + outOffset] = (curInputValue3 >>> 8) & mask; - out[27 + outOffset] = (curInputValue3 >>> 12) & mask; - out[28 + outOffset] = (curInputValue3 >>> 16) & mask; - out[29 + outOffset] = (curInputValue3 >>> 20) & mask; - out[30 + outOffset] = (curInputValue3 >>> 24) & mask; - out[31 + outOffset] = curInputValue3 >>> 28; - outOffset += 32; + static private void unpack4(int[] out, IntBuffer in) { + int outOffset = 0; + final int mask = 15; + for (int i = 0; i < 4; ++i) { + int curInputValue0 = in.get(); + int curInputValue1 = in.get(); + int curInputValue2 = in.get(); + int curInputValue3 = in.get(); + out[0 + outOffset] = curInputValue0 & mask; + out[1 + outOffset] = (curInputValue0 >>> 4) & mask; + out[2 + outOffset] = (curInputValue0 >>> 8) & mask; + out[3 + outOffset] = (curInputValue0 >>> 12) & mask; + out[4 + outOffset] = (curInputValue0 >>> 16) & mask; + out[5 + outOffset] = (curInputValue0 >>> 20) & mask; + out[6 + outOffset] = (curInputValue0 >>> 24) & mask; + out[7 + outOffset] = curInputValue0 >>> 28; + out[8 + outOffset] = curInputValue1 & mask; + out[9 + outOffset] = (curInputValue1 >>> 4) & mask; + out[10 + outOffset] = (curInputValue1 >>> 8) & mask; + out[11 + outOffset] = (curInputValue1 >>> 12) & mask; + out[12 + outOffset] = (curInputValue1 >>> 16) & mask; + out[13 + outOffset] = (curInputValue1 >>> 20) & mask; + out[14 + outOffset] = (curInputValue1 >>> 24) & mask; + out[15 + outOffset] = curInputValue1 >>> 28; + out[16 + outOffset] = curInputValue2 & mask; + out[17 + outOffset] = (curInputValue2 >>> 4) & mask; + out[18 + outOffset] = (curInputValue2 >>> 8) & mask; + out[19 + outOffset] = (curInputValue2 >>> 12) & mask; + out[20 + outOffset] = (curInputValue2 >>> 16) & mask; + out[21 + outOffset] = (curInputValue2 >>> 20) & mask; + out[22 + outOffset] = (curInputValue2 >>> 24) & mask; + out[23 + outOffset] = curInputValue2 >>> 28; + out[24 + outOffset] = curInputValue3 & mask; + out[25 + outOffset] = (curInputValue3 >>> 4) & mask; + out[26 + outOffset] = (curInputValue3 >>> 8) & mask; + out[27 + outOffset] = (curInputValue3 >>> 12) & mask; + out[28 + outOffset] = (curInputValue3 >>> 16) & mask; + out[29 + outOffset] = (curInputValue3 >>> 20) & mask; + out[30 + outOffset] = (curInputValue3 >>> 24) & mask; + out[31 + outOffset] = curInputValue3 >>> 28; + outOffset += 32; + } } - } - static private void unpack5(int[] out, IntBuffer in) { - int outOffset = 0; - final int mask = 31; - for (int i = 0; i < 4; ++i) { - int curInputValue0 = in.get(); - int curInputValue1 = in.get(); - int curInputValue2 = in.get(); - int curInputValue3 = in.get(); - int curInputValue4 = in.get(); - out[0 + outOffset] = curInputValue0 & mask; - out[1 + outOffset] = (curInputValue0 >>> 5) & mask; - out[2 + outOffset] = (curInputValue0 >>> 10) & mask; - out[3 + outOffset] = (curInputValue0 >>> 15) & mask; - out[4 + outOffset] = (curInputValue0 >>> 20) & mask; - out[5 + outOffset] = (curInputValue0 >>> 25) & mask; - out[6 + outOffset] = ((curInputValue0 >>> 30) | (curInputValue1 << 2)) & mask; - out[7 + outOffset] = (curInputValue1 >>> 3) & mask; - out[8 + outOffset] = (curInputValue1 >>> 8) & mask; - out[9 + outOffset] = (curInputValue1 >>> 13) & mask; - out[10 + outOffset] = (curInputValue1 >>> 18) & mask; - out[11 + outOffset] = (curInputValue1 >>> 23) & mask; - out[12 + outOffset] = ((curInputValue1 >>> 28) | (curInputValue2 << 4)) & mask; - out[13 + outOffset] = (curInputValue2 >>> 1) & mask; - out[14 + outOffset] = (curInputValue2 >>> 6) & mask; - out[15 + outOffset] = (curInputValue2 >>> 11) & mask; - out[16 + outOffset] = (curInputValue2 >>> 16) & mask; - out[17 + outOffset] = (curInputValue2 >>> 21) & mask; - out[18 + outOffset] = (curInputValue2 >>> 26) & mask; - out[19 + outOffset] = ((curInputValue2 >>> 31) | (curInputValue3 << 1)) & mask; - out[20 + outOffset] = (curInputValue3 >>> 4) & mask; - out[21 + outOffset] = (curInputValue3 >>> 9) & mask; - out[22 + outOffset] = (curInputValue3 >>> 14) & mask; - out[23 + outOffset] = (curInputValue3 >>> 19) & mask; - out[24 + outOffset] = (curInputValue3 >>> 24) & mask; - out[25 + outOffset] = ((curInputValue3 >>> 29) | (curInputValue4 << 3)) & mask; - out[26 + outOffset] = (curInputValue4 >>> 2) & mask; - out[27 + outOffset] = (curInputValue4 >>> 7) & mask; - out[28 + outOffset] = (curInputValue4 >>> 12) & mask; - out[29 + outOffset] = (curInputValue4 >>> 17) & mask; - out[30 + outOffset] = (curInputValue4 >>> 22) & mask; - out[31 + outOffset] = curInputValue4 >>> 27; - outOffset += 32; + static private void unpack5(int[] out, IntBuffer in) { + int outOffset = 0; + final int mask = 31; + for (int i = 0; i < 4; ++i) { + int curInputValue0 = in.get(); + int curInputValue1 = in.get(); + int curInputValue2 = in.get(); + int curInputValue3 = in.get(); + int curInputValue4 = in.get(); + out[0 + outOffset] = curInputValue0 & mask; + out[1 + outOffset] = (curInputValue0 >>> 5) & mask; + out[2 + outOffset] = (curInputValue0 >>> 10) & mask; + out[3 + outOffset] = (curInputValue0 >>> 15) & mask; + out[4 + outOffset] = (curInputValue0 >>> 20) & mask; + out[5 + outOffset] = (curInputValue0 >>> 25) & mask; + out[6 + outOffset] = ((curInputValue0 >>> 30) | (curInputValue1 << 2)) + & mask; + out[7 + outOffset] = (curInputValue1 >>> 3) & mask; + out[8 + outOffset] = (curInputValue1 >>> 8) & mask; + out[9 + outOffset] = (curInputValue1 >>> 13) & mask; + out[10 + outOffset] = (curInputValue1 >>> 18) & mask; + out[11 + outOffset] = (curInputValue1 >>> 23) & mask; + out[12 + outOffset] = ((curInputValue1 >>> 28) | (curInputValue2 << 4)) + & mask; + out[13 + outOffset] = (curInputValue2 >>> 1) & mask; + out[14 + outOffset] = (curInputValue2 >>> 6) & mask; + out[15 + outOffset] = (curInputValue2 >>> 11) & mask; + out[16 + outOffset] = (curInputValue2 >>> 16) & mask; + out[17 + outOffset] = (curInputValue2 >>> 21) & mask; + out[18 + outOffset] = (curInputValue2 >>> 26) & mask; + out[19 + outOffset] = ((curInputValue2 >>> 31) | (curInputValue3 << 1)) + & mask; + out[20 + outOffset] = (curInputValue3 >>> 4) & mask; + out[21 + outOffset] = (curInputValue3 >>> 9) & mask; + out[22 + outOffset] = (curInputValue3 >>> 14) & mask; + out[23 + outOffset] = (curInputValue3 >>> 19) & mask; + out[24 + outOffset] = (curInputValue3 >>> 24) & mask; + out[25 + outOffset] = ((curInputValue3 >>> 29) | (curInputValue4 << 3)) + & mask; + out[26 + outOffset] = (curInputValue4 >>> 2) & mask; + out[27 + outOffset] = (curInputValue4 >>> 7) & mask; + out[28 + outOffset] = (curInputValue4 >>> 12) & mask; + out[29 + outOffset] = (curInputValue4 >>> 17) & mask; + out[30 + outOffset] = (curInputValue4 >>> 22) & mask; + out[31 + outOffset] = curInputValue4 >>> 27; + outOffset += 32; + } } - } - static private void unpack6(int[] out, IntBuffer in) { - int outOffset = 0; - final int mask = 63; - for (int i = 0; i < 4; ++i) { - int curInputValue0 = in.get(); - int curInputValue1 = in.get(); - int curInputValue2 = in.get(); - int curInputValue3 = in.get(); - int curInputValue4 = in.get(); - int curInputValue5 = in.get(); - out[0 + outOffset] = curInputValue0 & mask; - out[1 + outOffset] = (curInputValue0 >>> 6) & mask; - out[2 + outOffset] = (curInputValue0 >>> 12) & mask; - out[3 + outOffset] = (curInputValue0 >>> 18) & mask; - out[4 + outOffset] = (curInputValue0 >>> 24) & mask; - out[5 + outOffset] = ((curInputValue0 >>> 30) | (curInputValue1 << 2)) & mask; - out[6 + outOffset] = (curInputValue1 >>> 4) & mask; - out[7 + outOffset] = (curInputValue1 >>> 10) & mask; - out[8 + outOffset] = (curInputValue1 >>> 16) & mask; - out[9 + outOffset] = (curInputValue1 >>> 22) & mask; - out[10 + outOffset] = ((curInputValue1 >>> 28) | (curInputValue2 << 4)) & mask; - out[11 + outOffset] = (curInputValue2 >>> 2) & mask; - out[12 + outOffset] = (curInputValue2 >>> 8) & mask; - out[13 + outOffset] = (curInputValue2 >>> 14) & mask; - out[14 + outOffset] = (curInputValue2 >>> 20) & mask; - out[15 + outOffset] = curInputValue2 >>> 26; - out[16 + outOffset] = curInputValue3 & mask; - out[17 + outOffset] = (curInputValue3 >>> 6) & mask; - out[18 + outOffset] = (curInputValue3 >>> 12) & mask; - out[19 + outOffset] = (curInputValue3 >>> 18) & mask; - out[20 + outOffset] = (curInputValue3 >>> 24) & mask; - out[21 + outOffset] = ((curInputValue3 >>> 30) | (curInputValue4 << 2)) & mask; - out[22 + outOffset] = (curInputValue4 >>> 4) & mask; - out[23 + outOffset] = (curInputValue4 >>> 10) & mask; - out[24 + outOffset] = (curInputValue4 >>> 16) & mask; - out[25 + outOffset] = (curInputValue4 >>> 22) & mask; - out[26 + outOffset] = ((curInputValue4 >>> 28) | (curInputValue5 << 4)) & mask; - out[27 + outOffset] = (curInputValue5 >>> 2) & mask; - out[28 + outOffset] = (curInputValue5 >>> 8) & mask; - out[29 + outOffset] = (curInputValue5 >>> 14) & mask; - out[30 + outOffset] = (curInputValue5 >>> 20) & mask; - out[31 + outOffset] = curInputValue5 >>> 26; - outOffset += 32; + static private void unpack6(int[] out, IntBuffer in) { + int outOffset = 0; + final int mask = 63; + for (int i = 0; i < 4; ++i) { + int curInputValue0 = in.get(); + int curInputValue1 = in.get(); + int curInputValue2 = in.get(); + int curInputValue3 = in.get(); + int curInputValue4 = in.get(); + int curInputValue5 = in.get(); + out[0 + outOffset] = curInputValue0 & mask; + out[1 + outOffset] = (curInputValue0 >>> 6) & mask; + out[2 + outOffset] = (curInputValue0 >>> 12) & mask; + out[3 + outOffset] = (curInputValue0 >>> 18) & mask; + out[4 + outOffset] = (curInputValue0 >>> 24) & mask; + out[5 + outOffset] = ((curInputValue0 >>> 30) | (curInputValue1 << 2)) + & mask; + out[6 + outOffset] = (curInputValue1 >>> 4) & mask; + out[7 + outOffset] = (curInputValue1 >>> 10) & mask; + out[8 + outOffset] = (curInputValue1 >>> 16) & mask; + out[9 + outOffset] = (curInputValue1 >>> 22) & mask; + out[10 + outOffset] = ((curInputValue1 >>> 28) | (curInputValue2 << 4)) + & mask; + out[11 + outOffset] = (curInputValue2 >>> 2) & mask; + out[12 + outOffset] = (curInputValue2 >>> 8) & mask; + out[13 + outOffset] = (curInputValue2 >>> 14) & mask; + out[14 + outOffset] = (curInputValue2 >>> 20) & mask; + out[15 + outOffset] = curInputValue2 >>> 26; + out[16 + outOffset] = curInputValue3 & mask; + out[17 + outOffset] = (curInputValue3 >>> 6) & mask; + out[18 + outOffset] = (curInputValue3 >>> 12) & mask; + out[19 + outOffset] = (curInputValue3 >>> 18) & mask; + out[20 + outOffset] = (curInputValue3 >>> 24) & mask; + out[21 + outOffset] = ((curInputValue3 >>> 30) | (curInputValue4 << 2)) + & mask; + out[22 + outOffset] = (curInputValue4 >>> 4) & mask; + out[23 + outOffset] = (curInputValue4 >>> 10) & mask; + out[24 + outOffset] = (curInputValue4 >>> 16) & mask; + out[25 + outOffset] = (curInputValue4 >>> 22) & mask; + out[26 + outOffset] = ((curInputValue4 >>> 28) | (curInputValue5 << 4)) + & mask; + out[27 + outOffset] = (curInputValue5 >>> 2) & mask; + out[28 + outOffset] = (curInputValue5 >>> 8) & mask; + out[29 + outOffset] = (curInputValue5 >>> 14) & mask; + out[30 + outOffset] = (curInputValue5 >>> 20) & mask; + out[31 + outOffset] = curInputValue5 >>> 26; + outOffset += 32; + } } - } - static private void unpack7(int[] out, IntBuffer in) { - int outOffset = 0; - final int mask = 127; - for (int i = 0; i < 4; ++i) { - int curInputValue0 = in.get(); - int curInputValue1 = in.get(); - int curInputValue2 = in.get(); - int curInputValue3 = in.get(); - int curInputValue4 = in.get(); - int curInputValue5 = in.get(); - int curInputValue6 = in.get(); - out[0 + outOffset] = curInputValue0 & mask; - out[1 + outOffset] = (curInputValue0 >>> 7) & mask; - out[2 + outOffset] = (curInputValue0 >>> 14) & mask; - out[3 + outOffset] = (curInputValue0 >>> 21) & mask; - out[4 + outOffset] = ((curInputValue0 >>> 28) | (curInputValue1 << 4)) & mask; - out[5 + outOffset] = (curInputValue1 >>> 3) & mask; - out[6 + outOffset] = (curInputValue1 >>> 10) & mask; - out[7 + outOffset] = (curInputValue1 >>> 17) & mask; - out[8 + outOffset] = (curInputValue1 >>> 24) & mask; - out[9 + outOffset] = ((curInputValue1 >>> 31) | (curInputValue2 << 1)) & mask; - out[10 + outOffset] = (curInputValue2 >>> 6) & mask; - out[11 + outOffset] = (curInputValue2 >>> 13) & mask; - out[12 + outOffset] = (curInputValue2 >>> 20) & mask; - out[13 + outOffset] = ((curInputValue2 >>> 27) | (curInputValue3 << 5)) & mask; - out[14 + outOffset] = (curInputValue3 >>> 2) & mask; - out[15 + outOffset] = (curInputValue3 >>> 9) & mask; - out[16 + outOffset] = (curInputValue3 >>> 16) & mask; - out[17 + outOffset] = (curInputValue3 >>> 23) & mask; - out[18 + outOffset] = ((curInputValue3 >>> 30) | (curInputValue4 << 2)) & mask; - out[19 + outOffset] = (curInputValue4 >>> 5) & mask; - out[20 + outOffset] = (curInputValue4 >>> 12) & mask; - out[21 + outOffset] = (curInputValue4 >>> 19) & mask; - out[22 + outOffset] = ((curInputValue4 >>> 26) | (curInputValue5 << 6)) & mask; - out[23 + outOffset] = (curInputValue5 >>> 1) & mask; - out[24 + outOffset] = (curInputValue5 >>> 8) & mask; - out[25 + outOffset] = (curInputValue5 >>> 15) & mask; - out[26 + outOffset] = (curInputValue5 >>> 22) & mask; - out[27 + outOffset] = ((curInputValue5 >>> 29) | (curInputValue6 << 3)) & mask; - out[28 + outOffset] = (curInputValue6 >>> 4) & mask; - out[29 + outOffset] = (curInputValue6 >>> 11) & mask; - out[30 + outOffset] = (curInputValue6 >>> 18) & mask; - out[31 + outOffset] = curInputValue6 >>> 25; - outOffset += 32; + static private void unpack7(int[] out, IntBuffer in) { + int outOffset = 0; + final int mask = 127; + for (int i = 0; i < 4; ++i) { + int curInputValue0 = in.get(); + int curInputValue1 = in.get(); + int curInputValue2 = in.get(); + int curInputValue3 = in.get(); + int curInputValue4 = in.get(); + int curInputValue5 = in.get(); + int curInputValue6 = in.get(); + out[0 + outOffset] = curInputValue0 & mask; + out[1 + outOffset] = (curInputValue0 >>> 7) & mask; + out[2 + outOffset] = (curInputValue0 >>> 14) & mask; + out[3 + outOffset] = (curInputValue0 >>> 21) & mask; + out[4 + outOffset] = ((curInputValue0 >>> 28) | (curInputValue1 << 4)) + & mask; + out[5 + outOffset] = (curInputValue1 >>> 3) & mask; + out[6 + outOffset] = (curInputValue1 >>> 10) & mask; + out[7 + outOffset] = (curInputValue1 >>> 17) & mask; + out[8 + outOffset] = (curInputValue1 >>> 24) & mask; + out[9 + outOffset] = ((curInputValue1 >>> 31) | (curInputValue2 << 1)) + & mask; + out[10 + outOffset] = (curInputValue2 >>> 6) & mask; + out[11 + outOffset] = (curInputValue2 >>> 13) & mask; + out[12 + outOffset] = (curInputValue2 >>> 20) & mask; + out[13 + outOffset] = ((curInputValue2 >>> 27) | (curInputValue3 << 5)) + & mask; + out[14 + outOffset] = (curInputValue3 >>> 2) & mask; + out[15 + outOffset] = (curInputValue3 >>> 9) & mask; + out[16 + outOffset] = (curInputValue3 >>> 16) & mask; + out[17 + outOffset] = (curInputValue3 >>> 23) & mask; + out[18 + outOffset] = ((curInputValue3 >>> 30) | (curInputValue4 << 2)) + & mask; + out[19 + outOffset] = (curInputValue4 >>> 5) & mask; + out[20 + outOffset] = (curInputValue4 >>> 12) & mask; + out[21 + outOffset] = (curInputValue4 >>> 19) & mask; + out[22 + outOffset] = ((curInputValue4 >>> 26) | (curInputValue5 << 6)) + & mask; + out[23 + outOffset] = (curInputValue5 >>> 1) & mask; + out[24 + outOffset] = (curInputValue5 >>> 8) & mask; + out[25 + outOffset] = (curInputValue5 >>> 15) & mask; + out[26 + outOffset] = (curInputValue5 >>> 22) & mask; + out[27 + outOffset] = ((curInputValue5 >>> 29) | (curInputValue6 << 3)) + & mask; + out[28 + outOffset] = (curInputValue6 >>> 4) & mask; + out[29 + outOffset] = (curInputValue6 >>> 11) & mask; + out[30 + outOffset] = (curInputValue6 >>> 18) & mask; + out[31 + outOffset] = curInputValue6 >>> 25; + outOffset += 32; + } } - } - static private void unpack8(int[] out, IntBuffer in) { - int outOffset = 0; - final int mask = 255; - for (int i = 0; i < 4; ++i) { - int curInputValue0 = in.get(); - int curInputValue1 = in.get(); - int curInputValue2 = in.get(); - int curInputValue3 = in.get(); - int curInputValue4 = in.get(); - int curInputValue5 = in.get(); - int curInputValue6 = in.get(); - int curInputValue7 = in.get(); - out[0 + outOffset] = curInputValue0 & mask; - out[1 + outOffset] = (curInputValue0 >>> 8) & mask; - out[2 + outOffset] = (curInputValue0 >>> 16) & mask; - out[3 + outOffset] = curInputValue0 >>> 24; - out[4 + outOffset] = curInputValue1 & mask; - out[5 + outOffset] = (curInputValue1 >>> 8) & mask; - out[6 + outOffset] = (curInputValue1 >>> 16) & mask; - out[7 + outOffset] = curInputValue1 >>> 24; - out[8 + outOffset] = curInputValue2 & mask; - out[9 + outOffset] = (curInputValue2 >>> 8) & mask; - out[10 + outOffset] = (curInputValue2 >>> 16) & mask; - out[11 + outOffset] = curInputValue2 >>> 24; - out[12 + outOffset] = curInputValue3 & mask; - out[13 + outOffset] = (curInputValue3 >>> 8) & mask; - out[14 + outOffset] = (curInputValue3 >>> 16) & mask; - out[15 + outOffset] = curInputValue3 >>> 24; - out[16 + outOffset] = curInputValue4 & mask; - out[17 + outOffset] = (curInputValue4 >>> 8) & mask; - out[18 + outOffset] = (curInputValue4 >>> 16) & mask; - out[19 + outOffset] = curInputValue4 >>> 24; - out[20 + outOffset] = curInputValue5 & mask; - out[21 + outOffset] = (curInputValue5 >>> 8) & mask; - out[22 + outOffset] = (curInputValue5 >>> 16) & mask; - out[23 + outOffset] = curInputValue5 >>> 24; - out[24 + outOffset] = curInputValue6 & mask; - out[25 + outOffset] = (curInputValue6 >>> 8) & mask; - out[26 + outOffset] = (curInputValue6 >>> 16) & mask; - out[27 + outOffset] = curInputValue6 >>> 24; - out[28 + outOffset] = curInputValue7 & mask; - out[29 + outOffset] = (curInputValue7 >>> 8) & mask; - out[30 + outOffset] = (curInputValue7 >>> 16) & mask; - out[31 + outOffset] = curInputValue7 >>> 24; - outOffset += 32; + static private void unpack8(int[] out, IntBuffer in) { + int outOffset = 0; + final int mask = 255; + for (int i = 0; i < 4; ++i) { + int curInputValue0 = in.get(); + int curInputValue1 = in.get(); + int curInputValue2 = in.get(); + int curInputValue3 = in.get(); + int curInputValue4 = in.get(); + int curInputValue5 = in.get(); + int curInputValue6 = in.get(); + int curInputValue7 = in.get(); + out[0 + outOffset] = curInputValue0 & mask; + out[1 + outOffset] = (curInputValue0 >>> 8) & mask; + out[2 + outOffset] = (curInputValue0 >>> 16) & mask; + out[3 + outOffset] = curInputValue0 >>> 24; + out[4 + outOffset] = curInputValue1 & mask; + out[5 + outOffset] = (curInputValue1 >>> 8) & mask; + out[6 + outOffset] = (curInputValue1 >>> 16) & mask; + out[7 + outOffset] = curInputValue1 >>> 24; + out[8 + outOffset] = curInputValue2 & mask; + out[9 + outOffset] = (curInputValue2 >>> 8) & mask; + out[10 + outOffset] = (curInputValue2 >>> 16) & mask; + out[11 + outOffset] = curInputValue2 >>> 24; + out[12 + outOffset] = curInputValue3 & mask; + out[13 + outOffset] = (curInputValue3 >>> 8) & mask; + out[14 + outOffset] = (curInputValue3 >>> 16) & mask; + out[15 + outOffset] = curInputValue3 >>> 24; + out[16 + outOffset] = curInputValue4 & mask; + out[17 + outOffset] = (curInputValue4 >>> 8) & mask; + out[18 + outOffset] = (curInputValue4 >>> 16) & mask; + out[19 + outOffset] = curInputValue4 >>> 24; + out[20 + outOffset] = curInputValue5 & mask; + out[21 + outOffset] = (curInputValue5 >>> 8) & mask; + out[22 + outOffset] = (curInputValue5 >>> 16) & mask; + out[23 + outOffset] = curInputValue5 >>> 24; + out[24 + outOffset] = curInputValue6 & mask; + out[25 + outOffset] = (curInputValue6 >>> 8) & mask; + out[26 + outOffset] = (curInputValue6 >>> 16) & mask; + out[27 + outOffset] = curInputValue6 >>> 24; + out[28 + outOffset] = curInputValue7 & mask; + out[29 + outOffset] = (curInputValue7 >>> 8) & mask; + out[30 + outOffset] = (curInputValue7 >>> 16) & mask; + out[31 + outOffset] = curInputValue7 >>> 24; + outOffset += 32; + } } - } - static private void unpack9(int[] out, IntBuffer in) { - int outOffset = 0; - final int mask = 511; - for (int i = 0; i < 4; ++i) { - int curInputValue0 = in.get(); - int curInputValue1 = in.get(); - int curInputValue2 = in.get(); - int curInputValue3 = in.get(); - int curInputValue4 = in.get(); - int curInputValue5 = in.get(); - int curInputValue6 = in.get(); - int curInputValue7 = in.get(); - int curInputValue8 = in.get(); - out[0 + outOffset] = curInputValue0 & mask; - out[1 + outOffset] = (curInputValue0 >>> 9) & mask; - out[2 + outOffset] = (curInputValue0 >>> 18) & mask; - out[3 + outOffset] = ((curInputValue0 >>> 27) | (curInputValue1 << 5)) & mask; - out[4 + outOffset] = (curInputValue1 >>> 4) & mask; - out[5 + outOffset] = (curInputValue1 >>> 13) & mask; - out[6 + outOffset] = (curInputValue1 >>> 22) & mask; - out[7 + outOffset] = ((curInputValue1 >>> 31) | (curInputValue2 << 1)) & mask; - out[8 + outOffset] = (curInputValue2 >>> 8) & mask; - out[9 + outOffset] = (curInputValue2 >>> 17) & mask; - out[10 + outOffset] = ((curInputValue2 >>> 26) | (curInputValue3 << 6)) & mask; - out[11 + outOffset] = (curInputValue3 >>> 3) & mask; - out[12 + outOffset] = (curInputValue3 >>> 12) & mask; - out[13 + outOffset] = (curInputValue3 >>> 21) & mask; - out[14 + outOffset] = ((curInputValue3 >>> 30) | (curInputValue4 << 2)) & mask; - out[15 + outOffset] = (curInputValue4 >>> 7) & mask; - out[16 + outOffset] = (curInputValue4 >>> 16) & mask; - out[17 + outOffset] = ((curInputValue4 >>> 25) | (curInputValue5 << 7)) & mask; - out[18 + outOffset] = (curInputValue5 >>> 2) & mask; - out[19 + outOffset] = (curInputValue5 >>> 11) & mask; - out[20 + outOffset] = (curInputValue5 >>> 20) & mask; - out[21 + outOffset] = ((curInputValue5 >>> 29) | (curInputValue6 << 3)) & mask; - out[22 + outOffset] = (curInputValue6 >>> 6) & mask; - out[23 + outOffset] = (curInputValue6 >>> 15) & mask; - out[24 + outOffset] = ((curInputValue6 >>> 24) | (curInputValue7 << 8)) & mask; - out[25 + outOffset] = (curInputValue7 >>> 1) & mask; - out[26 + outOffset] = (curInputValue7 >>> 10) & mask; - out[27 + outOffset] = (curInputValue7 >>> 19) & mask; - out[28 + outOffset] = ((curInputValue7 >>> 28) | (curInputValue8 << 4)) & mask; - out[29 + outOffset] = (curInputValue8 >>> 5) & mask; - out[30 + outOffset] = (curInputValue8 >>> 14) & mask; - out[31 + outOffset] = curInputValue8 >>> 23; - outOffset += 32; + static private void unpack9(int[] out, IntBuffer in) { + int outOffset = 0; + final int mask = 511; + for (int i = 0; i < 4; ++i) { + int curInputValue0 = in.get(); + int curInputValue1 = in.get(); + int curInputValue2 = in.get(); + int curInputValue3 = in.get(); + int curInputValue4 = in.get(); + int curInputValue5 = in.get(); + int curInputValue6 = in.get(); + int curInputValue7 = in.get(); + int curInputValue8 = in.get(); + out[0 + outOffset] = curInputValue0 & mask; + out[1 + outOffset] = (curInputValue0 >>> 9) & mask; + out[2 + outOffset] = (curInputValue0 >>> 18) & mask; + out[3 + outOffset] = ((curInputValue0 >>> 27) | (curInputValue1 << 5)) + & mask; + out[4 + outOffset] = (curInputValue1 >>> 4) & mask; + out[5 + outOffset] = (curInputValue1 >>> 13) & mask; + out[6 + outOffset] = (curInputValue1 >>> 22) & mask; + out[7 + outOffset] = ((curInputValue1 >>> 31) | (curInputValue2 << 1)) + & mask; + out[8 + outOffset] = (curInputValue2 >>> 8) & mask; + out[9 + outOffset] = (curInputValue2 >>> 17) & mask; + out[10 + outOffset] = ((curInputValue2 >>> 26) | (curInputValue3 << 6)) + & mask; + out[11 + outOffset] = (curInputValue3 >>> 3) & mask; + out[12 + outOffset] = (curInputValue3 >>> 12) & mask; + out[13 + outOffset] = (curInputValue3 >>> 21) & mask; + out[14 + outOffset] = ((curInputValue3 >>> 30) | (curInputValue4 << 2)) + & mask; + out[15 + outOffset] = (curInputValue4 >>> 7) & mask; + out[16 + outOffset] = (curInputValue4 >>> 16) & mask; + out[17 + outOffset] = ((curInputValue4 >>> 25) | (curInputValue5 << 7)) + & mask; + out[18 + outOffset] = (curInputValue5 >>> 2) & mask; + out[19 + outOffset] = (curInputValue5 >>> 11) & mask; + out[20 + outOffset] = (curInputValue5 >>> 20) & mask; + out[21 + outOffset] = ((curInputValue5 >>> 29) | (curInputValue6 << 3)) + & mask; + out[22 + outOffset] = (curInputValue6 >>> 6) & mask; + out[23 + outOffset] = (curInputValue6 >>> 15) & mask; + out[24 + outOffset] = ((curInputValue6 >>> 24) | (curInputValue7 << 8)) + & mask; + out[25 + outOffset] = (curInputValue7 >>> 1) & mask; + out[26 + outOffset] = (curInputValue7 >>> 10) & mask; + out[27 + outOffset] = (curInputValue7 >>> 19) & mask; + out[28 + outOffset] = ((curInputValue7 >>> 28) | (curInputValue8 << 4)) + & mask; + out[29 + outOffset] = (curInputValue8 >>> 5) & mask; + out[30 + outOffset] = (curInputValue8 >>> 14) & mask; + out[31 + outOffset] = curInputValue8 >>> 23; + outOffset += 32; + } } - } - static private void unpack10(int[] out, IntBuffer in) { - int outOffset = 0; - final int mask = 1023; - for (int i = 0; i < 4; ++i) { - int curInputValue0 = in.get(); - int curInputValue1 = in.get(); - int curInputValue2 = in.get(); - int curInputValue3 = in.get(); - int curInputValue4 = in.get(); - int curInputValue5 = in.get(); - int curInputValue6 = in.get(); - int curInputValue7 = in.get(); - int curInputValue8 = in.get(); - int curInputValue9 = in.get(); - out[0 + outOffset] = curInputValue0 & mask; - out[1 + outOffset] = (curInputValue0 >>> 10) & mask; - out[2 + outOffset] = (curInputValue0 >>> 20) & mask; - out[3 + outOffset] = ((curInputValue0 >>> 30) | (curInputValue1 << 2)) & mask; - out[4 + outOffset] = (curInputValue1 >>> 8) & mask; - out[5 + outOffset] = (curInputValue1 >>> 18) & mask; - out[6 + outOffset] = ((curInputValue1 >>> 28) | (curInputValue2 << 4)) & mask; - out[7 + outOffset] = (curInputValue2 >>> 6) & mask; - out[8 + outOffset] = (curInputValue2 >>> 16) & mask; - out[9 + outOffset] = ((curInputValue2 >>> 26) | (curInputValue3 << 6)) & mask; - out[10 + outOffset] = (curInputValue3 >>> 4) & mask; - out[11 + outOffset] = (curInputValue3 >>> 14) & mask; - out[12 + outOffset] = ((curInputValue3 >>> 24) | (curInputValue4 << 8)) & mask; - out[13 + outOffset] = (curInputValue4 >>> 2) & mask; - out[14 + outOffset] = (curInputValue4 >>> 12) & mask; - out[15 + outOffset] = curInputValue4 >>> 22; - out[16 + outOffset] = curInputValue5 & mask; - out[17 + outOffset] = (curInputValue5 >>> 10) & mask; - out[18 + outOffset] = (curInputValue5 >>> 20) & mask; - out[19 + outOffset] = ((curInputValue5 >>> 30) | (curInputValue6 << 2)) & mask; - out[20 + outOffset] = (curInputValue6 >>> 8) & mask; - out[21 + outOffset] = (curInputValue6 >>> 18) & mask; - out[22 + outOffset] = ((curInputValue6 >>> 28) | (curInputValue7 << 4)) & mask; - out[23 + outOffset] = (curInputValue7 >>> 6) & mask; - out[24 + outOffset] = (curInputValue7 >>> 16) & mask; - out[25 + outOffset] = ((curInputValue7 >>> 26) | (curInputValue8 << 6)) & mask; - out[26 + outOffset] = (curInputValue8 >>> 4) & mask; - out[27 + outOffset] = (curInputValue8 >>> 14) & mask; - out[28 + outOffset] = ((curInputValue8 >>> 24) | (curInputValue9 << 8)) & mask; - out[29 + outOffset] = (curInputValue9 >>> 2) & mask; - out[30 + outOffset] = (curInputValue9 >>> 12) & mask; - out[31 + outOffset] = curInputValue9 >>> 22; - outOffset += 32; + static private void unpack10(int[] out, IntBuffer in) { + int outOffset = 0; + final int mask = 1023; + for (int i = 0; i < 4; ++i) { + int curInputValue0 = in.get(); + int curInputValue1 = in.get(); + int curInputValue2 = in.get(); + int curInputValue3 = in.get(); + int curInputValue4 = in.get(); + int curInputValue5 = in.get(); + int curInputValue6 = in.get(); + int curInputValue7 = in.get(); + int curInputValue8 = in.get(); + int curInputValue9 = in.get(); + out[0 + outOffset] = curInputValue0 & mask; + out[1 + outOffset] = (curInputValue0 >>> 10) & mask; + out[2 + outOffset] = (curInputValue0 >>> 20) & mask; + out[3 + outOffset] = ((curInputValue0 >>> 30) | (curInputValue1 << 2)) + & mask; + out[4 + outOffset] = (curInputValue1 >>> 8) & mask; + out[5 + outOffset] = (curInputValue1 >>> 18) & mask; + out[6 + outOffset] = ((curInputValue1 >>> 28) | (curInputValue2 << 4)) + & mask; + out[7 + outOffset] = (curInputValue2 >>> 6) & mask; + out[8 + outOffset] = (curInputValue2 >>> 16) & mask; + out[9 + outOffset] = ((curInputValue2 >>> 26) | (curInputValue3 << 6)) + & mask; + out[10 + outOffset] = (curInputValue3 >>> 4) & mask; + out[11 + outOffset] = (curInputValue3 >>> 14) & mask; + out[12 + outOffset] = ((curInputValue3 >>> 24) | (curInputValue4 << 8)) + & mask; + out[13 + outOffset] = (curInputValue4 >>> 2) & mask; + out[14 + outOffset] = (curInputValue4 >>> 12) & mask; + out[15 + outOffset] = curInputValue4 >>> 22; + out[16 + outOffset] = curInputValue5 & mask; + out[17 + outOffset] = (curInputValue5 >>> 10) & mask; + out[18 + outOffset] = (curInputValue5 >>> 20) & mask; + out[19 + outOffset] = ((curInputValue5 >>> 30) | (curInputValue6 << 2)) + & mask; + out[20 + outOffset] = (curInputValue6 >>> 8) & mask; + out[21 + outOffset] = (curInputValue6 >>> 18) & mask; + out[22 + outOffset] = ((curInputValue6 >>> 28) | (curInputValue7 << 4)) + & mask; + out[23 + outOffset] = (curInputValue7 >>> 6) & mask; + out[24 + outOffset] = (curInputValue7 >>> 16) & mask; + out[25 + outOffset] = ((curInputValue7 >>> 26) | (curInputValue8 << 6)) + & mask; + out[26 + outOffset] = (curInputValue8 >>> 4) & mask; + out[27 + outOffset] = (curInputValue8 >>> 14) & mask; + out[28 + outOffset] = ((curInputValue8 >>> 24) | (curInputValue9 << 8)) + & mask; + out[29 + outOffset] = (curInputValue9 >>> 2) & mask; + out[30 + outOffset] = (curInputValue9 >>> 12) & mask; + out[31 + outOffset] = curInputValue9 >>> 22; + outOffset += 32; + } } - } - static private void unpack11(int[] out, IntBuffer in) { - int outOffset = 0; - final int mask = 2047; - for (int i = 0; i < 4; ++i) { - int curInputValue0 = in.get(); - int curInputValue1 = in.get(); - int curInputValue2 = in.get(); - int curInputValue3 = in.get(); - int curInputValue4 = in.get(); - int curInputValue5 = in.get(); - int curInputValue6 = in.get(); - int curInputValue7 = in.get(); - int curInputValue8 = in.get(); - int curInputValue9 = in.get(); - int curInputValue10 = in.get(); - out[0 + outOffset] = curInputValue0 & mask; - out[1 + outOffset] = (curInputValue0 >>> 11) & mask; - out[2 + outOffset] = ((curInputValue0 >>> 22) | (curInputValue1 << 10)) & mask; - out[3 + outOffset] = (curInputValue1 >>> 1) & mask; - out[4 + outOffset] = (curInputValue1 >>> 12) & mask; - out[5 + outOffset] = ((curInputValue1 >>> 23) | (curInputValue2 << 9)) & mask; - out[6 + outOffset] = (curInputValue2 >>> 2) & mask; - out[7 + outOffset] = (curInputValue2 >>> 13) & mask; - out[8 + outOffset] = ((curInputValue2 >>> 24) | (curInputValue3 << 8)) & mask; - out[9 + outOffset] = (curInputValue3 >>> 3) & mask; - out[10 + outOffset] = (curInputValue3 >>> 14) & mask; - out[11 + outOffset] = ((curInputValue3 >>> 25) | (curInputValue4 << 7)) & mask; - out[12 + outOffset] = (curInputValue4 >>> 4) & mask; - out[13 + outOffset] = (curInputValue4 >>> 15) & mask; - out[14 + outOffset] = ((curInputValue4 >>> 26) | (curInputValue5 << 6)) & mask; - out[15 + outOffset] = (curInputValue5 >>> 5) & mask; - out[16 + outOffset] = (curInputValue5 >>> 16) & mask; - out[17 + outOffset] = ((curInputValue5 >>> 27) | (curInputValue6 << 5)) & mask; - out[18 + outOffset] = (curInputValue6 >>> 6) & mask; - out[19 + outOffset] = (curInputValue6 >>> 17) & mask; - out[20 + outOffset] = ((curInputValue6 >>> 28) | (curInputValue7 << 4)) & mask; - out[21 + outOffset] = (curInputValue7 >>> 7) & mask; - out[22 + outOffset] = (curInputValue7 >>> 18) & mask; - out[23 + outOffset] = ((curInputValue7 >>> 29) | (curInputValue8 << 3)) & mask; - out[24 + outOffset] = (curInputValue8 >>> 8) & mask; - out[25 + outOffset] = (curInputValue8 >>> 19) & mask; - out[26 + outOffset] = ((curInputValue8 >>> 30) | (curInputValue9 << 2)) & mask; - out[27 + outOffset] = (curInputValue9 >>> 9) & mask; - out[28 + outOffset] = (curInputValue9 >>> 20) & mask; - out[29 + outOffset] = ((curInputValue9 >>> 31) | (curInputValue10 << 1)) & mask; - out[30 + outOffset] = (curInputValue10 >>> 10) & mask; - out[31 + outOffset] = curInputValue10 >>> 21; - outOffset += 32; + static private void unpack11(int[] out, IntBuffer in) { + int outOffset = 0; + final int mask = 2047; + for (int i = 0; i < 4; ++i) { + int curInputValue0 = in.get(); + int curInputValue1 = in.get(); + int curInputValue2 = in.get(); + int curInputValue3 = in.get(); + int curInputValue4 = in.get(); + int curInputValue5 = in.get(); + int curInputValue6 = in.get(); + int curInputValue7 = in.get(); + int curInputValue8 = in.get(); + int curInputValue9 = in.get(); + int curInputValue10 = in.get(); + out[0 + outOffset] = curInputValue0 & mask; + out[1 + outOffset] = (curInputValue0 >>> 11) & mask; + out[2 + outOffset] = ((curInputValue0 >>> 22) | (curInputValue1 << 10)) + & mask; + out[3 + outOffset] = (curInputValue1 >>> 1) & mask; + out[4 + outOffset] = (curInputValue1 >>> 12) & mask; + out[5 + outOffset] = ((curInputValue1 >>> 23) | (curInputValue2 << 9)) + & mask; + out[6 + outOffset] = (curInputValue2 >>> 2) & mask; + out[7 + outOffset] = (curInputValue2 >>> 13) & mask; + out[8 + outOffset] = ((curInputValue2 >>> 24) | (curInputValue3 << 8)) + & mask; + out[9 + outOffset] = (curInputValue3 >>> 3) & mask; + out[10 + outOffset] = (curInputValue3 >>> 14) & mask; + out[11 + outOffset] = ((curInputValue3 >>> 25) | (curInputValue4 << 7)) + & mask; + out[12 + outOffset] = (curInputValue4 >>> 4) & mask; + out[13 + outOffset] = (curInputValue4 >>> 15) & mask; + out[14 + outOffset] = ((curInputValue4 >>> 26) | (curInputValue5 << 6)) + & mask; + out[15 + outOffset] = (curInputValue5 >>> 5) & mask; + out[16 + outOffset] = (curInputValue5 >>> 16) & mask; + out[17 + outOffset] = ((curInputValue5 >>> 27) | (curInputValue6 << 5)) + & mask; + out[18 + outOffset] = (curInputValue6 >>> 6) & mask; + out[19 + outOffset] = (curInputValue6 >>> 17) & mask; + out[20 + outOffset] = ((curInputValue6 >>> 28) | (curInputValue7 << 4)) + & mask; + out[21 + outOffset] = (curInputValue7 >>> 7) & mask; + out[22 + outOffset] = (curInputValue7 >>> 18) & mask; + out[23 + outOffset] = ((curInputValue7 >>> 29) | (curInputValue8 << 3)) + & mask; + out[24 + outOffset] = (curInputValue8 >>> 8) & mask; + out[25 + outOffset] = (curInputValue8 >>> 19) & mask; + out[26 + outOffset] = ((curInputValue8 >>> 30) | (curInputValue9 << 2)) + & mask; + out[27 + outOffset] = (curInputValue9 >>> 9) & mask; + out[28 + outOffset] = (curInputValue9 >>> 20) & mask; + out[29 + outOffset] = ((curInputValue9 >>> 31) | (curInputValue10 << 1)) + & mask; + out[30 + outOffset] = (curInputValue10 >>> 10) & mask; + out[31 + outOffset] = curInputValue10 >>> 21; + outOffset += 32; + } } - } - static private void unpack12(int[] out, IntBuffer in) { - int outOffset = 0; - final int mask = 4095; - for (int i = 0; i < 4; ++i) { - int curInputValue0 = in.get(); - int curInputValue1 = in.get(); - int curInputValue2 = in.get(); - int curInputValue3 = in.get(); - int curInputValue4 = in.get(); - int curInputValue5 = in.get(); - int curInputValue6 = in.get(); - int curInputValue7 = in.get(); - int curInputValue8 = in.get(); - int curInputValue9 = in.get(); - int curInputValue10 = in.get(); - int curInputValue11 = in.get(); - out[0 + outOffset] = curInputValue0 & mask; - out[1 + outOffset] = (curInputValue0 >>> 12) & mask; - out[2 + outOffset] = ((curInputValue0 >>> 24) | (curInputValue1 << 8)) & mask; - out[3 + outOffset] = (curInputValue1 >>> 4) & mask; - out[4 + outOffset] = (curInputValue1 >>> 16) & mask; - out[5 + outOffset] = ((curInputValue1 >>> 28) | (curInputValue2 << 4)) & mask; - out[6 + outOffset] = (curInputValue2 >>> 8) & mask; - out[7 + outOffset] = curInputValue2 >>> 20; - out[8 + outOffset] = curInputValue3 & mask; - out[9 + outOffset] = (curInputValue3 >>> 12) & mask; - out[10 + outOffset] = ((curInputValue3 >>> 24) | (curInputValue4 << 8)) & mask; - out[11 + outOffset] = (curInputValue4 >>> 4) & mask; - out[12 + outOffset] = (curInputValue4 >>> 16) & mask; - out[13 + outOffset] = ((curInputValue4 >>> 28) | (curInputValue5 << 4)) & mask; - out[14 + outOffset] = (curInputValue5 >>> 8) & mask; - out[15 + outOffset] = curInputValue5 >>> 20; - out[16 + outOffset] = curInputValue6 & mask; - out[17 + outOffset] = (curInputValue6 >>> 12) & mask; - out[18 + outOffset] = ((curInputValue6 >>> 24) | (curInputValue7 << 8)) & mask; - out[19 + outOffset] = (curInputValue7 >>> 4) & mask; - out[20 + outOffset] = (curInputValue7 >>> 16) & mask; - out[21 + outOffset] = ((curInputValue7 >>> 28) | (curInputValue8 << 4)) & mask; - out[22 + outOffset] = (curInputValue8 >>> 8) & mask; - out[23 + outOffset] = curInputValue8 >>> 20; - out[24 + outOffset] = curInputValue9 & mask; - out[25 + outOffset] = (curInputValue9 >>> 12) & mask; - out[26 + outOffset] = ((curInputValue9 >>> 24) | (curInputValue10 << 8)) & mask; - out[27 + outOffset] = (curInputValue10 >>> 4) & mask; - out[28 + outOffset] = (curInputValue10 >>> 16) & mask; - out[29 + outOffset] = ((curInputValue10 >>> 28) | (curInputValue11 << 4)) & mask; - out[30 + outOffset] = (curInputValue11 >>> 8) & mask; - out[31 + outOffset] = curInputValue11 >>> 20; - outOffset += 32; + static private void unpack12(int[] out, IntBuffer in) { + int outOffset = 0; + final int mask = 4095; + for (int i = 0; i < 4; ++i) { + int curInputValue0 = in.get(); + int curInputValue1 = in.get(); + int curInputValue2 = in.get(); + int curInputValue3 = in.get(); + int curInputValue4 = in.get(); + int curInputValue5 = in.get(); + int curInputValue6 = in.get(); + int curInputValue7 = in.get(); + int curInputValue8 = in.get(); + int curInputValue9 = in.get(); + int curInputValue10 = in.get(); + int curInputValue11 = in.get(); + out[0 + outOffset] = curInputValue0 & mask; + out[1 + outOffset] = (curInputValue0 >>> 12) & mask; + out[2 + outOffset] = ((curInputValue0 >>> 24) | (curInputValue1 << 8)) + & mask; + out[3 + outOffset] = (curInputValue1 >>> 4) & mask; + out[4 + outOffset] = (curInputValue1 >>> 16) & mask; + out[5 + outOffset] = ((curInputValue1 >>> 28) | (curInputValue2 << 4)) + & mask; + out[6 + outOffset] = (curInputValue2 >>> 8) & mask; + out[7 + outOffset] = curInputValue2 >>> 20; + out[8 + outOffset] = curInputValue3 & mask; + out[9 + outOffset] = (curInputValue3 >>> 12) & mask; + out[10 + outOffset] = ((curInputValue3 >>> 24) | (curInputValue4 << 8)) + & mask; + out[11 + outOffset] = (curInputValue4 >>> 4) & mask; + out[12 + outOffset] = (curInputValue4 >>> 16) & mask; + out[13 + outOffset] = ((curInputValue4 >>> 28) | (curInputValue5 << 4)) + & mask; + out[14 + outOffset] = (curInputValue5 >>> 8) & mask; + out[15 + outOffset] = curInputValue5 >>> 20; + out[16 + outOffset] = curInputValue6 & mask; + out[17 + outOffset] = (curInputValue6 >>> 12) & mask; + out[18 + outOffset] = ((curInputValue6 >>> 24) | (curInputValue7 << 8)) + & mask; + out[19 + outOffset] = (curInputValue7 >>> 4) & mask; + out[20 + outOffset] = (curInputValue7 >>> 16) & mask; + out[21 + outOffset] = ((curInputValue7 >>> 28) | (curInputValue8 << 4)) + & mask; + out[22 + outOffset] = (curInputValue8 >>> 8) & mask; + out[23 + outOffset] = curInputValue8 >>> 20; + out[24 + outOffset] = curInputValue9 & mask; + out[25 + outOffset] = (curInputValue9 >>> 12) & mask; + out[26 + outOffset] = ((curInputValue9 >>> 24) | (curInputValue10 << 8)) + & mask; + out[27 + outOffset] = (curInputValue10 >>> 4) & mask; + out[28 + outOffset] = (curInputValue10 >>> 16) & mask; + out[29 + outOffset] = ((curInputValue10 >>> 28) | (curInputValue11 << 4)) + & mask; + out[30 + outOffset] = (curInputValue11 >>> 8) & mask; + out[31 + outOffset] = curInputValue11 >>> 20; + outOffset += 32; + } } - } - static private void unpack13(int[] out, IntBuffer in) { - int outOffset = 0; - final int mask = 8191; - for (int i = 0; i < 4; ++i) { - int curInputValue0 = in.get(); - int curInputValue1 = in.get(); - int curInputValue2 = in.get(); - int curInputValue3 = in.get(); - int curInputValue4 = in.get(); - int curInputValue5 = in.get(); - int curInputValue6 = in.get(); - int curInputValue7 = in.get(); - int curInputValue8 = in.get(); - int curInputValue9 = in.get(); - int curInputValue10 = in.get(); - int curInputValue11 = in.get(); - int curInputValue12 = in.get(); - out[0 + outOffset] = curInputValue0 & mask; - out[1 + outOffset] = (curInputValue0 >>> 13) & mask; - out[2 + outOffset] = ((curInputValue0 >>> 26) | (curInputValue1 << 6)) & mask; - out[3 + outOffset] = (curInputValue1 >>> 7) & mask; - out[4 + outOffset] = ((curInputValue1 >>> 20) | (curInputValue2 << 12)) & mask; - out[5 + outOffset] = (curInputValue2 >>> 1) & mask; - out[6 + outOffset] = (curInputValue2 >>> 14) & mask; - out[7 + outOffset] = ((curInputValue2 >>> 27) | (curInputValue3 << 5)) & mask; - out[8 + outOffset] = (curInputValue3 >>> 8) & mask; - out[9 + outOffset] = ((curInputValue3 >>> 21) | (curInputValue4 << 11)) & mask; - out[10 + outOffset] = (curInputValue4 >>> 2) & mask; - out[11 + outOffset] = (curInputValue4 >>> 15) & mask; - out[12 + outOffset] = ((curInputValue4 >>> 28) | (curInputValue5 << 4)) & mask; - out[13 + outOffset] = (curInputValue5 >>> 9) & mask; - out[14 + outOffset] = ((curInputValue5 >>> 22) | (curInputValue6 << 10)) & mask; - out[15 + outOffset] = (curInputValue6 >>> 3) & mask; - out[16 + outOffset] = (curInputValue6 >>> 16) & mask; - out[17 + outOffset] = ((curInputValue6 >>> 29) | (curInputValue7 << 3)) & mask; - out[18 + outOffset] = (curInputValue7 >>> 10) & mask; - out[19 + outOffset] = ((curInputValue7 >>> 23) | (curInputValue8 << 9)) & mask; - out[20 + outOffset] = (curInputValue8 >>> 4) & mask; - out[21 + outOffset] = (curInputValue8 >>> 17) & mask; - out[22 + outOffset] = ((curInputValue8 >>> 30) | (curInputValue9 << 2)) & mask; - out[23 + outOffset] = (curInputValue9 >>> 11) & mask; - out[24 + outOffset] = ((curInputValue9 >>> 24) | (curInputValue10 << 8)) & mask; - out[25 + outOffset] = (curInputValue10 >>> 5) & mask; - out[26 + outOffset] = (curInputValue10 >>> 18) & mask; - out[27 + outOffset] = ((curInputValue10 >>> 31) | (curInputValue11 << 1)) & mask; - out[28 + outOffset] = (curInputValue11 >>> 12) & mask; - out[29 + outOffset] = ((curInputValue11 >>> 25) | (curInputValue12 << 7)) & mask; - out[30 + outOffset] = (curInputValue12 >>> 6) & mask; - out[31 + outOffset] = curInputValue12 >>> 19; - outOffset += 32; + static private void unpack13(int[] out, IntBuffer in) { + int outOffset = 0; + final int mask = 8191; + for (int i = 0; i < 4; ++i) { + int curInputValue0 = in.get(); + int curInputValue1 = in.get(); + int curInputValue2 = in.get(); + int curInputValue3 = in.get(); + int curInputValue4 = in.get(); + int curInputValue5 = in.get(); + int curInputValue6 = in.get(); + int curInputValue7 = in.get(); + int curInputValue8 = in.get(); + int curInputValue9 = in.get(); + int curInputValue10 = in.get(); + int curInputValue11 = in.get(); + int curInputValue12 = in.get(); + out[0 + outOffset] = curInputValue0 & mask; + out[1 + outOffset] = (curInputValue0 >>> 13) & mask; + out[2 + outOffset] = ((curInputValue0 >>> 26) | (curInputValue1 << 6)) + & mask; + out[3 + outOffset] = (curInputValue1 >>> 7) & mask; + out[4 + outOffset] = ((curInputValue1 >>> 20) | (curInputValue2 << 12)) + & mask; + out[5 + outOffset] = (curInputValue2 >>> 1) & mask; + out[6 + outOffset] = (curInputValue2 >>> 14) & mask; + out[7 + outOffset] = ((curInputValue2 >>> 27) | (curInputValue3 << 5)) + & mask; + out[8 + outOffset] = (curInputValue3 >>> 8) & mask; + out[9 + outOffset] = ((curInputValue3 >>> 21) | (curInputValue4 << 11)) + & mask; + out[10 + outOffset] = (curInputValue4 >>> 2) & mask; + out[11 + outOffset] = (curInputValue4 >>> 15) & mask; + out[12 + outOffset] = ((curInputValue4 >>> 28) | (curInputValue5 << 4)) + & mask; + out[13 + outOffset] = (curInputValue5 >>> 9) & mask; + out[14 + outOffset] = ((curInputValue5 >>> 22) | (curInputValue6 << 10)) + & mask; + out[15 + outOffset] = (curInputValue6 >>> 3) & mask; + out[16 + outOffset] = (curInputValue6 >>> 16) & mask; + out[17 + outOffset] = ((curInputValue6 >>> 29) | (curInputValue7 << 3)) + & mask; + out[18 + outOffset] = (curInputValue7 >>> 10) & mask; + out[19 + outOffset] = ((curInputValue7 >>> 23) | (curInputValue8 << 9)) + & mask; + out[20 + outOffset] = (curInputValue8 >>> 4) & mask; + out[21 + outOffset] = (curInputValue8 >>> 17) & mask; + out[22 + outOffset] = ((curInputValue8 >>> 30) | (curInputValue9 << 2)) + & mask; + out[23 + outOffset] = (curInputValue9 >>> 11) & mask; + out[24 + outOffset] = ((curInputValue9 >>> 24) | (curInputValue10 << 8)) + & mask; + out[25 + outOffset] = (curInputValue10 >>> 5) & mask; + out[26 + outOffset] = (curInputValue10 >>> 18) & mask; + out[27 + outOffset] = ((curInputValue10 >>> 31) | (curInputValue11 << 1)) + & mask; + out[28 + outOffset] = (curInputValue11 >>> 12) & mask; + out[29 + outOffset] = ((curInputValue11 >>> 25) | (curInputValue12 << 7)) + & mask; + out[30 + outOffset] = (curInputValue12 >>> 6) & mask; + out[31 + outOffset] = curInputValue12 >>> 19; + outOffset += 32; + } } - } - static private void unpack16(int[] out, IntBuffer in) { - int outOffset = 0; - final int mask = 65535; - for (int i = 0; i < 4; ++i) { - int curInputValue0 = in.get(); - int curInputValue1 = in.get(); - int curInputValue2 = in.get(); - int curInputValue3 = in.get(); - int curInputValue4 = in.get(); - int curInputValue5 = in.get(); - int curInputValue6 = in.get(); - int curInputValue7 = in.get(); - int curInputValue8 = in.get(); - int curInputValue9 = in.get(); - int curInputValue10 = in.get(); - int curInputValue11 = in.get(); - int curInputValue12 = in.get(); - int curInputValue13 = in.get(); - int curInputValue14 = in.get(); - int curInputValue15 = in.get(); - out[0 + outOffset] = curInputValue0 & mask; - out[1 + outOffset] = curInputValue0 >>> 16; - out[2 + outOffset] = curInputValue1 & mask; - out[3 + outOffset] = curInputValue1 >>> 16; - out[4 + outOffset] = curInputValue2 & mask; - out[5 + outOffset] = curInputValue2 >>> 16; - out[6 + outOffset] = curInputValue3 & mask; - out[7 + outOffset] = curInputValue3 >>> 16; - out[8 + outOffset] = curInputValue4 & mask; - out[9 + outOffset] = curInputValue4 >>> 16; - out[10 + outOffset] = curInputValue5 & mask; - out[11 + outOffset] = curInputValue5 >>> 16; - out[12 + outOffset] = curInputValue6 & mask; - out[13 + outOffset] = curInputValue6 >>> 16; - out[14 + outOffset] = curInputValue7 & mask; - out[15 + outOffset] = curInputValue7 >>> 16; - out[16 + outOffset] = curInputValue8 & mask; - out[17 + outOffset] = curInputValue8 >>> 16; - out[18 + outOffset] = curInputValue9 & mask; - out[19 + outOffset] = curInputValue9 >>> 16; - out[20 + outOffset] = curInputValue10 & mask; - out[21 + outOffset] = curInputValue10 >>> 16; - out[22 + outOffset] = curInputValue11 & mask; - out[23 + outOffset] = curInputValue11 >>> 16; - out[24 + outOffset] = curInputValue12 & mask; - out[25 + outOffset] = curInputValue12 >>> 16; - out[26 + outOffset] = curInputValue13 & mask; - out[27 + outOffset] = curInputValue13 >>> 16; - out[28 + outOffset] = curInputValue14 & mask; - out[29 + outOffset] = curInputValue14 >>> 16; - out[30 + outOffset] = curInputValue15 & mask; - out[31 + outOffset] = curInputValue15 >>> 16; - outOffset += 32; + static private void unpack16(int[] out, IntBuffer in) { + int outOffset = 0; + final int mask = 65535; + for (int i = 0; i < 4; ++i) { + int curInputValue0 = in.get(); + int curInputValue1 = in.get(); + int curInputValue2 = in.get(); + int curInputValue3 = in.get(); + int curInputValue4 = in.get(); + int curInputValue5 = in.get(); + int curInputValue6 = in.get(); + int curInputValue7 = in.get(); + int curInputValue8 = in.get(); + int curInputValue9 = in.get(); + int curInputValue10 = in.get(); + int curInputValue11 = in.get(); + int curInputValue12 = in.get(); + int curInputValue13 = in.get(); + int curInputValue14 = in.get(); + int curInputValue15 = in.get(); + out[0 + outOffset] = curInputValue0 & mask; + out[1 + outOffset] = curInputValue0 >>> 16; + out[2 + outOffset] = curInputValue1 & mask; + out[3 + outOffset] = curInputValue1 >>> 16; + out[4 + outOffset] = curInputValue2 & mask; + out[5 + outOffset] = curInputValue2 >>> 16; + out[6 + outOffset] = curInputValue3 & mask; + out[7 + outOffset] = curInputValue3 >>> 16; + out[8 + outOffset] = curInputValue4 & mask; + out[9 + outOffset] = curInputValue4 >>> 16; + out[10 + outOffset] = curInputValue5 & mask; + out[11 + outOffset] = curInputValue5 >>> 16; + out[12 + outOffset] = curInputValue6 & mask; + out[13 + outOffset] = curInputValue6 >>> 16; + out[14 + outOffset] = curInputValue7 & mask; + out[15 + outOffset] = curInputValue7 >>> 16; + out[16 + outOffset] = curInputValue8 & mask; + out[17 + outOffset] = curInputValue8 >>> 16; + out[18 + outOffset] = curInputValue9 & mask; + out[19 + outOffset] = curInputValue9 >>> 16; + out[20 + outOffset] = curInputValue10 & mask; + out[21 + outOffset] = curInputValue10 >>> 16; + out[22 + outOffset] = curInputValue11 & mask; + out[23 + outOffset] = curInputValue11 >>> 16; + out[24 + outOffset] = curInputValue12 & mask; + out[25 + outOffset] = curInputValue12 >>> 16; + out[26 + outOffset] = curInputValue13 & mask; + out[27 + outOffset] = curInputValue13 >>> 16; + out[28 + outOffset] = curInputValue14 & mask; + out[29 + outOffset] = curInputValue14 >>> 16; + out[30 + outOffset] = curInputValue15 & mask; + out[31 + outOffset] = curInputValue15 >>> 16; + outOffset += 32; + } } - } - static private void unpack20(int[] out, IntBuffer in) { - int outOffset = 0; - final int mask = 1048575; - for (int i = 0; i < 4; ++i) { - int curInputValue0 = in.get(); - int curInputValue1 = in.get(); - int curInputValue2 = in.get(); - int curInputValue3 = in.get(); - int curInputValue4 = in.get(); - int curInputValue5 = in.get(); - int curInputValue6 = in.get(); - int curInputValue7 = in.get(); - int curInputValue8 = in.get(); - int curInputValue9 = in.get(); - int curInputValue10 = in.get(); - int curInputValue11 = in.get(); - int curInputValue12 = in.get(); - int curInputValue13 = in.get(); - int curInputValue14 = in.get(); - int curInputValue15 = in.get(); - int curInputValue16 = in.get(); - int curInputValue17 = in.get(); - int curInputValue18 = in.get(); - int curInputValue19 = in.get(); - out[0 + outOffset] = curInputValue0 & mask; - out[1 + outOffset] = ((curInputValue0 >>> 20) | (curInputValue1 << 12)) & mask; - out[2 + outOffset] = (curInputValue1 >>> 8) & mask; - out[3 + outOffset] = ((curInputValue1 >>> 28) | (curInputValue2 << 4)) & mask; - out[4 + outOffset] = ((curInputValue2 >>> 16) | (curInputValue3 << 16)) & mask; - out[5 + outOffset] = (curInputValue3 >>> 4) & mask; - out[6 + outOffset] = ((curInputValue3 >>> 24) | (curInputValue4 << 8)) & mask; - out[7 + outOffset] = curInputValue4 >>> 12; - out[8 + outOffset] = curInputValue5 & mask; - out[9 + outOffset] = ((curInputValue5 >>> 20) | (curInputValue6 << 12)) & mask; - out[10 + outOffset] = (curInputValue6 >>> 8) & mask; - out[11 + outOffset] = ((curInputValue6 >>> 28) | (curInputValue7 << 4)) & mask; - out[12 + outOffset] = ((curInputValue7 >>> 16) | (curInputValue8 << 16)) & mask; - out[13 + outOffset] = (curInputValue8 >>> 4) & mask; - out[14 + outOffset] = ((curInputValue8 >>> 24) | (curInputValue9 << 8)) & mask; - out[15 + outOffset] = curInputValue9 >>> 12; - out[16 + outOffset] = curInputValue10 & mask; - out[17 + outOffset] = ((curInputValue10 >>> 20) | (curInputValue11 << 12)) & mask; - out[18 + outOffset] = (curInputValue11 >>> 8) & mask; - out[19 + outOffset] = ((curInputValue11 >>> 28) | (curInputValue12 << 4)) & mask; - out[20 + outOffset] = ((curInputValue12 >>> 16) | (curInputValue13 << 16)) & mask; - out[21 + outOffset] = (curInputValue13 >>> 4) & mask; - out[22 + outOffset] = ((curInputValue13 >>> 24) | (curInputValue14 << 8)) & mask; - out[23 + outOffset] = curInputValue14 >>> 12; - out[24 + outOffset] = curInputValue15 & mask; - out[25 + outOffset] = ((curInputValue15 >>> 20) | (curInputValue16 << 12)) & mask; - out[26 + outOffset] = (curInputValue16 >>> 8) & mask; - out[27 + outOffset] = ((curInputValue16 >>> 28) | (curInputValue17 << 4)) & mask; - out[28 + outOffset] = ((curInputValue17 >>> 16) | (curInputValue18 << 16)) & mask; - out[29 + outOffset] = (curInputValue18 >>> 4) & mask; - out[30 + outOffset] = ((curInputValue18 >>> 24) | (curInputValue19 << 8)) & mask; - out[31 + outOffset] = curInputValue19 >>> 12; - outOffset += 32; + static private void unpack20(int[] out, IntBuffer in) { + int outOffset = 0; + final int mask = 1048575; + for (int i = 0; i < 4; ++i) { + int curInputValue0 = in.get(); + int curInputValue1 = in.get(); + int curInputValue2 = in.get(); + int curInputValue3 = in.get(); + int curInputValue4 = in.get(); + int curInputValue5 = in.get(); + int curInputValue6 = in.get(); + int curInputValue7 = in.get(); + int curInputValue8 = in.get(); + int curInputValue9 = in.get(); + int curInputValue10 = in.get(); + int curInputValue11 = in.get(); + int curInputValue12 = in.get(); + int curInputValue13 = in.get(); + int curInputValue14 = in.get(); + int curInputValue15 = in.get(); + int curInputValue16 = in.get(); + int curInputValue17 = in.get(); + int curInputValue18 = in.get(); + int curInputValue19 = in.get(); + out[0 + outOffset] = curInputValue0 & mask; + out[1 + outOffset] = ((curInputValue0 >>> 20) | (curInputValue1 << 12)) + & mask; + out[2 + outOffset] = (curInputValue1 >>> 8) & mask; + out[3 + outOffset] = ((curInputValue1 >>> 28) | (curInputValue2 << 4)) + & mask; + out[4 + outOffset] = ((curInputValue2 >>> 16) | (curInputValue3 << 16)) + & mask; + out[5 + outOffset] = (curInputValue3 >>> 4) & mask; + out[6 + outOffset] = ((curInputValue3 >>> 24) | (curInputValue4 << 8)) + & mask; + out[7 + outOffset] = curInputValue4 >>> 12; + out[8 + outOffset] = curInputValue5 & mask; + out[9 + outOffset] = ((curInputValue5 >>> 20) | (curInputValue6 << 12)) + & mask; + out[10 + outOffset] = (curInputValue6 >>> 8) & mask; + out[11 + outOffset] = ((curInputValue6 >>> 28) | (curInputValue7 << 4)) + & mask; + out[12 + outOffset] = ((curInputValue7 >>> 16) | (curInputValue8 << 16)) + & mask; + out[13 + outOffset] = (curInputValue8 >>> 4) & mask; + out[14 + outOffset] = ((curInputValue8 >>> 24) | (curInputValue9 << 8)) + & mask; + out[15 + outOffset] = curInputValue9 >>> 12; + out[16 + outOffset] = curInputValue10 & mask; + out[17 + outOffset] = ((curInputValue10 >>> 20) | (curInputValue11 << 12)) + & mask; + out[18 + outOffset] = (curInputValue11 >>> 8) & mask; + out[19 + outOffset] = ((curInputValue11 >>> 28) | (curInputValue12 << 4)) + & mask; + out[20 + outOffset] = ((curInputValue12 >>> 16) | (curInputValue13 << 16)) + & mask; + out[21 + outOffset] = (curInputValue13 >>> 4) & mask; + out[22 + outOffset] = ((curInputValue13 >>> 24) | (curInputValue14 << 8)) + & mask; + out[23 + outOffset] = curInputValue14 >>> 12; + out[24 + outOffset] = curInputValue15 & mask; + out[25 + outOffset] = ((curInputValue15 >>> 20) | (curInputValue16 << 12)) + & mask; + out[26 + outOffset] = (curInputValue16 >>> 8) & mask; + out[27 + outOffset] = ((curInputValue16 >>> 28) | (curInputValue17 << 4)) + & mask; + out[28 + outOffset] = ((curInputValue17 >>> 16) | (curInputValue18 << 16)) + & mask; + out[29 + outOffset] = (curInputValue18 >>> 4) & mask; + out[30 + outOffset] = ((curInputValue18 >>> 24) | (curInputValue19 << 8)) + & mask; + out[31 + outOffset] = curInputValue19 >>> 12; + outOffset += 32; + } } - } - static private void unpack28(int[] out, IntBuffer in) { - int outOffset = 0; - final int mask = 268435455; - for (int i = 0; i < 4; ++i) { - int curInputValue0 = in.get(); - int curInputValue1 = in.get(); - int curInputValue2 = in.get(); - int curInputValue3 = in.get(); - int curInputValue4 = in.get(); - int curInputValue5 = in.get(); - int curInputValue6 = in.get(); - int curInputValue7 = in.get(); - int curInputValue8 = in.get(); - int curInputValue9 = in.get(); - int curInputValue10 = in.get(); - int curInputValue11 = in.get(); - int curInputValue12 = in.get(); - int curInputValue13 = in.get(); - int curInputValue14 = in.get(); - int curInputValue15 = in.get(); - int curInputValue16 = in.get(); - int curInputValue17 = in.get(); - int curInputValue18 = in.get(); - int curInputValue19 = in.get(); - int curInputValue20 = in.get(); - int curInputValue21 = in.get(); - int curInputValue22 = in.get(); - int curInputValue23 = in.get(); - int curInputValue24 = in.get(); - int curInputValue25 = in.get(); - int curInputValue26 = in.get(); - int curInputValue27 = in.get(); - out[0 + outOffset] = curInputValue0 & mask; - out[1 + outOffset] = ((curInputValue0 >>> 28) | (curInputValue1 << 4)) & mask; - out[2 + outOffset] = ((curInputValue1 >>> 24) | (curInputValue2 << 8)) & mask; - out[3 + outOffset] = ((curInputValue2 >>> 20) | (curInputValue3 << 12)) & mask; - out[4 + outOffset] = ((curInputValue3 >>> 16) | (curInputValue4 << 16)) & mask; - out[5 + outOffset] = ((curInputValue4 >>> 12) | (curInputValue5 << 20)) & mask; - out[6 + outOffset] = ((curInputValue5 >>> 8) | (curInputValue6 << 24)) & mask; - out[7 + outOffset] = curInputValue6 >>> 4; - out[8 + outOffset] = curInputValue7 & mask; - out[9 + outOffset] = ((curInputValue7 >>> 28) | (curInputValue8 << 4)) & mask; - out[10 + outOffset] = ((curInputValue8 >>> 24) | (curInputValue9 << 8)) & mask; - out[11 + outOffset] = ((curInputValue9 >>> 20) | (curInputValue10 << 12)) & mask; - out[12 + outOffset] = ((curInputValue10 >>> 16) | (curInputValue11 << 16)) & mask; - out[13 + outOffset] = ((curInputValue11 >>> 12) | (curInputValue12 << 20)) & mask; - out[14 + outOffset] = ((curInputValue12 >>> 8) | (curInputValue13 << 24)) & mask; - out[15 + outOffset] = curInputValue13 >>> 4; - out[16 + outOffset] = curInputValue14 & mask; - out[17 + outOffset] = ((curInputValue14 >>> 28) | (curInputValue15 << 4)) & mask; - out[18 + outOffset] = ((curInputValue15 >>> 24) | (curInputValue16 << 8)) & mask; - out[19 + outOffset] = ((curInputValue16 >>> 20) | (curInputValue17 << 12)) & mask; - out[20 + outOffset] = ((curInputValue17 >>> 16) | (curInputValue18 << 16)) & mask; - out[21 + outOffset] = ((curInputValue18 >>> 12) | (curInputValue19 << 20)) & mask; - out[22 + outOffset] = ((curInputValue19 >>> 8) | (curInputValue20 << 24)) & mask; - out[23 + outOffset] = curInputValue20 >>> 4; - out[24 + outOffset] = curInputValue21 & mask; - out[25 + outOffset] = ((curInputValue21 >>> 28) | (curInputValue22 << 4)) & mask; - out[26 + outOffset] = ((curInputValue22 >>> 24) | (curInputValue23 << 8)) & mask; - out[27 + outOffset] = ((curInputValue23 >>> 20) | (curInputValue24 << 12)) & mask; - out[28 + outOffset] = ((curInputValue24 >>> 16) | (curInputValue25 << 16)) & mask; - out[29 + outOffset] = ((curInputValue25 >>> 12) | (curInputValue26 << 20)) & mask; - out[30 + outOffset] = ((curInputValue26 >>> 8) | (curInputValue27 << 24)) & mask; - out[31 + outOffset] = curInputValue27 >>> 4; - outOffset += 32; + static private void unpack28(int[] out, IntBuffer in) { + int outOffset = 0; + final int mask = 268435455; + for (int i = 0; i < 4; ++i) { + int curInputValue0 = in.get(); + int curInputValue1 = in.get(); + int curInputValue2 = in.get(); + int curInputValue3 = in.get(); + int curInputValue4 = in.get(); + int curInputValue5 = in.get(); + int curInputValue6 = in.get(); + int curInputValue7 = in.get(); + int curInputValue8 = in.get(); + int curInputValue9 = in.get(); + int curInputValue10 = in.get(); + int curInputValue11 = in.get(); + int curInputValue12 = in.get(); + int curInputValue13 = in.get(); + int curInputValue14 = in.get(); + int curInputValue15 = in.get(); + int curInputValue16 = in.get(); + int curInputValue17 = in.get(); + int curInputValue18 = in.get(); + int curInputValue19 = in.get(); + int curInputValue20 = in.get(); + int curInputValue21 = in.get(); + int curInputValue22 = in.get(); + int curInputValue23 = in.get(); + int curInputValue24 = in.get(); + int curInputValue25 = in.get(); + int curInputValue26 = in.get(); + int curInputValue27 = in.get(); + out[0 + outOffset] = curInputValue0 & mask; + out[1 + outOffset] = ((curInputValue0 >>> 28) | (curInputValue1 << 4)) + & mask; + out[2 + outOffset] = ((curInputValue1 >>> 24) | (curInputValue2 << 8)) + & mask; + out[3 + outOffset] = ((curInputValue2 >>> 20) | (curInputValue3 << 12)) + & mask; + out[4 + outOffset] = ((curInputValue3 >>> 16) | (curInputValue4 << 16)) + & mask; + out[5 + outOffset] = ((curInputValue4 >>> 12) | (curInputValue5 << 20)) + & mask; + out[6 + outOffset] = ((curInputValue5 >>> 8) | (curInputValue6 << 24)) + & mask; + out[7 + outOffset] = curInputValue6 >>> 4; + out[8 + outOffset] = curInputValue7 & mask; + out[9 + outOffset] = ((curInputValue7 >>> 28) | (curInputValue8 << 4)) + & mask; + out[10 + outOffset] = ((curInputValue8 >>> 24) | (curInputValue9 << 8)) + & mask; + out[11 + outOffset] = ((curInputValue9 >>> 20) | (curInputValue10 << 12)) + & mask; + out[12 + outOffset] = ((curInputValue10 >>> 16) | (curInputValue11 << 16)) + & mask; + out[13 + outOffset] = ((curInputValue11 >>> 12) | (curInputValue12 << 20)) + & mask; + out[14 + outOffset] = ((curInputValue12 >>> 8) | (curInputValue13 << 24)) + & mask; + out[15 + outOffset] = curInputValue13 >>> 4; + out[16 + outOffset] = curInputValue14 & mask; + out[17 + outOffset] = ((curInputValue14 >>> 28) | (curInputValue15 << 4)) + & mask; + out[18 + outOffset] = ((curInputValue15 >>> 24) | (curInputValue16 << 8)) + & mask; + out[19 + outOffset] = ((curInputValue16 >>> 20) | (curInputValue17 << 12)) + & mask; + out[20 + outOffset] = ((curInputValue17 >>> 16) | (curInputValue18 << 16)) + & mask; + out[21 + outOffset] = ((curInputValue18 >>> 12) | (curInputValue19 << 20)) + & mask; + out[22 + outOffset] = ((curInputValue19 >>> 8) | (curInputValue20 << 24)) + & mask; + out[23 + outOffset] = curInputValue20 >>> 4; + out[24 + outOffset] = curInputValue21 & mask; + out[25 + outOffset] = ((curInputValue21 >>> 28) | (curInputValue22 << 4)) + & mask; + out[26 + outOffset] = ((curInputValue22 >>> 24) | (curInputValue23 << 8)) + & mask; + out[27 + outOffset] = ((curInputValue23 >>> 20) | (curInputValue24 << 12)) + & mask; + out[28 + outOffset] = ((curInputValue24 >>> 16) | (curInputValue25 << 16)) + & mask; + out[29 + outOffset] = ((curInputValue25 >>> 12) | (curInputValue26 << 20)) + & mask; + out[30 + outOffset] = ((curInputValue26 >>> 8) | (curInputValue27 << 24)) + & mask; + out[31 + outOffset] = curInputValue27 >>> 4; + outOffset += 32; + } } - } } diff --git a/src/main/java/com/kamikaze/pfordelta/Simple16.java b/src/main/java/com/kamikaze/pfordelta/Simple16.java index b615818..c427f4d 100644 --- a/src/main/java/com/kamikaze/pfordelta/Simple16.java +++ b/src/main/java/com/kamikaze/pfordelta/Simple16.java @@ -7,112 +7,153 @@ */ /** - * Implementation of the Simple16 algorithm for sorted integer arrays. The basic ideas are based on papers from + * Implementation of the Simple16 algorithm for sorted integer arrays. The basic + * ideas are based on papers from * * 1. http://www2008.org/papers/pdf/p387-zhangA.pdf * * 2. http://www2009.org/proceedings/pdf/p401.pdf * - * The maximum possible integer value Simple16 can encode is < 2^28 (this is dertermined by the Simple16 algorithm itself). - * Therefore, in order to use Simple16, the application must write their own code to encode numbers in the range of [2^28, 2^32). - * A simple way is just write those numbers as 32-bit integers (that is, no compression for very big numbers). + * The maximum possible integer value Simple16 can encode is less than 2^28 (this is + * dertermined by the Simple16 algorithm itself). Therefore, in order to use + * Simple16, the application must write their own code to encode numbers in the + * range of [2^28, 2^32). A simple way is just write those numbers as 32-bit + * integers (that is, no compression for very big numbers). */ -@SuppressWarnings("javadoc") public class Simple16 { - private static final int S16_NUMSIZE = 16; - private static final int S16_BITSSIZE = 28; + private static final int S16_NUMSIZE = 16; + private static final int S16_BITSSIZE = 28; - //the possible number of compressed numbers hold in a single 32-bit integer - private static final int[] S16_NUM = {28, 21, 21, 21, 14, 9, 8, 7, 6, 6, 5, 5, 4, 3, 2, 1}; + // the possible number of compressed numbers hold in a single 32-bit + // integer + private static final int[] S16_NUM = { 28, 21, 21, 21, 14, 9, 8, 7, 6, + 6, 5, 5, 4, 3, 2, 1 }; - //the possible number of bits used to compress one number - private static final int[][] S16_BITS = {{1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}, - {2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0}, - {1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0}, - {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0}, - {2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, - {4, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, - {3, 4, 4, 4, 4, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, - {4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, - {5, 5, 5, 5, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, - {4, 4, 5, 5, 5, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, - {6, 6, 6, 5, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, - {5, 5, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, - {7, 7, 7, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, - {10, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, - {14, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, - {28, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}}; + // the possible number of bits used to compress one number + private static final int[][] S16_BITS = { + { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1 }, + { 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 0, 0, 0, 0, 0, 0, 0 }, + { 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, + 1, 0, 0, 0, 0, 0, 0, 0 }, + { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, + 2, 0, 0, 0, 0, 0, 0, 0 }, + { 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0 }, + { 4, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0 }, + { 3, 4, 4, 4, 4, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0 }, + { 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0 }, + { 5, 5, 5, 5, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0 }, + { 4, 4, 5, 5, 5, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0 }, + { 6, 6, 6, 5, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0 }, + { 5, 5, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0 }, + { 7, 7, 7, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0 }, + { 10, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0 }, + { 14, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0 }, + { 28, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0 } }; - /** - * Compress an integer array using Simple16 - * - * @param out the compressed output - * @param outOffset the offset of the output in the number of integers - * @param in the integer input array - * @param inOffset the offset of the input in the number of integers - * @param n the number of elements to be compressed - * @return the number of compressed integers - */ - public static final int s16Compress(int[] out, int outOffset, int[] in, int inOffset, int n, int blockSize) { - int numIdx = 0, j = 0, num = 0, bits = 0; - try { - for (numIdx = 0; numIdx < S16_NUMSIZE; numIdx++) { - out[outOffset] = numIdx << S16_BITSSIZE; - num = (S16_NUM[numIdx] < n) ? S16_NUM[numIdx] : n; + /** + * Compress an integer array using Simple16 + * + * @param out + * the compressed output + * @param outOffset + * the offset of the output in the number of integers + * @param in + * the integer input array + * @param inOffset + * the offset of the input in the number of integers + * @param n + * the number of elements to be compressed + * @param blockSize block size + * @return the number of compressed integers + */ + public static final int s16Compress(int[] out, int outOffset, int[] in, + int inOffset, int n, int blockSize) { + int numIdx = 0, j = 0, num = 0, bits = 0; + try { + for (numIdx = 0; numIdx < S16_NUMSIZE; numIdx++) { + out[outOffset] = numIdx << S16_BITSSIZE; + num = (S16_NUM[numIdx] < n) ? S16_NUM[numIdx] + : n; - for (j = 0, bits = 0; (j < num) && in[inOffset + j] < (1 << S16_BITS[numIdx][j]); ) { - out[outOffset] |= (in[inOffset + j] << bits); - bits += S16_BITS[numIdx][j]; - j++; - } + for (j = 0, bits = 0; (j < num) + && in[inOffset + j] < (1 << S16_BITS[numIdx][j]);) { + out[outOffset] |= (in[inOffset + j] << bits); + bits += S16_BITS[numIdx][j]; + j++; + } - if (j == num) { - return num; + if (j == num) { + return num; + } + } + } catch (Exception e) { + System.out.println("s16Compress: " + "numIdx:" + numIdx + + ",j:" + j + ",num:" + num + ",bits: " + bits); + e.printStackTrace(); } - } - } catch (Exception e) { - System.out.println("s16Compress: " + "numIdx:" + numIdx + ",j:" + j + ",num:" + num + ",bits: " + bits); - e.printStackTrace(); - } - return -1; - } - - /** - * Decompress an integer array using Simple16 - * - * @param out the decompressed output - * @param outOffset the offset of the output in the number of integers - * @param in the compressed input array - * @param inOffset the offset of the input in the number of integers - * @param n the number of elements to be compressed - * @return the number of processed integers - */ - public static final int s16Decompress(int[] out, int outOffset, int[] in, int inOffset, int n) { - int numIdx, j = 0, bits = 0; - numIdx = in[inOffset] >>> S16_BITSSIZE; - int num = S16_NUM[numIdx] < n ? S16_NUM[numIdx] : n; - for (j = 0, bits = 0; j < num; j++) { - out[outOffset + j] = readBitsForS16(in, inOffset, bits, S16_BITS[numIdx][j]); - bits += S16_BITS[numIdx][j]; + return -1; } - return num; - } + /** + * Decompress an integer array using Simple16 + * + * @param out + * the decompressed output + * @param outOffset + * the offset of the output in the number of integers + * @param in + * the compressed input array + * @param inOffset + * the offset of the input in the number of integers + * @param n + * the number of elements to be compressed + * @return the number of processed integers + */ + public static final int s16Decompress(int[] out, int outOffset, + int[] in, int inOffset, int n) { + int numIdx, j = 0, bits = 0; + numIdx = in[inOffset] >>> S16_BITSSIZE; + int num = S16_NUM[numIdx] < n ? S16_NUM[numIdx] : n; + for (j = 0, bits = 0; j < num; j++) { + out[outOffset + j] = readBitsForS16(in, inOffset, bits, + S16_BITS[numIdx][j]); + bits += S16_BITS[numIdx][j]; + } + return num; + } - /** - * Read a certain number of bits of a integer on the input array - * - * @param in the input array - * @param inIntOffset the start offset in ints in the input array - * @param inWithIntOffset the start offset within a int in the input array - * @param bits the number of bits to be read - * @return the bits bits of the input - */ - static private int readBitsForS16(int[] in, final int inIntOffset, final int inWithIntOffset, final int bits) { - final int val = (in[inIntOffset] >>> inWithIntOffset); - return val & (0xffffffff >>> (32 - bits)); - } + /** + * Read a certain number of bits of a integer on the input array + * + * @param in + * the input array + * @param inIntOffset + * the start offset in ints in the input array + * @param inWithIntOffset + * the start offset within a int in the input array + * @param bits + * the number of bits to be read + * @return the bits bits of the input + */ + static private int readBitsForS16(int[] in, final int inIntOffset, + final int inWithIntOffset, final int bits) { + final int val = (in[inIntOffset] >>> inWithIntOffset); + return val & (0xffffffff >>> (32 - bits)); + } } - diff --git a/src/main/java/com/kamikaze/pfordelta/Simple16WithHardCodes.java b/src/main/java/com/kamikaze/pfordelta/Simple16WithHardCodes.java index 6965176..b371360 100644 --- a/src/main/java/com/kamikaze/pfordelta/Simple16WithHardCodes.java +++ b/src/main/java/com/kamikaze/pfordelta/Simple16WithHardCodes.java @@ -7,635 +7,696 @@ */ /** - * Implementation of the Simple16 algorithm for sorted integer arrays. The basic ideas are based on papers from + * Implementation of the Simple16 algorithm for sorted integer arrays. The basic + * ideas are based on papers from * * 1. http://www2008.org/papers/pdf/p387-zhangA.pdf * * 2. http://www2009.org/proceedings/pdf/p401.pdf * - * The maximum possible integer value Simple16 can encode is < 2^28 (this is dertermined by the Simple16 algorithm itself). - * Therefore, in order to use Simple16, the application must write their own code to encode numbers in the range of [2^28, 2^32). - * A simple way is just write those numbers as 32-bit integers (that is, no compression for very big numbers). + * The maximum possible integer value Simple16 can encode is less than 2^28 (this is + * dertermined by the Simple16 algorithm itself). Therefore, in order to use + * Simple16, the application must write their own code to encode numbers in the + * range of [2^28, 2^32). A simple way is just write those numbers as 32-bit + * integers (that is, no compression for very big numbers). * - * Compared to Simple16, Simple16WithHardCodes will decompress each compressed integer using hardwired codes, - * resulting in faster decompression speed. However, it will sacrifice with slightly larger index size. + * Compared to Simple16, Simple16WithHardCodes will decompress each compressed + * integer using hardwired codes, resulting in faster decompression speed. + * However, it will sacrifice with slightly larger index size. * * Author: Hao Yan, hyan2008@gmail.com */ -@SuppressWarnings("javadoc") public class Simple16WithHardCodes { - private static final int S16_NUMSIZE = 16; - private static final int S16_BITSSIZE = 28; + private static final int S16_NUMSIZE = 16; + private static final int S16_BITSSIZE = 28; + + // the possible number of compressed numbers hold in a single 32-bit + // integer + private static final int[] S16_NUM = { 28, 21, 21, 21, 14, 9, 8, 7, 6, + 6, 5, 5, 4, 3, 2, 1 }; + + // the possible number of bits used to compress one number + private static final int[][] S16_BITS = { + { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1 }, + { 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 0, 0, 0, 0, 0, 0, 0 }, + { 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, + 1, 0, 0, 0, 0, 0, 0, 0 }, + { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, + 2, 0, 0, 0, 0, 0, 0, 0 }, + { 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0 }, + { 4, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0 }, + { 3, 4, 4, 4, 4, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0 }, + { 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0 }, + { 5, 5, 5, 5, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0 }, + { 4, 4, 5, 5, 5, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0 }, + { 6, 6, 6, 5, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0 }, + { 5, 5, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0 }, + { 7, 7, 7, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0 }, + { 10, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0 }, + { 14, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0 }, + { 28, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0 } }; + + /** + * Compress an integer array using Simple16 + * + * @param out + * the compressed output + * @param outOffset + * the offset of the output in the number of integers + * @param in + * the integer input array + * @param inOffset + * the offset of the input in the number of integers + * @param n + * the number of elements to be compressed + * @param blockSize block size + * @param oriBlockSize ori block size + * @param oriInputBlock ori input block + * @return the number of compressed integers + */ + public static final int s16Compress(int[] out, int outOffset, int[] in, + int inOffset, int n, int blockSize, int oriBlockSize, + int[] oriInputBlock) { + int numIdx, j, num, bits; + for (numIdx = 0; numIdx < S16_NUMSIZE; numIdx++) { + out[outOffset] = numIdx << S16_BITSSIZE; + // num = (S16_NUM[numIdx] < n) ? S16_NUM[numIdx] : n; + + if (S16_NUM[numIdx] > n) + continue; + num = S16_NUM[numIdx]; + + for (j = 0, bits = 0; (j < num) + && in[inOffset + j] < (1 << S16_BITS[numIdx][j]);) { + out[outOffset] |= (in[inOffset + j] << bits); + bits += S16_BITS[numIdx][j]; + j++; + } + + if (j == num) { + return num; + } + } - //the possible number of compressed numbers hold in a single 32-bit integer - private static final int[] S16_NUM = {28, 21, 21, 21, 14, 9, 8, 7, 6, 6, 5, 5, 4, 3, 2, 1}; + return -1; + } - //the possible number of bits used to compress one number - private static final int[][] S16_BITS = {{1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}, - {2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0}, - {1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0}, - {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0}, - {2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, - {4, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, - {3, 4, 4, 4, 4, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, - {4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, - {5, 5, 5, 5, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, - {4, 4, 5, 5, 5, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, - {6, 6, 6, 5, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, - {5, 5, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, - {7, 7, 7, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, - {10, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, - {14, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, - {28, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}}; - /** - * Compress an integer array using Simple16 - * - * @param out the compressed output - * @param outOffset the offset of the output in the number of integers - * @param in the integer input array - * @param inOffset the offset of the input in the number of integers - * @param n the number of elements to be compressed - * @return the number of compressed integers - */ - public static final int s16Compress(int[] out, int outOffset, int[] in, int inOffset, int n, int blockSize, int oriBlockSize, int[] oriInputBlock) { - int numIdx, j, num, bits; - for (numIdx = 0; numIdx < S16_NUMSIZE; numIdx++) { - out[outOffset] = numIdx << S16_BITSSIZE; - //num = (S16_NUM[numIdx] < n) ? S16_NUM[numIdx] : n; + protected static final int s16CompressBackup(int[] out, int outOffset, + int[] in, int inOffset, int n, int blockSize, int oriBlockSize, + int[] oriInputBlock) { + int numIdx, j, num, bits; + for (numIdx = 0; numIdx < S16_NUMSIZE; numIdx++) { + out[outOffset] = numIdx << S16_BITSSIZE; + num = (S16_NUM[numIdx] < n) ? S16_NUM[numIdx] : n; - if (S16_NUM[numIdx] > n) continue; - num = S16_NUM[numIdx]; + for (j = 0, bits = 0; (j < num) + && in[inOffset + j] < (1 << S16_BITS[numIdx][j]);) { + out[outOffset] |= (in[inOffset + j] << bits); + bits += S16_BITS[numIdx][j]; + j++; + } - for (j = 0, bits = 0; (j < num) && in[inOffset + j] < (1 << S16_BITS[numIdx][j]); ) { - out[outOffset] |= (in[inOffset + j] << bits); - bits += S16_BITS[numIdx][j]; - j++; - } + if (j == num) { + return num; + } + } - if (j == num) { - return num; - } + return -1; } - return -1; - } - - public static final int s16CompressBackup(int[] out, int outOffset, int[] in, int inOffset, int n, int blockSize, int oriBlockSize, int[] oriInputBlock) { - int numIdx, j, num, bits; - for (numIdx = 0; numIdx < S16_NUMSIZE; numIdx++) { - out[outOffset] = numIdx << S16_BITSSIZE; - num = (S16_NUM[numIdx] < n) ? S16_NUM[numIdx] : n; - - for (j = 0, bits = 0; (j < num) && in[inOffset + j] < (1 << S16_BITS[numIdx][j]); ) { - out[outOffset] |= (in[inOffset + j] << bits); - bits += S16_BITS[numIdx][j]; - j++; - } - - if (j == num) { + /** + * Decompress an integer array using Simple16 + * + * @param out + * the decompressed output + * @param outOffset + * the offset of the output in the number of integers + * @param in + * the compressed input array + * @param inOffset + * the offset of the input in the number of integers + * @param n + * the number of elements to be compressed + * @return the number of processed integers + */ + protected static final int s16Decompress(int[] out, int outOffset, + int[] in, int inOffset, int n) { + int numIdx, j = 0, bits = 0; + numIdx = in[inOffset] >>> S16_BITSSIZE; + int num = S16_NUM[numIdx] < n ? S16_NUM[numIdx] : n; + for (j = 0, bits = 0; j < num; j++) { + out[outOffset + j] = readBitsForS16(in, inOffset, bits, + S16_BITS[numIdx][j]); + bits += S16_BITS[numIdx][j]; + } return num; - } } - return -1; - } - - /** - * Decompress an integer array using Simple16 - * - * @param out the decompressed output - * @param outOffset the offset of the output in the number of integers - * @param in the compressed input array - * @param inOffset the offset of the input in the number of integers - * @param n the number of elements to be compressed - * @return the number of processed integers - */ - public static final int s16Decompress(int[] out, int outOffset, int[] in, int inOffset, int n) { - int numIdx, j = 0, bits = 0; - numIdx = in[inOffset] >>> S16_BITSSIZE; - int num = S16_NUM[numIdx] < n ? S16_NUM[numIdx] : n; - for (j = 0, bits = 0; j < num; j++) { - out[outOffset + j] = readBitsForS16(in, inOffset, bits, S16_BITS[numIdx][j]); - bits += S16_BITS[numIdx][j]; + protected static final int s16DecompressWithIntBufferBackup( + final int[] out, int outOffset, final int value, final int n) { + int j = 0, shift; + final int numIdx = value >>> S16_BITSSIZE; + final int num = S16_NUM[numIdx] < n ? S16_NUM[numIdx] : n; + int s16Bits; + for (shift = 0; j < num; ++j) { + s16Bits = S16_BITS[numIdx][j]; + out[outOffset++] = (value >>> shift) + & (0xffffffff >>> (32 - s16Bits)); + shift += s16Bits; + } + return num; } - return num; - } - public static final int s16DecompressWithIntBufferBackup(final int[] out, int outOffset, final int value, final int n) { - int j = 0, shift; - final int numIdx = value >>> S16_BITSSIZE; - final int num = S16_NUM[numIdx] < n ? S16_NUM[numIdx] : n; - int s16Bits; - for (shift = 0; j < num; ++j) { - s16Bits = S16_BITS[numIdx][j]; - out[outOffset++] = (value >>> shift) & (0xffffffff >>> (32 - s16Bits)); - shift += s16Bits; + protected static final int s16DecompressWithIntBuffer(final int[] out, + int outOffset, final int value, final int n) { + int j = 0, shift; + final int numIdx = value >>> S16_BITSSIZE; + + final int num = S16_NUM[numIdx]; + int s16Bits; + for (shift = 0; j < num; ++j) { + s16Bits = S16_BITS[numIdx][j]; + out[outOffset++] = (value >>> shift) + & (0xffffffff >>> (32 - s16Bits)); + shift += s16Bits; + } + return num; } - return num; - } - - public static final int s16DecompressWithIntBuffer(final int[] out, int outOffset, final int value, final int n) { - int j = 0, shift; - final int numIdx = value >>> S16_BITSSIZE; - final int num = S16_NUM[numIdx]; - int s16Bits; - for (shift = 0; j < num; ++j) { - s16Bits = S16_BITS[numIdx][j]; - out[outOffset++] = (value >>> shift) & (0xffffffff >>> (32 - s16Bits)); - shift += s16Bits; + protected static final int s16DecompressWithIntBufferWithHardCodes( + final int[] out, int outOffset, final int value, final int n) { + final int numIdx = value >>> S16_BITSSIZE; + return s16DecompressOneNumberWithHardCodes(out, outOffset, + value, numIdx); } - return num; - } - - public static final int s16DecompressWithIntBufferWithHardCodes(final int[] out, int outOffset, final int value, final int n) { - final int numIdx = value >>> S16_BITSSIZE; - return s16DecompressOneNumberWithHardCodes(out, outOffset, value, numIdx); - } - - public static final int s16DecompressWithIntBufferIntegrated(final int[] out, int outOffset, final int value, final int n, int[] expPos, int oribits) { - int j = 0, shift = 0; - final int numIdx = value >>> S16_BITSSIZE; - - final int num = S16_NUM[numIdx]; - int s16Bits; - for (; j < num; ++j) { - s16Bits = S16_BITS[numIdx][j]; - out[expPos[outOffset + j]] |= (((value >>> shift) & (0xffffffff >>> (32 - s16Bits))) << oribits); - shift += s16Bits; + protected static final int s16DecompressWithIntBufferIntegrated( + final int[] out, int outOffset, final int value, final int n, + int[] expPos, int oribits) { + int j = 0, shift = 0; + final int numIdx = value >>> S16_BITSSIZE; + + final int num = S16_NUM[numIdx]; + int s16Bits; + for (; j < num; ++j) { + s16Bits = S16_BITS[numIdx][j]; + out[expPos[outOffset + j]] |= (((value >>> shift) & (0xffffffff >>> (32 - s16Bits))) << oribits); + shift += s16Bits; + } + return num; } - return num; - } - public static final int s16DecompressWithIntBufferIntegrated2(final int[] out, int outOffset, final int value, final int n, int[] expPos, int oribits) { - final int numIdx = value >>> S16_BITSSIZE; - return s16DecompressOneNumberWithHardCodesIntegrated(out, outOffset, value, numIdx, oribits, expPos); - } - - - public static final int s16DecompressWithIntBufferIntegratedBackup(final int[] out, int outOffset, final int value, final int n, int[] expPos, int oribits) { - int j = 0, shift = 0; - final int numIdx = value >>> S16_BITSSIZE; - final int num = S16_NUM[numIdx] < n ? S16_NUM[numIdx] : n; - int s16Bits; - for (; j < num; ++j, ++outOffset) { - s16Bits = S16_BITS[numIdx][j]; - out[expPos[outOffset]] |= (((value >>> shift) & (0xffffffff >>> (32 - s16Bits))) << oribits); - shift += s16Bits; + protected static final int s16DecompressWithIntBufferIntegrated2( + final int[] out, int outOffset, final int value, final int n, + int[] expPos, int oribits) { + final int numIdx = value >>> S16_BITSSIZE; + return s16DecompressOneNumberWithHardCodesIntegrated(out, + outOffset, value, numIdx, oribits, expPos); } - return num; - } - public static int s16DecompressOneNumberWithHardCodes(int[] out, int outOffset, int value, int numIdx) { - switch (numIdx) { - case 0: { - out[outOffset] = value & 0x00000001; - out[outOffset + 1] = (value >>> 1) & 0x00000001; - out[outOffset + 2] = (value >>> 2) & 0x00000001; - out[outOffset + 3] = (value >>> 3) & 0x00000001; - out[outOffset + 4] = (value >>> 4) & 0x00000001; - out[outOffset + 5] = (value >>> 5) & 0x00000001; - out[outOffset + 6] = (value >>> 6) & 0x00000001; - out[outOffset + 7] = (value >>> 7) & 0x00000001; - out[outOffset + 8] = (value >>> 8) & 0x00000001; - out[outOffset + 9] = (value >>> 9) & 0x00000001; - out[outOffset + 10] = (value >>> 10) & 0x00000001; - out[outOffset + 11] = (value >>> 11) & 0x00000001; - out[outOffset + 12] = (value >>> 12) & 0x00000001; - out[outOffset + 13] = (value >>> 13) & 0x00000001; - out[outOffset + 14] = (value >>> 14) & 0x00000001; - out[outOffset + 15] = (value >>> 15) & 0x00000001; - out[outOffset + 16] = (value >>> 16) & 0x00000001; - out[outOffset + 17] = (value >>> 17) & 0x00000001; - out[outOffset + 18] = (value >>> 18) & 0x00000001; - out[outOffset + 19] = (value >>> 19) & 0x00000001; - out[outOffset + 20] = (value >>> 20) & 0x00000001; - out[outOffset + 21] = (value >>> 21) & 0x00000001; - out[outOffset + 22] = (value >>> 22) & 0x00000001; - out[outOffset + 23] = (value >>> 23) & 0x00000001; - out[outOffset + 24] = (value >>> 24) & 0x00000001; - out[outOffset + 25] = (value >>> 25) & 0x00000001; - out[outOffset + 26] = (value >>> 26) & 0x00000001; - out[outOffset + 27] = (value >>> 27) & 0x00000001; - return 28; - } - case 1: { - out[outOffset] = value & 0x00000003; - out[outOffset + 1] = (value >>> 2) & 0x00000003; - out[outOffset + 2] = (value >>> 4) & 0x00000003; - out[outOffset + 3] = (value >>> 6) & 0x00000003; - out[outOffset + 4] = (value >>> 8) & 0x00000003; - out[outOffset + 5] = (value >>> 10) & 0x00000003; - out[outOffset + 6] = (value >>> 12) & 0x00000003; - out[outOffset + 7] = (value >>> 14) & 0x00000001; - out[outOffset + 8] = (value >>> 15) & 0x00000001; - out[outOffset + 9] = (value >>> 16) & 0x00000001; - out[outOffset + 10] = (value >>> 17) & 0x00000001; - out[outOffset + 11] = (value >>> 18) & 0x00000001; - out[outOffset + 12] = (value >>> 19) & 0x00000001; - out[outOffset + 13] = (value >>> 20) & 0x00000001; - out[outOffset + 14] = (value >>> 21) & 0x00000001; - out[outOffset + 15] = (value >>> 22) & 0x00000001; - out[outOffset + 16] = (value >>> 23) & 0x00000001; - out[outOffset + 17] = (value >>> 24) & 0x00000001; - out[outOffset + 18] = (value >>> 25) & 0x00000001; - out[outOffset + 19] = (value >>> 26) & 0x00000001; - out[outOffset + 20] = (value >>> 27) & 0x00000001; - return 21; - } - case 2: { - out[outOffset] = value & 0x00000001; - out[outOffset + 1] = (value >>> 1) & 0x00000001; - out[outOffset + 2] = (value >>> 2) & 0x00000001; - out[outOffset + 3] = (value >>> 3) & 0x00000001; - out[outOffset + 4] = (value >>> 4) & 0x00000001; - out[outOffset + 5] = (value >>> 5) & 0x00000001; - out[outOffset + 6] = (value >>> 6) & 0x00000001; - out[outOffset + 7] = (value >>> 7) & 0x00000003; - out[outOffset + 8] = (value >>> 9) & 0x00000003; - out[outOffset + 9] = (value >>> 11) & 0x00000003; - out[outOffset + 10] = (value >>> 13) & 0x00000003; - out[outOffset + 11] = (value >>> 15) & 0x00000003; - out[outOffset + 12] = (value >>> 17) & 0x00000003; - out[outOffset + 13] = (value >>> 19) & 0x00000003; - out[outOffset + 14] = (value >>> 21) & 0x00000001; - out[outOffset + 15] = (value >>> 22) & 0x00000001; - out[outOffset + 16] = (value >>> 23) & 0x00000001; - out[outOffset + 17] = (value >>> 24) & 0x00000001; - out[outOffset + 18] = (value >>> 25) & 0x00000001; - out[outOffset + 19] = (value >>> 26) & 0x00000001; - out[outOffset + 20] = (value >>> 27) & 0x00000001; - return 21; - } - case 3: { - out[outOffset] = value & 0x00000001; - out[outOffset + 1] = (value >>> 1) & 0x00000001; - out[outOffset + 2] = (value >>> 2) & 0x00000001; - out[outOffset + 3] = (value >>> 3) & 0x00000001; - out[outOffset + 4] = (value >>> 4) & 0x00000001; - out[outOffset + 5] = (value >>> 5) & 0x00000001; - out[outOffset + 6] = (value >>> 6) & 0x00000001; - out[outOffset + 7] = (value >>> 7) & 0x00000001; - out[outOffset + 8] = (value >>> 8) & 0x00000001; - out[outOffset + 9] = (value >>> 9) & 0x00000001; - out[outOffset + 10] = (value >>> 10) & 0x00000001; - out[outOffset + 11] = (value >>> 11) & 0x00000001; - out[outOffset + 12] = (value >>> 12) & 0x00000001; - out[outOffset + 13] = (value >>> 13) & 0x00000001; - out[outOffset + 14] = (value >>> 14) & 0x00000003; - out[outOffset + 15] = (value >>> 16) & 0x00000003; - out[outOffset + 16] = (value >>> 18) & 0x00000003; - out[outOffset + 17] = (value >>> 20) & 0x00000003; - out[outOffset + 18] = (value >>> 22) & 0x00000003; - out[outOffset + 19] = (value >>> 24) & 0x00000003; - out[outOffset + 20] = (value >>> 26) & 0x00000003; - return 21; - } - case 4: { - out[outOffset] = value & 0x00000003; - out[outOffset + 1] = (value >>> 2) & 0x00000003; - out[outOffset + 2] = (value >>> 4) & 0x00000003; - out[outOffset + 3] = (value >>> 6) & 0x00000003; - out[outOffset + 4] = (value >>> 8) & 0x00000003; - out[outOffset + 5] = (value >>> 10) & 0x00000003; - out[outOffset + 6] = (value >>> 12) & 0x00000003; - out[outOffset + 7] = (value >>> 14) & 0x00000003; - out[outOffset + 8] = (value >>> 16) & 0x00000003; - out[outOffset + 9] = (value >>> 18) & 0x00000003; - out[outOffset + 10] = (value >>> 20) & 0x00000003; - out[outOffset + 11] = (value >>> 22) & 0x00000003; - out[outOffset + 12] = (value >>> 24) & 0x00000003; - out[outOffset + 13] = (value >>> 26) & 0x00000003; - return 14; - } - case 5: { - out[outOffset] = value & 0x0000000f; - out[outOffset + 1] = (value >>> 4) & 0x00000007; - out[outOffset + 2] = (value >>> 7) & 0x00000007; - out[outOffset + 3] = (value >>> 10) & 0x00000007; - out[outOffset + 4] = (value >>> 13) & 0x00000007; - out[outOffset + 5] = (value >>> 16) & 0x00000007; - out[outOffset + 6] = (value >>> 19) & 0x00000007; - out[outOffset + 7] = (value >>> 22) & 0x00000007; - out[outOffset + 8] = (value >>> 25) & 0x00000007; - return 9; - } - case 6: { - out[outOffset] = value & 0x00000007; - out[outOffset + 1] = (value >>> 3) & 0x0000000f; - out[outOffset + 2] = (value >>> 7) & 0x0000000f; - out[outOffset + 3] = (value >>> 11) & 0x0000000f; - out[outOffset + 4] = (value >>> 15) & 0x0000000f; - out[outOffset + 5] = (value >>> 19) & 0x00000007; - out[outOffset + 6] = (value >>> 22) & 0x00000007; - out[outOffset + 7] = (value >>> 25) & 0x00000007; - return 8; - } - case 7: { - out[outOffset] = value & 0x0000000f; - out[outOffset + 1] = (value >>> 4) & 0x0000000f; - out[outOffset + 2] = (value >>> 8) & 0x0000000f; - out[outOffset + 3] = (value >>> 12) & 0x0000000f; - out[outOffset + 4] = (value >>> 16) & 0x0000000f; - out[outOffset + 5] = (value >>> 20) & 0x0000000f; - out[outOffset + 6] = (value >>> 24) & 0x0000000f; - return 7; - } - case 8: { - out[outOffset] = value & 0x0000001f; - out[outOffset + 1] = (value >>> 5) & 0x0000001f; - out[outOffset + 2] = (value >>> 10) & 0x0000001f; - out[outOffset + 3] = (value >>> 15) & 0x0000001f; - out[outOffset + 4] = (value >>> 20) & 0x0000000f; - out[outOffset + 5] = (value >>> 24) & 0x0000000f; - return 6; - } - case 9: { - out[outOffset] = value & 0x0000000f; - out[outOffset + 1] = (value >>> 4) & 0x0000000f; - out[outOffset + 2] = (value >>> 8) & 0x0000001f; - out[outOffset + 3] = (value >>> 13) & 0x0000001f; - out[outOffset + 4] = (value >>> 18) & 0x0000001f; - out[outOffset + 5] = (value >>> 23) & 0x0000001f; - return 6; - } - case 10: { - out[outOffset] = value & 0x0000003f; - out[outOffset + 1] = (value >>> 6) & 0x0000003f; - out[outOffset + 2] = (value >>> 12) & 0x0000003f; - out[outOffset + 3] = (value >>> 18) & 0x0000001f; - out[outOffset + 4] = (value >>> 23) & 0x0000001f; - return 5; - } - case 11: { - out[outOffset] = value & 0x0000001f; - out[outOffset + 1] = (value >>> 5) & 0x0000001f; - out[outOffset + 2] = (value >>> 10) & 0x0000003f; - out[outOffset + 3] = (value >>> 16) & 0x0000003f; - out[outOffset + 4] = (value >>> 22) & 0x0000003f; - return 5; - } - case 12: { - out[outOffset] = value & 0x0000007f; - out[outOffset + 1] = (value >>> 7) & 0x0000007f; - out[outOffset + 2] = (value >>> 14) & 0x0000007f; - out[outOffset + 3] = (value >>> 21) & 0x0000007f; - return 4; - } - case 13: { - out[outOffset] = value & 0x000003ff; - out[outOffset + 1] = (value >>> 10) & 0x000001ff; - out[outOffset + 2] = (value >>> 19) & 0x000001ff; - return 3; - } - case 14: { - out[outOffset] = value & 0x00003fff; - out[outOffset + 1] = (value >>> 14) & 0x00003fff; - return 2; - } - case 15: { - out[outOffset] = value & 0x0fffffff; - return 1; - } - default: - return -1; + protected static final int s16DecompressWithIntBufferIntegratedBackup( + final int[] out, int outOffset, final int value, final int n, + int[] expPos, int oribits) { + int j = 0, shift = 0; + final int numIdx = value >>> S16_BITSSIZE; + final int num = S16_NUM[numIdx] < n ? S16_NUM[numIdx] : n; + int s16Bits; + for (; j < num; ++j, ++outOffset) { + s16Bits = S16_BITS[numIdx][j]; + out[expPos[outOffset]] |= (((value >>> shift) & (0xffffffff >>> (32 - s16Bits))) << oribits); + shift += s16Bits; + } + return num; } - } + protected static int s16DecompressOneNumberWithHardCodes(int[] out, + int outOffset, int value, int numIdx) { + switch (numIdx) { + case 0: { + out[outOffset] = value & 0x00000001; + out[outOffset + 1] = (value >>> 1) & 0x00000001; + out[outOffset + 2] = (value >>> 2) & 0x00000001; + out[outOffset + 3] = (value >>> 3) & 0x00000001; + out[outOffset + 4] = (value >>> 4) & 0x00000001; + out[outOffset + 5] = (value >>> 5) & 0x00000001; + out[outOffset + 6] = (value >>> 6) & 0x00000001; + out[outOffset + 7] = (value >>> 7) & 0x00000001; + out[outOffset + 8] = (value >>> 8) & 0x00000001; + out[outOffset + 9] = (value >>> 9) & 0x00000001; + out[outOffset + 10] = (value >>> 10) & 0x00000001; + out[outOffset + 11] = (value >>> 11) & 0x00000001; + out[outOffset + 12] = (value >>> 12) & 0x00000001; + out[outOffset + 13] = (value >>> 13) & 0x00000001; + out[outOffset + 14] = (value >>> 14) & 0x00000001; + out[outOffset + 15] = (value >>> 15) & 0x00000001; + out[outOffset + 16] = (value >>> 16) & 0x00000001; + out[outOffset + 17] = (value >>> 17) & 0x00000001; + out[outOffset + 18] = (value >>> 18) & 0x00000001; + out[outOffset + 19] = (value >>> 19) & 0x00000001; + out[outOffset + 20] = (value >>> 20) & 0x00000001; + out[outOffset + 21] = (value >>> 21) & 0x00000001; + out[outOffset + 22] = (value >>> 22) & 0x00000001; + out[outOffset + 23] = (value >>> 23) & 0x00000001; + out[outOffset + 24] = (value >>> 24) & 0x00000001; + out[outOffset + 25] = (value >>> 25) & 0x00000001; + out[outOffset + 26] = (value >>> 26) & 0x00000001; + out[outOffset + 27] = (value >>> 27) & 0x00000001; + return 28; + } + case 1: { + out[outOffset] = value & 0x00000003; + out[outOffset + 1] = (value >>> 2) & 0x00000003; + out[outOffset + 2] = (value >>> 4) & 0x00000003; + out[outOffset + 3] = (value >>> 6) & 0x00000003; + out[outOffset + 4] = (value >>> 8) & 0x00000003; + out[outOffset + 5] = (value >>> 10) & 0x00000003; + out[outOffset + 6] = (value >>> 12) & 0x00000003; + out[outOffset + 7] = (value >>> 14) & 0x00000001; + out[outOffset + 8] = (value >>> 15) & 0x00000001; + out[outOffset + 9] = (value >>> 16) & 0x00000001; + out[outOffset + 10] = (value >>> 17) & 0x00000001; + out[outOffset + 11] = (value >>> 18) & 0x00000001; + out[outOffset + 12] = (value >>> 19) & 0x00000001; + out[outOffset + 13] = (value >>> 20) & 0x00000001; + out[outOffset + 14] = (value >>> 21) & 0x00000001; + out[outOffset + 15] = (value >>> 22) & 0x00000001; + out[outOffset + 16] = (value >>> 23) & 0x00000001; + out[outOffset + 17] = (value >>> 24) & 0x00000001; + out[outOffset + 18] = (value >>> 25) & 0x00000001; + out[outOffset + 19] = (value >>> 26) & 0x00000001; + out[outOffset + 20] = (value >>> 27) & 0x00000001; + return 21; + } + case 2: { + out[outOffset] = value & 0x00000001; + out[outOffset + 1] = (value >>> 1) & 0x00000001; + out[outOffset + 2] = (value >>> 2) & 0x00000001; + out[outOffset + 3] = (value >>> 3) & 0x00000001; + out[outOffset + 4] = (value >>> 4) & 0x00000001; + out[outOffset + 5] = (value >>> 5) & 0x00000001; + out[outOffset + 6] = (value >>> 6) & 0x00000001; + out[outOffset + 7] = (value >>> 7) & 0x00000003; + out[outOffset + 8] = (value >>> 9) & 0x00000003; + out[outOffset + 9] = (value >>> 11) & 0x00000003; + out[outOffset + 10] = (value >>> 13) & 0x00000003; + out[outOffset + 11] = (value >>> 15) & 0x00000003; + out[outOffset + 12] = (value >>> 17) & 0x00000003; + out[outOffset + 13] = (value >>> 19) & 0x00000003; + out[outOffset + 14] = (value >>> 21) & 0x00000001; + out[outOffset + 15] = (value >>> 22) & 0x00000001; + out[outOffset + 16] = (value >>> 23) & 0x00000001; + out[outOffset + 17] = (value >>> 24) & 0x00000001; + out[outOffset + 18] = (value >>> 25) & 0x00000001; + out[outOffset + 19] = (value >>> 26) & 0x00000001; + out[outOffset + 20] = (value >>> 27) & 0x00000001; + return 21; + } + case 3: { + out[outOffset] = value & 0x00000001; + out[outOffset + 1] = (value >>> 1) & 0x00000001; + out[outOffset + 2] = (value >>> 2) & 0x00000001; + out[outOffset + 3] = (value >>> 3) & 0x00000001; + out[outOffset + 4] = (value >>> 4) & 0x00000001; + out[outOffset + 5] = (value >>> 5) & 0x00000001; + out[outOffset + 6] = (value >>> 6) & 0x00000001; + out[outOffset + 7] = (value >>> 7) & 0x00000001; + out[outOffset + 8] = (value >>> 8) & 0x00000001; + out[outOffset + 9] = (value >>> 9) & 0x00000001; + out[outOffset + 10] = (value >>> 10) & 0x00000001; + out[outOffset + 11] = (value >>> 11) & 0x00000001; + out[outOffset + 12] = (value >>> 12) & 0x00000001; + out[outOffset + 13] = (value >>> 13) & 0x00000001; + out[outOffset + 14] = (value >>> 14) & 0x00000003; + out[outOffset + 15] = (value >>> 16) & 0x00000003; + out[outOffset + 16] = (value >>> 18) & 0x00000003; + out[outOffset + 17] = (value >>> 20) & 0x00000003; + out[outOffset + 18] = (value >>> 22) & 0x00000003; + out[outOffset + 19] = (value >>> 24) & 0x00000003; + out[outOffset + 20] = (value >>> 26) & 0x00000003; + return 21; + } + case 4: { + out[outOffset] = value & 0x00000003; + out[outOffset + 1] = (value >>> 2) & 0x00000003; + out[outOffset + 2] = (value >>> 4) & 0x00000003; + out[outOffset + 3] = (value >>> 6) & 0x00000003; + out[outOffset + 4] = (value >>> 8) & 0x00000003; + out[outOffset + 5] = (value >>> 10) & 0x00000003; + out[outOffset + 6] = (value >>> 12) & 0x00000003; + out[outOffset + 7] = (value >>> 14) & 0x00000003; + out[outOffset + 8] = (value >>> 16) & 0x00000003; + out[outOffset + 9] = (value >>> 18) & 0x00000003; + out[outOffset + 10] = (value >>> 20) & 0x00000003; + out[outOffset + 11] = (value >>> 22) & 0x00000003; + out[outOffset + 12] = (value >>> 24) & 0x00000003; + out[outOffset + 13] = (value >>> 26) & 0x00000003; + return 14; + } + case 5: { + out[outOffset] = value & 0x0000000f; + out[outOffset + 1] = (value >>> 4) & 0x00000007; + out[outOffset + 2] = (value >>> 7) & 0x00000007; + out[outOffset + 3] = (value >>> 10) & 0x00000007; + out[outOffset + 4] = (value >>> 13) & 0x00000007; + out[outOffset + 5] = (value >>> 16) & 0x00000007; + out[outOffset + 6] = (value >>> 19) & 0x00000007; + out[outOffset + 7] = (value >>> 22) & 0x00000007; + out[outOffset + 8] = (value >>> 25) & 0x00000007; + return 9; + } + case 6: { + out[outOffset] = value & 0x00000007; + out[outOffset + 1] = (value >>> 3) & 0x0000000f; + out[outOffset + 2] = (value >>> 7) & 0x0000000f; + out[outOffset + 3] = (value >>> 11) & 0x0000000f; + out[outOffset + 4] = (value >>> 15) & 0x0000000f; + out[outOffset + 5] = (value >>> 19) & 0x00000007; + out[outOffset + 6] = (value >>> 22) & 0x00000007; + out[outOffset + 7] = (value >>> 25) & 0x00000007; + return 8; + } + case 7: { + out[outOffset] = value & 0x0000000f; + out[outOffset + 1] = (value >>> 4) & 0x0000000f; + out[outOffset + 2] = (value >>> 8) & 0x0000000f; + out[outOffset + 3] = (value >>> 12) & 0x0000000f; + out[outOffset + 4] = (value >>> 16) & 0x0000000f; + out[outOffset + 5] = (value >>> 20) & 0x0000000f; + out[outOffset + 6] = (value >>> 24) & 0x0000000f; + return 7; + } + case 8: { + out[outOffset] = value & 0x0000001f; + out[outOffset + 1] = (value >>> 5) & 0x0000001f; + out[outOffset + 2] = (value >>> 10) & 0x0000001f; + out[outOffset + 3] = (value >>> 15) & 0x0000001f; + out[outOffset + 4] = (value >>> 20) & 0x0000000f; + out[outOffset + 5] = (value >>> 24) & 0x0000000f; + return 6; + } + case 9: { + out[outOffset] = value & 0x0000000f; + out[outOffset + 1] = (value >>> 4) & 0x0000000f; + out[outOffset + 2] = (value >>> 8) & 0x0000001f; + out[outOffset + 3] = (value >>> 13) & 0x0000001f; + out[outOffset + 4] = (value >>> 18) & 0x0000001f; + out[outOffset + 5] = (value >>> 23) & 0x0000001f; + return 6; + } + case 10: { + out[outOffset] = value & 0x0000003f; + out[outOffset + 1] = (value >>> 6) & 0x0000003f; + out[outOffset + 2] = (value >>> 12) & 0x0000003f; + out[outOffset + 3] = (value >>> 18) & 0x0000001f; + out[outOffset + 4] = (value >>> 23) & 0x0000001f; + return 5; + } + case 11: { + out[outOffset] = value & 0x0000001f; + out[outOffset + 1] = (value >>> 5) & 0x0000001f; + out[outOffset + 2] = (value >>> 10) & 0x0000003f; + out[outOffset + 3] = (value >>> 16) & 0x0000003f; + out[outOffset + 4] = (value >>> 22) & 0x0000003f; + return 5; + } + case 12: { + out[outOffset] = value & 0x0000007f; + out[outOffset + 1] = (value >>> 7) & 0x0000007f; + out[outOffset + 2] = (value >>> 14) & 0x0000007f; + out[outOffset + 3] = (value >>> 21) & 0x0000007f; + return 4; + } + case 13: { + out[outOffset] = value & 0x000003ff; + out[outOffset + 1] = (value >>> 10) & 0x000001ff; + out[outOffset + 2] = (value >>> 19) & 0x000001ff; + return 3; + } + case 14: { + out[outOffset] = value & 0x00003fff; + out[outOffset + 1] = (value >>> 14) & 0x00003fff; + return 2; + } + case 15: { + out[outOffset] = value & 0x0fffffff; + return 1; + } + default: + return -1; + } + } - public static int s16DecompressOneNumberWithHardCodesIntegrated(int[] out, int outOffset, int value, int numIdx, int oribits, int[] expPos) { - switch (numIdx) { - case 0: { - out[expPos[outOffset]] |= ((value & 0x00000001) << oribits); - out[expPos[outOffset + 1]] |= (((value >>> 1) & 0x00000001) << oribits); - out[expPos[outOffset + 2]] |= (((value >>> 2) & 0x00000001) << oribits); - out[expPos[outOffset + 3]] |= (((value >>> 3) & 0x00000001) << oribits); - out[expPos[outOffset + 4]] |= (((value >>> 4) & 0x00000001) << oribits); - out[expPos[outOffset + 5]] |= (((value >>> 5) & 0x00000001) << oribits); - out[expPos[outOffset + 6]] |= (((value >>> 6) & 0x00000001) << oribits); - out[expPos[outOffset + 7]] |= (((value >>> 7) & 0x00000001) << oribits); - out[expPos[outOffset + 8]] |= (((value >>> 8) & 0x00000001) << oribits); - out[expPos[outOffset + 9]] |= (((value >>> 9) & 0x00000001) << oribits); - out[expPos[outOffset + 10]] |= (((value >>> 10) & 0x00000001) << oribits); - out[expPos[outOffset + 11]] |= (((value >>> 11) & 0x00000001) << oribits); - out[expPos[outOffset + 12]] |= (((value >>> 12) & 0x00000001) << oribits); - out[expPos[outOffset + 13]] |= (((value >>> 13) & 0x00000001) << oribits); - out[expPos[outOffset + 14]] |= (((value >>> 14) & 0x00000001) << oribits); - out[expPos[outOffset + 15]] |= (((value >>> 15) & 0x00000001) << oribits); - out[expPos[outOffset + 16]] |= (((value >>> 16) & 0x00000001) << oribits); - out[expPos[outOffset + 17]] |= (((value >>> 17) & 0x00000001) << oribits); - out[expPos[outOffset + 18]] |= (((value >>> 18) & 0x00000001) << oribits); - out[expPos[outOffset + 19]] |= (((value >>> 19) & 0x00000001) << oribits); - out[expPos[outOffset + 20]] |= (((value >>> 20) & 0x00000001) << oribits); - out[expPos[outOffset + 21]] |= (((value >>> 21) & 0x00000001) << oribits); - out[expPos[outOffset + 22]] |= (((value >>> 22) & 0x00000001) << oribits); - out[expPos[outOffset + 23]] |= (((value >>> 23) & 0x00000001) << oribits); - out[expPos[outOffset + 24]] |= (((value >>> 24) & 0x00000001) << oribits); - out[expPos[outOffset + 25]] |= (((value >>> 25) & 0x00000001) << oribits); - out[expPos[outOffset + 26]] |= (((value >>> 26) & 0x00000001) << oribits); - out[expPos[outOffset + 27]] |= (((value >>> 27) & 0x00000001) << oribits); - return 28; - } - case 1: { - out[expPos[outOffset]] |= ((value & 0x00000003) << oribits); - out[expPos[outOffset + 1]] |= (((value >>> 2) & 0x00000003) << oribits); - out[expPos[outOffset + 2]] |= (((value >>> 4) & 0x00000003) << oribits); - out[expPos[outOffset + 3]] |= (((value >>> 6) & 0x00000003) << oribits); - out[expPos[outOffset + 4]] |= (((value >>> 8) & 0x00000003) << oribits); - out[expPos[outOffset + 5]] |= (((value >>> 10) & 0x00000003) << oribits); - out[expPos[outOffset + 6]] |= (((value >>> 12) & 0x00000003) << oribits); - out[expPos[outOffset + 7]] |= (((value >>> 14) & 0x00000001) << oribits); - out[expPos[outOffset + 8]] |= (((value >>> 15) & 0x00000001) << oribits); - out[expPos[outOffset + 9]] |= (((value >>> 16) & 0x00000001) << oribits); - out[expPos[outOffset + 10]] |= (((value >>> 17) & 0x00000001) << oribits); - out[expPos[outOffset + 11]] |= (((value >>> 18) & 0x00000001) << oribits); - out[expPos[outOffset + 12]] |= (((value >>> 19) & 0x00000001) << oribits); - out[expPos[outOffset + 13]] |= (((value >>> 20) & 0x00000001) << oribits); - out[expPos[outOffset + 14]] |= (((value >>> 21) & 0x00000001) << oribits); - out[expPos[outOffset + 15]] |= (((value >>> 22) & 0x00000001) << oribits); - out[expPos[outOffset + 16]] |= (((value >>> 23) & 0x00000001) << oribits); - out[expPos[outOffset + 17]] |= (((value >>> 24) & 0x00000001) << oribits); - out[expPos[outOffset + 18]] |= (((value >>> 25) & 0x00000001) << oribits); - out[expPos[outOffset + 19]] |= (((value >>> 26) & 0x00000001) << oribits); - out[expPos[outOffset + 20]] |= (((value >>> 27) & 0x00000001) << oribits); - return 21; - } - case 2: { - out[expPos[outOffset]] |= ((value & 0x00000001) << oribits); - out[expPos[outOffset + 1]] |= (((value >>> 1) & 0x00000001) << oribits); - out[expPos[outOffset + 2]] |= (((value >>> 2) & 0x00000001) << oribits); - out[expPos[outOffset + 3]] |= (((value >>> 3) & 0x00000001) << oribits); - out[expPos[outOffset + 4]] |= (((value >>> 4) & 0x00000001) << oribits); - out[expPos[outOffset + 5]] |= (((value >>> 5) & 0x00000001) << oribits); - out[expPos[outOffset + 6]] |= (((value >>> 6) & 0x00000001) << oribits); - out[expPos[outOffset + 7]] |= (((value >>> 7) & 0x00000003) << oribits); - out[expPos[outOffset + 8]] |= (((value >>> 9) & 0x00000003) << oribits); - out[expPos[outOffset + 9]] |= (((value >>> 11) & 0x00000003) << oribits); - out[expPos[outOffset + 10]] |= (((value >>> 13) & 0x00000003) << oribits); - out[expPos[outOffset + 11]] |= (((value >>> 15) & 0x00000003) << oribits); - out[expPos[outOffset + 12]] |= (((value >>> 17) & 0x00000003) << oribits); - out[expPos[outOffset + 13]] |= (((value >>> 19) & 0x00000003) << oribits); - out[expPos[outOffset + 14]] |= (((value >>> 21) & 0x00000001) << oribits); - out[expPos[outOffset + 15]] |= (((value >>> 22) & 0x00000001) << oribits); - out[expPos[outOffset + 16]] |= (((value >>> 23) & 0x00000001) << oribits); - out[expPos[outOffset + 17]] |= (((value >>> 24) & 0x00000001) << oribits); - out[expPos[outOffset + 18]] |= (((value >>> 25) & 0x00000001) << oribits); - out[expPos[outOffset + 19]] |= (((value >>> 26) & 0x00000001) << oribits); - out[expPos[outOffset + 20]] |= (((value >>> 27) & 0x00000001) << oribits); - return 21; - } - case 3: { - out[expPos[outOffset]] |= ((value & 0x00000001) << oribits); - out[expPos[outOffset + 1]] |= (((value >>> 1) & 0x00000001) << oribits); - out[expPos[outOffset + 2]] |= (((value >>> 2) & 0x00000001) << oribits); - out[expPos[outOffset + 3]] |= (((value >>> 3) & 0x00000001) << oribits); - out[expPos[outOffset + 4]] |= (((value >>> 4) & 0x00000001) << oribits); - out[expPos[outOffset + 5]] |= (((value >>> 5) & 0x00000001) << oribits); - out[expPos[outOffset + 6]] |= (((value >>> 6) & 0x00000001) << oribits); - out[expPos[outOffset + 7]] |= (((value >>> 7) & 0x00000001) << oribits); - out[expPos[outOffset + 8]] |= (((value >>> 8) & 0x00000001) << oribits); - out[expPos[outOffset + 9]] |= (((value >>> 9) & 0x00000001) << oribits); - out[expPos[outOffset + 10]] |= (((value >>> 10) & 0x00000001) << oribits); - out[expPos[outOffset + 11]] |= (((value >>> 11) & 0x00000001) << oribits); - out[expPos[outOffset + 12]] |= (((value >>> 12) & 0x00000001) << oribits); - out[expPos[outOffset + 13]] |= (((value >>> 13) & 0x00000001) << oribits); - out[expPos[outOffset + 14]] |= (((value >>> 14) & 0x00000003) << oribits); - out[expPos[outOffset + 15]] |= (((value >>> 16) & 0x00000003) << oribits); - out[expPos[outOffset + 16]] |= (((value >>> 18) & 0x00000003) << oribits); - out[expPos[outOffset + 17]] |= (((value >>> 20) & 0x00000003) << oribits); - out[expPos[outOffset + 18]] |= (((value >>> 22) & 0x00000003) << oribits); - out[expPos[outOffset + 19]] |= (((value >>> 24) & 0x00000003) << oribits); - out[expPos[outOffset + 20]] |= (((value >>> 26) & 0x00000003) << oribits); - return 21; - } - case 4: { - out[expPos[outOffset]] |= ((value & 0x00000003) << oribits); - out[expPos[outOffset + 1]] |= (((value >>> 2) & 0x00000003) << oribits); - out[expPos[outOffset + 2]] |= (((value >>> 4) & 0x00000003) << oribits); - out[expPos[outOffset + 3]] |= (((value >>> 6) & 0x00000003) << oribits); - out[expPos[outOffset + 4]] |= (((value >>> 8) & 0x00000003) << oribits); - out[expPos[outOffset + 5]] |= (((value >>> 10) & 0x00000003) << oribits); - out[expPos[outOffset + 6]] |= (((value >>> 12) & 0x00000003) << oribits); - out[expPos[outOffset + 7]] |= (((value >>> 14) & 0x00000003) << oribits); - out[expPos[outOffset + 8]] |= (((value >>> 16) & 0x00000003) << oribits); - out[expPos[outOffset + 9]] |= (((value >>> 18) & 0x00000003) << oribits); - out[expPos[outOffset + 10]] |= (((value >>> 20) & 0x00000003) << oribits); - out[expPos[outOffset + 11]] |= (((value >>> 22) & 0x00000003) << oribits); - out[expPos[outOffset + 12]] |= (((value >>> 24) & 0x00000003) << oribits); - out[expPos[outOffset + 13]] |= (((value >>> 26) & 0x00000003) << oribits); - return 14; - } - case 5: { - out[expPos[outOffset]] |= ((value & 0x0000000f) << oribits); - out[expPos[outOffset + 1]] |= (((value >>> 4) & 0x00000007) << oribits); - out[expPos[outOffset + 2]] |= (((value >>> 7) & 0x00000007) << oribits); - out[expPos[outOffset + 3]] |= (((value >>> 10) & 0x00000007) << oribits); - out[expPos[outOffset + 4]] |= (((value >>> 13) & 0x00000007) << oribits); - out[expPos[outOffset + 5]] |= (((value >>> 16) & 0x00000007) << oribits); - out[expPos[outOffset + 6]] |= (((value >>> 19) & 0x00000007) << oribits); - out[expPos[outOffset + 7]] |= (((value >>> 22) & 0x00000007) << oribits); - out[expPos[outOffset + 8]] |= (((value >>> 25) & 0x00000007) << oribits); - return 9; - } - case 6: { - out[expPos[outOffset]] |= ((value & 0x00000007) << oribits); - out[expPos[outOffset + 1]] |= (((value >>> 3) & 0x0000000f) << oribits); - out[expPos[outOffset + 2]] |= (((value >>> 7) & 0x0000000f) << oribits); - out[expPos[outOffset + 3]] |= (((value >>> 11) & 0x0000000f) << oribits); - out[expPos[outOffset + 4]] |= (((value >>> 15) & 0x0000000f) << oribits); - out[expPos[outOffset + 5]] |= (((value >>> 19) & 0x00000007) << oribits); - out[expPos[outOffset + 6]] |= (((value >>> 22) & 0x00000007) << oribits); - out[expPos[outOffset + 7]] |= (((value >>> 25) & 0x00000007) << oribits); - return 8; - } - case 7: { - out[expPos[outOffset]] |= ((value & 0x0000000f) << oribits); - out[expPos[outOffset + 1]] |= (((value >>> 4) & 0x0000000f) << oribits); - out[expPos[outOffset + 2]] |= (((value >>> 8) & 0x0000000f) << oribits); - out[expPos[outOffset + 3]] |= (((value >>> 12) & 0x0000000f) << oribits); - out[expPos[outOffset + 4]] |= (((value >>> 16) & 0x0000000f) << oribits); - out[expPos[outOffset + 5]] |= (((value >>> 20) & 0x0000000f) << oribits); - out[expPos[outOffset + 6]] |= (((value >>> 24) & 0x0000000f) << oribits); - return 7; - } - case 8: { - out[expPos[outOffset]] |= ((value & 0x0000001f) << oribits); - out[expPos[outOffset + 1]] |= (((value >>> 5) & 0x0000001f) << oribits); - out[expPos[outOffset + 2]] |= (((value >>> 10) & 0x0000001f) << oribits); - out[expPos[outOffset + 3]] |= (((value >>> 15) & 0x0000001f) << oribits); - out[expPos[outOffset + 4]] |= (((value >>> 20) & 0x0000000f) << oribits); - out[expPos[outOffset + 5]] |= (((value >>> 24) & 0x0000000f) << oribits); - return 6; - } - case 9: { - out[expPos[outOffset]] |= ((value & 0x0000000f) << oribits); - out[expPos[outOffset + 1]] |= (((value >>> 4) & 0x0000000f) << oribits); - out[expPos[outOffset + 2]] |= (((value >>> 8) & 0x0000001f) << oribits); - out[expPos[outOffset + 3]] |= (((value >>> 13) & 0x0000001f) << oribits); - out[expPos[outOffset + 4]] |= (((value >>> 18) & 0x0000001f) << oribits); - out[expPos[outOffset + 5]] |= (((value >>> 23) & 0x0000001f) << oribits); - return 6; - } - case 10: { - out[expPos[outOffset]] |= ((value & 0x0000003f) << oribits); - out[expPos[outOffset + 1]] |= (((value >>> 6) & 0x0000003f) << oribits); - out[expPos[outOffset + 2]] |= (((value >>> 12) & 0x0000003f) << oribits); - out[expPos[outOffset + 3]] |= (((value >>> 18) & 0x0000001f) << oribits); - out[expPos[outOffset + 4]] |= (((value >>> 23) & 0x0000001f) << oribits); - return 5; - } - case 11: { - out[expPos[outOffset]] |= ((value & 0x0000001f) << oribits); - out[expPos[outOffset + 1]] |= (((value >>> 5) & 0x0000001f) << oribits); - out[expPos[outOffset + 2]] |= (((value >>> 10) & 0x0000003f) << oribits); - out[expPos[outOffset + 3]] |= (((value >>> 16) & 0x0000003f) << oribits); - out[expPos[outOffset + 4]] |= (((value >>> 22) & 0x0000003f) << oribits); - return 5; - } - case 12: { - out[expPos[outOffset]] |= ((value & 0x0000007f) << oribits); - out[expPos[outOffset + 1]] |= (((value >>> 7) & 0x0000007f) << oribits); - out[expPos[outOffset + 2]] |= (((value >>> 14) & 0x0000007f) << oribits); - out[expPos[outOffset + 3]] |= (((value >>> 21) & 0x0000007f) << oribits); - return 4; - } - case 13: { - out[expPos[outOffset]] |= ((value & 0x000003ff) << oribits); - out[expPos[outOffset + 1]] |= (((value >>> 10) & 0x000001ff) << oribits); - out[expPos[outOffset + 2]] |= (((value >>> 19) & 0x000001ff) << oribits); - return 3; - } - case 14: { - out[expPos[outOffset]] |= ((value & 0x00003fff) << oribits); - out[expPos[outOffset + 1]] |= (((value >>> 14) & 0x00003fff) << oribits); - return 2; - } - case 15: { - out[expPos[outOffset]] |= ((value & 0x0fffffff) << oribits); - return 1; - } - default: - return -1; + protected static int s16DecompressOneNumberWithHardCodesIntegrated( + int[] out, int outOffset, int value, int numIdx, int oribits, + int[] expPos) { + switch (numIdx) { + case 0: { + out[expPos[outOffset]] |= ((value & 0x00000001) << oribits); + out[expPos[outOffset + 1]] |= (((value >>> 1) & 0x00000001) << oribits); + out[expPos[outOffset + 2]] |= (((value >>> 2) & 0x00000001) << oribits); + out[expPos[outOffset + 3]] |= (((value >>> 3) & 0x00000001) << oribits); + out[expPos[outOffset + 4]] |= (((value >>> 4) & 0x00000001) << oribits); + out[expPos[outOffset + 5]] |= (((value >>> 5) & 0x00000001) << oribits); + out[expPos[outOffset + 6]] |= (((value >>> 6) & 0x00000001) << oribits); + out[expPos[outOffset + 7]] |= (((value >>> 7) & 0x00000001) << oribits); + out[expPos[outOffset + 8]] |= (((value >>> 8) & 0x00000001) << oribits); + out[expPos[outOffset + 9]] |= (((value >>> 9) & 0x00000001) << oribits); + out[expPos[outOffset + 10]] |= (((value >>> 10) & 0x00000001) << oribits); + out[expPos[outOffset + 11]] |= (((value >>> 11) & 0x00000001) << oribits); + out[expPos[outOffset + 12]] |= (((value >>> 12) & 0x00000001) << oribits); + out[expPos[outOffset + 13]] |= (((value >>> 13) & 0x00000001) << oribits); + out[expPos[outOffset + 14]] |= (((value >>> 14) & 0x00000001) << oribits); + out[expPos[outOffset + 15]] |= (((value >>> 15) & 0x00000001) << oribits); + out[expPos[outOffset + 16]] |= (((value >>> 16) & 0x00000001) << oribits); + out[expPos[outOffset + 17]] |= (((value >>> 17) & 0x00000001) << oribits); + out[expPos[outOffset + 18]] |= (((value >>> 18) & 0x00000001) << oribits); + out[expPos[outOffset + 19]] |= (((value >>> 19) & 0x00000001) << oribits); + out[expPos[outOffset + 20]] |= (((value >>> 20) & 0x00000001) << oribits); + out[expPos[outOffset + 21]] |= (((value >>> 21) & 0x00000001) << oribits); + out[expPos[outOffset + 22]] |= (((value >>> 22) & 0x00000001) << oribits); + out[expPos[outOffset + 23]] |= (((value >>> 23) & 0x00000001) << oribits); + out[expPos[outOffset + 24]] |= (((value >>> 24) & 0x00000001) << oribits); + out[expPos[outOffset + 25]] |= (((value >>> 25) & 0x00000001) << oribits); + out[expPos[outOffset + 26]] |= (((value >>> 26) & 0x00000001) << oribits); + out[expPos[outOffset + 27]] |= (((value >>> 27) & 0x00000001) << oribits); + return 28; + } + case 1: { + out[expPos[outOffset]] |= ((value & 0x00000003) << oribits); + out[expPos[outOffset + 1]] |= (((value >>> 2) & 0x00000003) << oribits); + out[expPos[outOffset + 2]] |= (((value >>> 4) & 0x00000003) << oribits); + out[expPos[outOffset + 3]] |= (((value >>> 6) & 0x00000003) << oribits); + out[expPos[outOffset + 4]] |= (((value >>> 8) & 0x00000003) << oribits); + out[expPos[outOffset + 5]] |= (((value >>> 10) & 0x00000003) << oribits); + out[expPos[outOffset + 6]] |= (((value >>> 12) & 0x00000003) << oribits); + out[expPos[outOffset + 7]] |= (((value >>> 14) & 0x00000001) << oribits); + out[expPos[outOffset + 8]] |= (((value >>> 15) & 0x00000001) << oribits); + out[expPos[outOffset + 9]] |= (((value >>> 16) & 0x00000001) << oribits); + out[expPos[outOffset + 10]] |= (((value >>> 17) & 0x00000001) << oribits); + out[expPos[outOffset + 11]] |= (((value >>> 18) & 0x00000001) << oribits); + out[expPos[outOffset + 12]] |= (((value >>> 19) & 0x00000001) << oribits); + out[expPos[outOffset + 13]] |= (((value >>> 20) & 0x00000001) << oribits); + out[expPos[outOffset + 14]] |= (((value >>> 21) & 0x00000001) << oribits); + out[expPos[outOffset + 15]] |= (((value >>> 22) & 0x00000001) << oribits); + out[expPos[outOffset + 16]] |= (((value >>> 23) & 0x00000001) << oribits); + out[expPos[outOffset + 17]] |= (((value >>> 24) & 0x00000001) << oribits); + out[expPos[outOffset + 18]] |= (((value >>> 25) & 0x00000001) << oribits); + out[expPos[outOffset + 19]] |= (((value >>> 26) & 0x00000001) << oribits); + out[expPos[outOffset + 20]] |= (((value >>> 27) & 0x00000001) << oribits); + return 21; + } + case 2: { + out[expPos[outOffset]] |= ((value & 0x00000001) << oribits); + out[expPos[outOffset + 1]] |= (((value >>> 1) & 0x00000001) << oribits); + out[expPos[outOffset + 2]] |= (((value >>> 2) & 0x00000001) << oribits); + out[expPos[outOffset + 3]] |= (((value >>> 3) & 0x00000001) << oribits); + out[expPos[outOffset + 4]] |= (((value >>> 4) & 0x00000001) << oribits); + out[expPos[outOffset + 5]] |= (((value >>> 5) & 0x00000001) << oribits); + out[expPos[outOffset + 6]] |= (((value >>> 6) & 0x00000001) << oribits); + out[expPos[outOffset + 7]] |= (((value >>> 7) & 0x00000003) << oribits); + out[expPos[outOffset + 8]] |= (((value >>> 9) & 0x00000003) << oribits); + out[expPos[outOffset + 9]] |= (((value >>> 11) & 0x00000003) << oribits); + out[expPos[outOffset + 10]] |= (((value >>> 13) & 0x00000003) << oribits); + out[expPos[outOffset + 11]] |= (((value >>> 15) & 0x00000003) << oribits); + out[expPos[outOffset + 12]] |= (((value >>> 17) & 0x00000003) << oribits); + out[expPos[outOffset + 13]] |= (((value >>> 19) & 0x00000003) << oribits); + out[expPos[outOffset + 14]] |= (((value >>> 21) & 0x00000001) << oribits); + out[expPos[outOffset + 15]] |= (((value >>> 22) & 0x00000001) << oribits); + out[expPos[outOffset + 16]] |= (((value >>> 23) & 0x00000001) << oribits); + out[expPos[outOffset + 17]] |= (((value >>> 24) & 0x00000001) << oribits); + out[expPos[outOffset + 18]] |= (((value >>> 25) & 0x00000001) << oribits); + out[expPos[outOffset + 19]] |= (((value >>> 26) & 0x00000001) << oribits); + out[expPos[outOffset + 20]] |= (((value >>> 27) & 0x00000001) << oribits); + return 21; + } + case 3: { + out[expPos[outOffset]] |= ((value & 0x00000001) << oribits); + out[expPos[outOffset + 1]] |= (((value >>> 1) & 0x00000001) << oribits); + out[expPos[outOffset + 2]] |= (((value >>> 2) & 0x00000001) << oribits); + out[expPos[outOffset + 3]] |= (((value >>> 3) & 0x00000001) << oribits); + out[expPos[outOffset + 4]] |= (((value >>> 4) & 0x00000001) << oribits); + out[expPos[outOffset + 5]] |= (((value >>> 5) & 0x00000001) << oribits); + out[expPos[outOffset + 6]] |= (((value >>> 6) & 0x00000001) << oribits); + out[expPos[outOffset + 7]] |= (((value >>> 7) & 0x00000001) << oribits); + out[expPos[outOffset + 8]] |= (((value >>> 8) & 0x00000001) << oribits); + out[expPos[outOffset + 9]] |= (((value >>> 9) & 0x00000001) << oribits); + out[expPos[outOffset + 10]] |= (((value >>> 10) & 0x00000001) << oribits); + out[expPos[outOffset + 11]] |= (((value >>> 11) & 0x00000001) << oribits); + out[expPos[outOffset + 12]] |= (((value >>> 12) & 0x00000001) << oribits); + out[expPos[outOffset + 13]] |= (((value >>> 13) & 0x00000001) << oribits); + out[expPos[outOffset + 14]] |= (((value >>> 14) & 0x00000003) << oribits); + out[expPos[outOffset + 15]] |= (((value >>> 16) & 0x00000003) << oribits); + out[expPos[outOffset + 16]] |= (((value >>> 18) & 0x00000003) << oribits); + out[expPos[outOffset + 17]] |= (((value >>> 20) & 0x00000003) << oribits); + out[expPos[outOffset + 18]] |= (((value >>> 22) & 0x00000003) << oribits); + out[expPos[outOffset + 19]] |= (((value >>> 24) & 0x00000003) << oribits); + out[expPos[outOffset + 20]] |= (((value >>> 26) & 0x00000003) << oribits); + return 21; + } + case 4: { + out[expPos[outOffset]] |= ((value & 0x00000003) << oribits); + out[expPos[outOffset + 1]] |= (((value >>> 2) & 0x00000003) << oribits); + out[expPos[outOffset + 2]] |= (((value >>> 4) & 0x00000003) << oribits); + out[expPos[outOffset + 3]] |= (((value >>> 6) & 0x00000003) << oribits); + out[expPos[outOffset + 4]] |= (((value >>> 8) & 0x00000003) << oribits); + out[expPos[outOffset + 5]] |= (((value >>> 10) & 0x00000003) << oribits); + out[expPos[outOffset + 6]] |= (((value >>> 12) & 0x00000003) << oribits); + out[expPos[outOffset + 7]] |= (((value >>> 14) & 0x00000003) << oribits); + out[expPos[outOffset + 8]] |= (((value >>> 16) & 0x00000003) << oribits); + out[expPos[outOffset + 9]] |= (((value >>> 18) & 0x00000003) << oribits); + out[expPos[outOffset + 10]] |= (((value >>> 20) & 0x00000003) << oribits); + out[expPos[outOffset + 11]] |= (((value >>> 22) & 0x00000003) << oribits); + out[expPos[outOffset + 12]] |= (((value >>> 24) & 0x00000003) << oribits); + out[expPos[outOffset + 13]] |= (((value >>> 26) & 0x00000003) << oribits); + return 14; + } + case 5: { + out[expPos[outOffset]] |= ((value & 0x0000000f) << oribits); + out[expPos[outOffset + 1]] |= (((value >>> 4) & 0x00000007) << oribits); + out[expPos[outOffset + 2]] |= (((value >>> 7) & 0x00000007) << oribits); + out[expPos[outOffset + 3]] |= (((value >>> 10) & 0x00000007) << oribits); + out[expPos[outOffset + 4]] |= (((value >>> 13) & 0x00000007) << oribits); + out[expPos[outOffset + 5]] |= (((value >>> 16) & 0x00000007) << oribits); + out[expPos[outOffset + 6]] |= (((value >>> 19) & 0x00000007) << oribits); + out[expPos[outOffset + 7]] |= (((value >>> 22) & 0x00000007) << oribits); + out[expPos[outOffset + 8]] |= (((value >>> 25) & 0x00000007) << oribits); + return 9; + } + case 6: { + out[expPos[outOffset]] |= ((value & 0x00000007) << oribits); + out[expPos[outOffset + 1]] |= (((value >>> 3) & 0x0000000f) << oribits); + out[expPos[outOffset + 2]] |= (((value >>> 7) & 0x0000000f) << oribits); + out[expPos[outOffset + 3]] |= (((value >>> 11) & 0x0000000f) << oribits); + out[expPos[outOffset + 4]] |= (((value >>> 15) & 0x0000000f) << oribits); + out[expPos[outOffset + 5]] |= (((value >>> 19) & 0x00000007) << oribits); + out[expPos[outOffset + 6]] |= (((value >>> 22) & 0x00000007) << oribits); + out[expPos[outOffset + 7]] |= (((value >>> 25) & 0x00000007) << oribits); + return 8; + } + case 7: { + out[expPos[outOffset]] |= ((value & 0x0000000f) << oribits); + out[expPos[outOffset + 1]] |= (((value >>> 4) & 0x0000000f) << oribits); + out[expPos[outOffset + 2]] |= (((value >>> 8) & 0x0000000f) << oribits); + out[expPos[outOffset + 3]] |= (((value >>> 12) & 0x0000000f) << oribits); + out[expPos[outOffset + 4]] |= (((value >>> 16) & 0x0000000f) << oribits); + out[expPos[outOffset + 5]] |= (((value >>> 20) & 0x0000000f) << oribits); + out[expPos[outOffset + 6]] |= (((value >>> 24) & 0x0000000f) << oribits); + return 7; + } + case 8: { + out[expPos[outOffset]] |= ((value & 0x0000001f) << oribits); + out[expPos[outOffset + 1]] |= (((value >>> 5) & 0x0000001f) << oribits); + out[expPos[outOffset + 2]] |= (((value >>> 10) & 0x0000001f) << oribits); + out[expPos[outOffset + 3]] |= (((value >>> 15) & 0x0000001f) << oribits); + out[expPos[outOffset + 4]] |= (((value >>> 20) & 0x0000000f) << oribits); + out[expPos[outOffset + 5]] |= (((value >>> 24) & 0x0000000f) << oribits); + return 6; + } + case 9: { + out[expPos[outOffset]] |= ((value & 0x0000000f) << oribits); + out[expPos[outOffset + 1]] |= (((value >>> 4) & 0x0000000f) << oribits); + out[expPos[outOffset + 2]] |= (((value >>> 8) & 0x0000001f) << oribits); + out[expPos[outOffset + 3]] |= (((value >>> 13) & 0x0000001f) << oribits); + out[expPos[outOffset + 4]] |= (((value >>> 18) & 0x0000001f) << oribits); + out[expPos[outOffset + 5]] |= (((value >>> 23) & 0x0000001f) << oribits); + return 6; + } + case 10: { + out[expPos[outOffset]] |= ((value & 0x0000003f) << oribits); + out[expPos[outOffset + 1]] |= (((value >>> 6) & 0x0000003f) << oribits); + out[expPos[outOffset + 2]] |= (((value >>> 12) & 0x0000003f) << oribits); + out[expPos[outOffset + 3]] |= (((value >>> 18) & 0x0000001f) << oribits); + out[expPos[outOffset + 4]] |= (((value >>> 23) & 0x0000001f) << oribits); + return 5; + } + case 11: { + out[expPos[outOffset]] |= ((value & 0x0000001f) << oribits); + out[expPos[outOffset + 1]] |= (((value >>> 5) & 0x0000001f) << oribits); + out[expPos[outOffset + 2]] |= (((value >>> 10) & 0x0000003f) << oribits); + out[expPos[outOffset + 3]] |= (((value >>> 16) & 0x0000003f) << oribits); + out[expPos[outOffset + 4]] |= (((value >>> 22) & 0x0000003f) << oribits); + return 5; + } + case 12: { + out[expPos[outOffset]] |= ((value & 0x0000007f) << oribits); + out[expPos[outOffset + 1]] |= (((value >>> 7) & 0x0000007f) << oribits); + out[expPos[outOffset + 2]] |= (((value >>> 14) & 0x0000007f) << oribits); + out[expPos[outOffset + 3]] |= (((value >>> 21) & 0x0000007f) << oribits); + return 4; + } + case 13: { + out[expPos[outOffset]] |= ((value & 0x000003ff) << oribits); + out[expPos[outOffset + 1]] |= (((value >>> 10) & 0x000001ff) << oribits); + out[expPos[outOffset + 2]] |= (((value >>> 19) & 0x000001ff) << oribits); + return 3; + } + case 14: { + out[expPos[outOffset]] |= ((value & 0x00003fff) << oribits); + out[expPos[outOffset + 1]] |= (((value >>> 14) & 0x00003fff) << oribits); + return 2; + } + case 15: { + out[expPos[outOffset]] |= ((value & 0x0fffffff) << oribits); + return 1; + } + default: + return -1; + } } - } - /** - * Read a certain number of bits of a integer on the input array - * - * @param in the input array - * @param inIntOffset the start offset in ints in the input array - * @param inWithIntOffset the start offset within a int in the input array - * @param bits the number of bits to be read - * @return the bits bits of the input - */ - static private int readBitsForS16(int[] in, final int inIntOffset, final int inWithIntOffset, final int bits) { - final int val = (in[inIntOffset] >>> inWithIntOffset); - return val & (0xffffffff >>> (32 - bits)); - } + /** + * Read a certain number of bits of a integer on the input array + * + * @param in + * the input array + * @param inIntOffset + * the start offset in ints in the input array + * @param inWithIntOffset + * the start offset within a int in the input array + * @param bits + * the number of bits to be read + * @return the bits bits of the input + */ + static private int readBitsForS16(int[] in, final int inIntOffset, + final int inWithIntOffset, final int bits) { + final int val = (in[inIntOffset] >>> inWithIntOffset); + return val & (0xffffffff >>> (32 - bits)); + } } - - diff --git a/src/main/java/me/lemire/integercompression/Benchmark.java b/src/main/java/me/lemire/integercompression/Benchmark.java deleted file mode 100644 index 25c7bff..0000000 --- a/src/main/java/me/lemire/integercompression/Benchmark.java +++ /dev/null @@ -1,332 +0,0 @@ -/** - * This code is released under the - * Apache License Version 2.0 http://www.apache.org/licenses/. - * - * (c) Daniel Lemire, http://lemire.me/en/ - */ -package me.lemire.integercompression; - - -import com.kamikaze.pfordelta.PForDelta; -import me.lemire.integercompression.synth.ClusteredDataGenerator; - -import java.text.DecimalFormat; -import java.util.ArrayList; -import java.util.Arrays; - -/** - * - * Simple class meant to compare the speed of different schemes. - * @author Daniel Lemire - * - */ -public class Benchmark { - - /** - * Standard benchmark - * - * @param c the codec - * @param data arrays of input data - * @param repeat How many times to repeat the test - * @param verbose whether to output result on screen - */ - private static void testCodec(IntegerCODEC c, int[][] data, - int repeat, boolean verbose) { - DecimalFormat df = new DecimalFormat("0.00"); - DecimalFormat dfspeed = new DecimalFormat("0"); - if (verbose) - System.out.println("# " + c.toString()); - if (verbose) - System.out - .println("# bits per int, compress speed (mis), decompression speed (mis) "); - long bef, aft; - String line = ""; - int N = data.length; - int totalsize = 0; - int maxlength = 0; - for (int k = 0; k < N; ++k) { - totalsize += data[k].length; - if (data[k].length > maxlength) - maxlength = data[k].length; - } - int[] buffer = new int[maxlength + 1024]; - int[] dataout = new int[4 * maxlength + 1024]; - /* 4x + 1024 to account for the possibility of some negative compression */ - int size = 0; - int comptime = 0; - long decomptime = 0; - IntWrapper inpos = new IntWrapper(); - IntWrapper outpos = new IntWrapper(); - for (int r = 0; r < repeat; ++r) { - size = 0; - for (int k = 0; k < N; ++k) { - int[] backupdata = Arrays.copyOf(data[k], data[k].length); - // - bef = System.nanoTime() / 1000; - inpos.set(1); - outpos.set(0); - if (!(c instanceof IntegratedIntegerCODEC)) { - Delta.delta(backupdata); - } - c.compress(backupdata, inpos, backupdata.length - inpos.get(), - dataout, outpos); - aft = System.nanoTime() / 1000; - // - comptime += aft - bef; - final int thiscompsize = outpos.get() + 1; - size += thiscompsize; - // - bef = System.nanoTime() / 1000; - inpos.set(0); - outpos.set(1); - buffer[0] = backupdata[0]; - c.uncompress(dataout, inpos, thiscompsize - 1, buffer, outpos); - if (!(c instanceof IntegratedIntegerCODEC)) - Delta.fastinverseDelta(buffer); - aft = System.nanoTime() / 1000; - // - decomptime += aft - bef; - if (outpos.get() != data[k].length) - throw new RuntimeException("we have a bug (diff length) " - + c + " expected " + data[k].length + " got " - + outpos.get()); - for (int m = 0; m < outpos.get(); ++m) - if (buffer[m] != data[k][m]) { - throw new RuntimeException( - "we have a bug (actual difference), expected " - + data[k][m] + " found " + buffer[m] - + " at " + m); - } - - } - } - line += "\t" + df.format(size * 32.0 / totalsize); - line += "\t" + dfspeed.format(totalsize * repeat / (comptime)); - line += "\t" + dfspeed.format(totalsize * repeat / (decomptime)); - if (verbose) - System.out.println(line); - } - - /** - * Main method. - * - * @param args command-line arguments - */ - public static void main(String args[]) { - System.out.println("# benchmark based on the ClusterData model from:"); - System.out.println("# Vo Ngoc Anh and Alistair Moffat. "); - System.out.println("# Index compression using 64-bit words.") ; - System.out.println("# Softw. Pract. Exper.40, 2 (February 2010), 131-147. "); - System.out.println(); - test(20, 18, 10); - } - - /** - * Standard test for the Kamikaze library - * - * @param data input data - * @param repeat how many times to repeat - * @param verbose whether to output data on screen - */ - public static void testKamikaze(int[][] data, - int repeat, boolean verbose) { - DecimalFormat df = new DecimalFormat("0.00"); - DecimalFormat dfspeed = new DecimalFormat("0"); - if (verbose) - System.out.println("# kamikaze PForDelta"); - if (verbose) - System.out - .println("# bits per int, compress speed (mis), decompression speed (mis) "); - long bef, aft; - String line = ""; - int N = data.length; - int totalsize = 0; - int maxlength = 0; - for (int k = 0; k < N; ++k) { - totalsize += data[k].length; - if (data[k].length > maxlength) - maxlength = data[k].length; - } - int[] buffer = new int[maxlength + 1024]; - /* 4x + 1024 to account for the possibility of some negative compression */ - int size = 0; - int comptime = 0; - long decomptime = 0; - for (int r = 0; r < repeat; ++r) { - size = 0; - for (int k = 0; k < N; ++k) { - int outpos = 0; - int[] backupdata = Arrays.copyOf(data[k], data[k].length); - // - bef = System.nanoTime() / 1000; - Delta.delta(backupdata); - ArrayList dataout = new ArrayList(data[k].length / 128); - for (int K = 0; K < data[k].length; K += 128) { - final int[] compressedbuf = PForDelta.compressOneBlockOpt(Arrays.copyOfRange(backupdata, K, K + 128), 128); - dataout.add(compressedbuf); - outpos += compressedbuf.length; - } - aft = System.nanoTime() / 1000; - // - comptime += aft - bef; - final int thiscompsize = outpos; - size += thiscompsize; - // - bef = System.nanoTime() / 1000; - //buffer[0] = backupdata[0]; - ArrayList datauncomp = new ArrayList(dataout.size()); - int deltaoffset = 0; - - for (int[] compbuf : dataout) { - int[] tmpbuf = new int[128]; - PForDelta.decompressOneBlock(tmpbuf, compbuf, 128); - tmpbuf[0] += deltaoffset; - Delta.fastinverseDelta(tmpbuf); - deltaoffset = tmpbuf[127]; - datauncomp.add(tmpbuf); - } - aft = System.nanoTime() / 1000; - // - decomptime += aft - bef; - if (datauncomp.size() * 128 != data[k].length) - throw new RuntimeException("we have a bug (diff length) " - + " expected " + data[k].length + " got " - + datauncomp.size() * 128); - for (int m = 0; m < data[k].length; ++m) - if (datauncomp.get(m / 128)[m % 128] != data[k][m]) { - throw new RuntimeException( - "we have a bug (actual difference), expected " - + data[k][m] + " found " + buffer[m] - + " at " + m); - } - - } - } - - line += "\t" + df.format(size * 32.0 / totalsize); - line += "\t" + dfspeed.format(totalsize * repeat / (comptime)); - line += "\t" + dfspeed.format(totalsize * repeat / (decomptime)); - if (verbose) - System.out.println(line); - } - - /** - * Generates data and calls other tests. - * - * @param N How many input arrays to generate - * @param nbr how big (in log2) should the arrays be - * @param repeat How many times should we repeat tests. - */ - private static void test(int N, int nbr, int repeat) { - ClusteredDataGenerator cdg = new ClusteredDataGenerator(); - for (int sparsity = 1; sparsity < 31 - nbr; sparsity += 1) { - System.out.println("# sparsity " + sparsity); - int[][] data = new int[N][]; - int Max = (1 << (nbr + sparsity)); - System.out.println("# generating random data..."); - for (int k = 0; k < N; ++k) { - data[k] = cdg.generateClustered((1 << nbr), Max); - } - System.out.println("# generating random data... ok."); - testKamikaze(data, repeat, false); - testKamikaze(data, repeat, false); - testKamikaze(data, repeat, true); - System.out.println(); - - testCodec(new IntegratedComposition(new IntegratedBinaryPacking(), - new IntegratedVariableByte()), data, repeat, false); - testCodec(new IntegratedComposition(new IntegratedBinaryPacking(), - new IntegratedVariableByte()), data, repeat, false); - testCodec(new IntegratedComposition(new IntegratedBinaryPacking(), - new IntegratedVariableByte()), data, repeat, true); - System.out.println(); - - - testCodec(new JustCopy(), data, repeat, false); - testCodec(new JustCopy(), data, repeat, false); - testCodec(new JustCopy(), data, repeat, true); - System.out.println(); - - testCodec(new VariableByte(), data, repeat, false); - testCodec(new VariableByte(), data, repeat, false); - testCodec(new VariableByte(), data, repeat, true); - System.out.println(); - - testCodec(new IntegratedVariableByte(), data, repeat, false); - testCodec(new IntegratedVariableByte(), data, repeat, false); - testCodec(new IntegratedVariableByte(), data, repeat, true); - System.out.println(); - - - testCodec(new Composition(new BinaryPacking(), new VariableByte()), - data, repeat, false); - testCodec(new Composition(new BinaryPacking(), new VariableByte()), - data, repeat, false); - testCodec(new Composition(new BinaryPacking(), new VariableByte()), - data, repeat, true); - System.out.println(); - - testCodec(new Composition(new NewPFD(), new VariableByte()), data, - repeat, false); - testCodec(new Composition(new NewPFD(), new VariableByte()), data, - repeat, false); - testCodec(new Composition(new NewPFD(), new VariableByte()), data, - repeat, true); - System.out.println(); - - - testCodec(new Composition(new NewPFDS9(), new VariableByte()), data, - repeat, false); - testCodec(new Composition(new NewPFDS9(), new VariableByte()), data, - repeat, false); - testCodec(new Composition(new NewPFDS9(), new VariableByte()), data, - repeat, true); - System.out.println(); - - testCodec(new Composition(new NewPFDS16(), new VariableByte()), data, - repeat, false); - testCodec(new Composition(new NewPFDS16(), new VariableByte()), data, - repeat, false); - testCodec(new Composition(new NewPFDS16(), new VariableByte()), data, - repeat, true); - System.out.println(); - - testCodec(new Composition(new OptPFD(), new VariableByte()), data, - repeat, false); - testCodec(new Composition(new OptPFD(), new VariableByte()), data, - repeat, false); - testCodec(new Composition(new OptPFD(), new VariableByte()), data, - repeat, true); - System.out.println(); - - testCodec(new Composition(new OptPFDS9(), new VariableByte()), data, - repeat, false); - testCodec(new Composition(new OptPFDS9(), new VariableByte()), data, - repeat, false); - testCodec(new Composition(new OptPFDS9(), new VariableByte()), data, - repeat, true); - System.out.println(); - - testCodec(new Composition(new OptPFDS16(), new VariableByte()), data, - repeat, false); - testCodec(new Composition(new OptPFDS16(), new VariableByte()), data, - repeat, false); - testCodec(new Composition(new OptPFDS16(), new VariableByte()), data, - repeat, true); - System.out.println(); - - testCodec(new Composition(new FastPFOR(), new VariableByte()), - data, repeat, false); - testCodec(new Composition(new FastPFOR(), new VariableByte()), - data, repeat, false); - testCodec(new Composition(new FastPFOR(), new VariableByte()), - data, repeat, true); - System.out.println(); - - testCodec(new Simple9(), data, repeat, false); - testCodec(new Simple9(), data, repeat, false); - testCodec(new Simple9(), data, repeat, true); - System.out.println(); - } - } -} diff --git a/src/main/java/me/lemire/integercompression/BenchmarkBitPacking.java b/src/main/java/me/lemire/integercompression/BenchmarkBitPacking.java deleted file mode 100644 index 88ec99c..0000000 --- a/src/main/java/me/lemire/integercompression/BenchmarkBitPacking.java +++ /dev/null @@ -1,127 +0,0 @@ -/** - * This code is released under the - * Apache License Version 2.0 http://www.apache.org/licenses/. - * - * (c) Daniel Lemire, http://lemire.me/en/ - */ -package me.lemire.integercompression; - -import java.text.DecimalFormat; -import java.util.Arrays; -import java.util.Random; - -/** - * Class used to benchmark the speed of bit packing. (For - * expert use.) - * - * @author Daniel Lemire - * - */ -public class BenchmarkBitPacking { - - private static void test(boolean verbose) { - DecimalFormat dfspeed = new DecimalFormat("0"); - final int N = 32; - final int times = 100000; - Random r = new Random(0); - int[] data = new int[N]; - int[] compressed = new int[N]; - int[] uncompressed = new int[N]; - for (int bit = 0; bit < 31; ++bit) { - long comp = 0; - long compwm = 0; - long decomp = 0; - for (int t = 0; t < times; ++t) { - for (int k = 0; k < N; ++k) { - data[k] = r.nextInt(1 << bit); - } - long time1 = System.nanoTime(); - BitPacking.fastpack(data, 0, compressed, 0, bit); - long time2 = System.nanoTime(); - BitPacking.fastpackwithoutmask(data, 0, compressed, 0, bit); - long time3 = System.nanoTime(); - BitPacking.fastunpack(compressed, 0, uncompressed, 0, bit); - long time4 = System.nanoTime(); - comp += time2 - time1; - compwm += time3 - time2; - decomp += time4 - time3; - } - if (verbose) - System.out.println("bit = " + bit + " comp. speed = " - + dfspeed.format(N * times * 1000.0 / (comp)) - + " comp. speed wm = " - + dfspeed.format(N * times * 1000.0 / (compwm)) - + " decomp. speed = " - + dfspeed.format(N * times * 1000.0 / (decomp))); - } - } - - private static void testWithDeltas(boolean verbose) { - DecimalFormat dfspeed = new DecimalFormat("0"); - final int N = 32; - final int times = 100000; - Random r = new Random(0); - int[] data = new int[N]; - int[] compressed = new int[N]; - int[] icompressed = new int[N]; - int[] uncompressed = new int[N]; - for (int bit = 1; bit < 31; ++bit) { - long comp = 0; - long decomp = 0; - long icomp = 0; - long idecomp = 0; - for (int t = 0; t < times; ++t) { - data[0] = r.nextInt(1 << bit); - for (int k = 1; k < N; ++k) { - data[k] = r.nextInt(1 << bit) + data[k - 1]; - } - int[] tmpdata = Arrays.copyOf(data, data.length); - long time1 = System.nanoTime(); - Delta.delta(tmpdata); - BitPacking.fastpackwithoutmask(tmpdata, 0, compressed, 0, bit); - long time2 = System.nanoTime(); - BitPacking.fastunpack(compressed, 0, uncompressed, 0, bit); - Delta.fastinverseDelta(uncompressed); - long time3 = System.nanoTime(); - if (!Arrays.equals(data, uncompressed)) throw new RuntimeException("bug"); - comp += time2 - time1; - decomp += time3 - time2; - tmpdata = Arrays.copyOf(data, data.length); - time1 = System.nanoTime(); - IntegratedBitPacking.integratedpack(0, tmpdata, 0, icompressed, 0, bit); - time2 = System.nanoTime(); - IntegratedBitPacking.integratedunpack(0, icompressed, 0, uncompressed, 0, bit); - time3 = System.nanoTime(); - if (!Arrays.equals(icompressed, compressed)) throw new RuntimeException("ibug " + bit); - if (!Arrays.equals(data, uncompressed)) throw new RuntimeException("bug " + bit); - icomp += time2 - time1; - idecomp += time3 - time2; - } - if (verbose) - System.out.println("bit = " + bit + " comp. speed = " - + dfspeed.format(N * times * 1000.0 / (comp)) - + " decomp. speed = " - + dfspeed.format(N * times * 1000.0 / (decomp)) - + " icomp. speed = " - + dfspeed.format(N * times * 1000.0 / (icomp)) - + " idecomp. speed = " - + dfspeed.format(N * times * 1000.0 / (idecomp)) - ); - } - } - - /** - * Main method - * - * @param args command-line arguments - */ - public static void main(String[] args) { - System.out.println("Testing packing and delta "); - testWithDeltas(false); - testWithDeltas(true); - System.out.println("Testing packing alone "); - test(false); - test(true); - } - -} diff --git a/src/main/java/me/lemire/integercompression/BinaryPacking.java b/src/main/java/me/lemire/integercompression/BinaryPacking.java index 98d93a1..ce37ff0 100644 --- a/src/main/java/me/lemire/integercompression/BinaryPacking.java +++ b/src/main/java/me/lemire/integercompression/BinaryPacking.java @@ -8,63 +8,142 @@ /** - * Scheme designed by D. Lemire + * Scheme based on a commonly used idea: can be extremely fast. + * It encodes integers in blocks of 32 integers. For arrays containing + * an arbitrary number of integers, you should use it in conjunction + * with another CODEC: + * + *
IntegerCODEC ic = 
+ *  new Composition(new BinaryPacking(), new VariableByte()).
+ * + * Note that this does not use differential coding: if you are working on sorted + * lists, use IntegratedBinaryPacking instead. * + *

+ * For details, please see + *

+ *

+ * Daniel Lemire and Leonid Boytsov, Decoding billions of integers per second + * through vectorization Software: Practice & Experience + * http://onlinelibrary.wiley.com/doi/10.1002/spe.2203/abstract + * http://arxiv.org/abs/1209.2137 + *

+ *

+ * Daniel Lemire, Leonid Boytsov, Nathan Kurz, + * SIMD Compression and the Intersection of Sorted Integers + * http://arxiv.org/abs/1401.6399 + *

+ * * @author Daniel Lemire */ -public final class BinaryPacking implements IntegerCODEC { +public final class BinaryPacking implements IntegerCODEC, SkippableIntegerCODEC { + public final static int BLOCK_SIZE = 32; + private static final int MAX_BIT_WIDTH = Integer.SIZE; - @Override - public void compress(int[] in, IntWrapper inpos, int inlength, int[] out, IntWrapper outpos) { - inlength = inlength / 128 * 128; - if(inlength == 0) return; + @Override + public void compress(int[] in, IntWrapper inpos, int inlength, + int[] out, IntWrapper outpos) { + inlength = Util.greatestMultiple(inlength, BLOCK_SIZE); + if (inlength == 0) + return; + out[outpos.get()] = inlength; + outpos.increment(); + headlessCompress(in, inpos, inlength, out, outpos); + } + + @Override + public void headlessCompress(int[] in, IntWrapper inpos, int inlength, + int[] out, IntWrapper outpos) { + inlength = Util.greatestMultiple(inlength, BLOCK_SIZE); + int tmpoutpos = outpos.get(); + int s = inpos.get(); + for (; s + BLOCK_SIZE * 4 - 1 < inpos.get() + inlength; s += BLOCK_SIZE * 4) { + final int mbits1 = Util.maxbits(in, s, BLOCK_SIZE); + final int mbits2 = Util.maxbits(in, s + BLOCK_SIZE, BLOCK_SIZE); + final int mbits3 = Util.maxbits(in, s + 2 * BLOCK_SIZE, BLOCK_SIZE); + final int mbits4 = Util.maxbits(in, s + 3 * BLOCK_SIZE, BLOCK_SIZE); + out[tmpoutpos++] = (mbits1 << 24) | (mbits2 << 16) + | (mbits3 << 8) | (mbits4); + BitPacking.fastpackwithoutmask(in, s, out, tmpoutpos, + mbits1); + tmpoutpos += mbits1; + BitPacking.fastpackwithoutmask(in, s + BLOCK_SIZE, out, + tmpoutpos, mbits2); + tmpoutpos += mbits2; + BitPacking.fastpackwithoutmask(in, s + 2 * BLOCK_SIZE, out, + tmpoutpos, mbits3); + tmpoutpos += mbits3; + BitPacking.fastpackwithoutmask(in, s + 3 * BLOCK_SIZE, out, + tmpoutpos, mbits4); + tmpoutpos += mbits4; + } + for (; s < inpos.get() + inlength; s += BLOCK_SIZE ) { + final int mbits = Util.maxbits(in, s, BLOCK_SIZE); + out[tmpoutpos++] = mbits; + BitPacking.fastpackwithoutmask(in, s, out, tmpoutpos, + mbits); + tmpoutpos += mbits; + + } + inpos.add(inlength); + outpos.set(tmpoutpos); + } - out[outpos.get()] = inlength; - outpos.increment(); - int tmpoutpos = outpos.get(); - for (int s = inpos.get(); s < inpos.get() + inlength; s += 32 * 4) { - final int mbits1 = Util.maxbits(in, s, 32); - final int mbits2 = Util.maxbits(in, s + 32, 32); - final int mbits3 = Util.maxbits(in, s + 2 * 32, 32); - final int mbits4 = Util.maxbits(in, s + 3 * 32, 32); - out[tmpoutpos++] = (mbits1 << 24) | (mbits2 << 16) | (mbits3 << 8) - | (mbits4); - BitPacking.fastpackwithoutmask(in, s, out, tmpoutpos, mbits1); - tmpoutpos += mbits1; - BitPacking.fastpackwithoutmask(in, s + 32, out, tmpoutpos, mbits2); - tmpoutpos += mbits2; - BitPacking.fastpackwithoutmask(in, s + 2 * 32, out, tmpoutpos, mbits3); - tmpoutpos += mbits3; - BitPacking.fastpackwithoutmask(in, s + 3 * 32, out, tmpoutpos, mbits4); - tmpoutpos += mbits4; + @Override + public void uncompress(int[] in, IntWrapper inpos, int inlength, + int[] out, IntWrapper outpos) { + if (inlength == 0) + return; + final int outlength = in[inpos.get()]; + inpos.increment(); + headlessUncompress(in,inpos, inlength,out,outpos,outlength); } - inpos.add(inlength); - outpos.set(tmpoutpos); - } - @Override - public void uncompress(int[] in, IntWrapper inpos, int inlength, int[] out, IntWrapper outpos) { - if(inlength == 0) return; - final int outlength = in[inpos.get()]; - inpos.increment(); - int tmpinpos = inpos.get(); - for (int s = outpos.get(); s < outpos.get() + outlength; s += 32 * 4) { - final int mbits1 = (in[tmpinpos] >>> 24); - final int mbits2 = (in[tmpinpos] >>> 16) & 0xFF; - final int mbits3 = (in[tmpinpos] >>> 8) & 0xFF; - final int mbits4 = (in[tmpinpos]) & 0xFF; - ++tmpinpos; - BitPacking.fastunpack(in, tmpinpos, out, s, mbits1); - tmpinpos += mbits1; - BitPacking.fastunpack(in, tmpinpos, out, s + 32, mbits2); - tmpinpos += mbits2; - BitPacking.fastunpack(in, tmpinpos, out, s + 2 * 32, mbits3); - tmpinpos += mbits3; - BitPacking.fastunpack(in, tmpinpos, out, s + 3 * 32, mbits4); - tmpinpos += mbits4; + @Override + public void headlessUncompress(int[] in, IntWrapper inpos, int inlength, + int[] out, IntWrapper outpos, int num) { + final int outlength = Util.greatestMultiple(num, BLOCK_SIZE); + int tmpinpos = inpos.get(); + int s = outpos.get(); + for (; s + BLOCK_SIZE * 4 - 1 < outpos.get() + outlength; s += BLOCK_SIZE * 4) { + final int mbits1 = (in[tmpinpos] >>> 24); + final int mbits2 = (in[tmpinpos] >>> 16) & 0xFF; + final int mbits3 = (in[tmpinpos] >>> 8) & 0xFF; + final int mbits4 = (in[tmpinpos]) & 0xFF; + ++tmpinpos; + BitPacking.fastunpack(in, tmpinpos, out, s, mbits1); + tmpinpos += mbits1; + BitPacking + .fastunpack(in, tmpinpos, out, s + BLOCK_SIZE, mbits2); + tmpinpos += mbits2; + BitPacking.fastunpack(in, tmpinpos, out, s + 2 * BLOCK_SIZE, + mbits3); + tmpinpos += mbits3; + BitPacking.fastunpack(in, tmpinpos, out, s + 3 * BLOCK_SIZE, + mbits4); + tmpinpos += mbits4; + } + for (; s < outpos.get() + outlength; s += BLOCK_SIZE ) { + final int mbits = in[tmpinpos]; + ++tmpinpos; + BitPacking.fastunpack(in, tmpinpos, out, s, mbits); + tmpinpos += mbits; + } + outpos.add(outlength); + inpos.set(tmpinpos); } - outpos.add(outlength); - inpos.set(tmpinpos); - } + @Override + public int maxHeadlessCompressedLength(IntWrapper compressedPositions, int inlength) { + int blockCount = inlength / BLOCK_SIZE; + int headersSizeInInts = blockCount / Integer.BYTES + (blockCount % Integer.BYTES); + int blocksSizeInInts = blockCount * MAX_BIT_WIDTH; + compressedPositions.add(blockCount * BLOCK_SIZE); + return headersSizeInInts + blocksSizeInInts; + } + + @Override + public String toString() { + return this.getClass().getSimpleName(); + } } diff --git a/src/main/java/me/lemire/integercompression/BitPacking.java b/src/main/java/me/lemire/integercompression/BitPacking.java index 8af38b5..8652be4 100644 --- a/src/main/java/me/lemire/integercompression/BitPacking.java +++ b/src/main/java/me/lemire/integercompression/BitPacking.java @@ -12,6940 +12,4660 @@ /** * Bitpacking routines * + *

For details, please see

+ *

+ * Daniel Lemire and Leonid Boytsov, Decoding billions of integers per second + * through vectorization Software: Practice & Experience + * http://onlinelibrary.wiley.com/doi/10.1002/spe.2203/abstract + * http://arxiv.org/abs/1209.2137 + *

+ * * @author Daniel Lemire - * + * */ public final class BitPacking { + /** + * Pack 32 integers + * + * @param in + * source array + * @param inpos + * position in source array + * @param out + * output array + * @param outpos + * position in output array + * @param bit + * number of bits to use per integer + */ + public static void fastpack(final int[] in, final int inpos, + final int[] out, final int outpos, final int bit) { + switch (bit) { + case 0: + fastpack0(in, inpos, out, outpos); + break; + case 1: + fastpack1(in, inpos, out, outpos); + break; + case 2: + fastpack2(in, inpos, out, outpos); + break; + case 3: + fastpack3(in, inpos, out, outpos); + break; + case 4: + fastpack4(in, inpos, out, outpos); + break; + case 5: + fastpack5(in, inpos, out, outpos); + break; + case 6: + fastpack6(in, inpos, out, outpos); + break; + case 7: + fastpack7(in, inpos, out, outpos); + break; + case 8: + fastpack8(in, inpos, out, outpos); + break; + case 9: + fastpack9(in, inpos, out, outpos); + break; + case 10: + fastpack10(in, inpos, out, outpos); + break; + case 11: + fastpack11(in, inpos, out, outpos); + break; + case 12: + fastpack12(in, inpos, out, outpos); + break; + case 13: + fastpack13(in, inpos, out, outpos); + break; + case 14: + fastpack14(in, inpos, out, outpos); + break; + case 15: + fastpack15(in, inpos, out, outpos); + break; + case 16: + fastpack16(in, inpos, out, outpos); + break; + case 17: + fastpack17(in, inpos, out, outpos); + break; + case 18: + fastpack18(in, inpos, out, outpos); + break; + case 19: + fastpack19(in, inpos, out, outpos); + break; + case 20: + fastpack20(in, inpos, out, outpos); + break; + case 21: + fastpack21(in, inpos, out, outpos); + break; + case 22: + fastpack22(in, inpos, out, outpos); + break; + case 23: + fastpack23(in, inpos, out, outpos); + break; + case 24: + fastpack24(in, inpos, out, outpos); + break; + case 25: + fastpack25(in, inpos, out, outpos); + break; + case 26: + fastpack26(in, inpos, out, outpos); + break; + case 27: + fastpack27(in, inpos, out, outpos); + break; + case 28: + fastpack28(in, inpos, out, outpos); + break; + case 29: + fastpack29(in, inpos, out, outpos); + break; + case 30: + fastpack30(in, inpos, out, outpos); + break; + case 31: + fastpack31(in, inpos, out, outpos); + break; + case 32: + fastpack32(in, inpos, out, outpos); + break; + default: + throw new IllegalArgumentException( + "Unsupported bit width."); + } + } - protected static void fastpackwithoutmask1(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = in[0 + inpos] - | ((in[1 + inpos]) << 1) - | ((in[2 + inpos]) << 2) - | ((in[3 + inpos]) << 3) - | ((in[4 + inpos]) << 4) - | ((in[5 + inpos]) << 5) - | ((in[6 + inpos]) << 6) - | ((in[7 + inpos]) << 7) - | ((in[8 + inpos]) << 8) - | ((in[9 + inpos]) << 9) - | ((in[10 + inpos]) << 10) - | ((in[11 + inpos]) << 11) - | ((in[12 + inpos]) << 12) - | ((in[13 + inpos]) << 13) - | ((in[14 + inpos]) << 14) - | ((in[15 + inpos]) << 15) - | ((in[16 + inpos]) << 16) - | ((in[17 + inpos]) << 17) - | ((in[18 + inpos]) << 18) - | ((in[19 + inpos]) << 19) - | ((in[20 + inpos]) << 20) - | ((in[21 + inpos]) << 21) - | ((in[22 + inpos]) << 22) - | ((in[23 + inpos]) << 23) - | ((in[24 + inpos]) << 24) - | ((in[25 + inpos]) << 25) - | ((in[26 + inpos]) << 26) - | ((in[27 + inpos]) << 27) - | ((in[28 + inpos]) << 28) - | ((in[29 + inpos]) << 29) - | ((in[30 + inpos]) << 30) - | ((in[31 + inpos]) << 31) - ; - } - - - protected static void fastpackwithoutmask2(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = in[0 + inpos] - | ((in[1 + inpos]) << 2) - | ((in[2 + inpos]) << 4) - | ((in[3 + inpos]) << 6) - | ((in[4 + inpos]) << 8) - | ((in[5 + inpos]) << 10) - | ((in[6 + inpos]) << 12) - | ((in[7 + inpos]) << 14) - | ((in[8 + inpos]) << 16) - | ((in[9 + inpos]) << 18) - | ((in[10 + inpos]) << 20) - | ((in[11 + inpos]) << 22) - | ((in[12 + inpos]) << 24) - | ((in[13 + inpos]) << 26) - | ((in[14 + inpos]) << 28) - | ((in[15 + inpos]) << 30) - ; - out[1 + outpos] = in[16 + inpos] - | ((in[17 + inpos]) << 2) - | ((in[18 + inpos]) << 4) - | ((in[19 + inpos]) << 6) - | ((in[20 + inpos]) << 8) - | ((in[21 + inpos]) << 10) - | ((in[22 + inpos]) << 12) - | ((in[23 + inpos]) << 14) - | ((in[24 + inpos]) << 16) - | ((in[25 + inpos]) << 18) - | ((in[26 + inpos]) << 20) - | ((in[27 + inpos]) << 22) - | ((in[28 + inpos]) << 24) - | ((in[29 + inpos]) << 26) - | ((in[30 + inpos]) << 28) - | ((in[31 + inpos]) << 30) - ; - } - - - protected static void fastpackwithoutmask3(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = in[0 + inpos] - | ((in[1 + inpos]) << 3) - | ((in[2 + inpos]) << 6) - | ((in[3 + inpos]) << 9) - | ((in[4 + inpos]) << 12) - | ((in[5 + inpos]) << 15) - | ((in[6 + inpos]) << 18) - | ((in[7 + inpos]) << 21) - | ((in[8 + inpos]) << 24) - | ((in[9 + inpos]) << 27) - | ((in[10 + inpos]) << 30) - ; - out[1 + outpos] = ((in[10 + inpos]) >>> (3 - 1)) - | ((in[11 + inpos]) << 1) - | ((in[12 + inpos]) << 4) - | ((in[13 + inpos]) << 7) - | ((in[14 + inpos]) << 10) - | ((in[15 + inpos]) << 13) - | ((in[16 + inpos]) << 16) - | ((in[17 + inpos]) << 19) - | ((in[18 + inpos]) << 22) - | ((in[19 + inpos]) << 25) - | ((in[20 + inpos]) << 28) - | ((in[21 + inpos]) << 31) - ; - out[2 + outpos] = ((in[21 + inpos]) >>> (3 - 2)) - | ((in[22 + inpos]) << 2) - | ((in[23 + inpos]) << 5) - | ((in[24 + inpos]) << 8) - | ((in[25 + inpos]) << 11) - | ((in[26 + inpos]) << 14) - | ((in[27 + inpos]) << 17) - | ((in[28 + inpos]) << 20) - | ((in[29 + inpos]) << 23) - | ((in[30 + inpos]) << 26) - | ((in[31 + inpos]) << 29) - ; - } - - - protected static void fastpackwithoutmask4(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = in[0 + inpos] - | ((in[1 + inpos]) << 4) - | ((in[2 + inpos]) << 8) - | ((in[3 + inpos]) << 12) - | ((in[4 + inpos]) << 16) - | ((in[5 + inpos]) << 20) - | ((in[6 + inpos]) << 24) - | ((in[7 + inpos]) << 28) - ; - out[1 + outpos] = in[8 + inpos] - | ((in[9 + inpos]) << 4) - | ((in[10 + inpos]) << 8) - | ((in[11 + inpos]) << 12) - | ((in[12 + inpos]) << 16) - | ((in[13 + inpos]) << 20) - | ((in[14 + inpos]) << 24) - | ((in[15 + inpos]) << 28) - ; - out[2 + outpos] = in[16 + inpos] - | ((in[17 + inpos]) << 4) - | ((in[18 + inpos]) << 8) - | ((in[19 + inpos]) << 12) - | ((in[20 + inpos]) << 16) - | ((in[21 + inpos]) << 20) - | ((in[22 + inpos]) << 24) - | ((in[23 + inpos]) << 28) - ; - out[3 + outpos] = in[24 + inpos] - | ((in[25 + inpos]) << 4) - | ((in[26 + inpos]) << 8) - | ((in[27 + inpos]) << 12) - | ((in[28 + inpos]) << 16) - | ((in[29 + inpos]) << 20) - | ((in[30 + inpos]) << 24) - | ((in[31 + inpos]) << 28) - ; - } - - - protected static void fastpackwithoutmask5(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = in[0 + inpos] - | ((in[1 + inpos]) << 5) - | ((in[2 + inpos]) << 10) - | ((in[3 + inpos]) << 15) - | ((in[4 + inpos]) << 20) - | ((in[5 + inpos]) << 25) - | ((in[6 + inpos]) << 30) - ; - out[1 + outpos] = ((in[6 + inpos]) >>> (5 - 3)) - | ((in[7 + inpos]) << 3) - | ((in[8 + inpos]) << 8) - | ((in[9 + inpos]) << 13) - | ((in[10 + inpos]) << 18) - | ((in[11 + inpos]) << 23) - | ((in[12 + inpos]) << 28) - ; - out[2 + outpos] = ((in[12 + inpos]) >>> (5 - 1)) - | ((in[13 + inpos]) << 1) - | ((in[14 + inpos]) << 6) - | ((in[15 + inpos]) << 11) - | ((in[16 + inpos]) << 16) - | ((in[17 + inpos]) << 21) - | ((in[18 + inpos]) << 26) - | ((in[19 + inpos]) << 31) - ; - out[3 + outpos] = ((in[19 + inpos]) >>> (5 - 4)) - | ((in[20 + inpos]) << 4) - | ((in[21 + inpos]) << 9) - | ((in[22 + inpos]) << 14) - | ((in[23 + inpos]) << 19) - | ((in[24 + inpos]) << 24) - | ((in[25 + inpos]) << 29) - ; - out[4 + outpos] = ((in[25 + inpos]) >>> (5 - 2)) - | ((in[26 + inpos]) << 2) - | ((in[27 + inpos]) << 7) - | ((in[28 + inpos]) << 12) - | ((in[29 + inpos]) << 17) - | ((in[30 + inpos]) << 22) - | ((in[31 + inpos]) << 27) - ; - } - - - protected static void fastpackwithoutmask6(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = in[0 + inpos] - | ((in[1 + inpos]) << 6) - | ((in[2 + inpos]) << 12) - | ((in[3 + inpos]) << 18) - | ((in[4 + inpos]) << 24) - | ((in[5 + inpos]) << 30) - ; - out[1 + outpos] = ((in[5 + inpos]) >>> (6 - 4)) - | ((in[6 + inpos]) << 4) - | ((in[7 + inpos]) << 10) - | ((in[8 + inpos]) << 16) - | ((in[9 + inpos]) << 22) - | ((in[10 + inpos]) << 28) - ; - out[2 + outpos] = ((in[10 + inpos]) >>> (6 - 2)) - | ((in[11 + inpos]) << 2) - | ((in[12 + inpos]) << 8) - | ((in[13 + inpos]) << 14) - | ((in[14 + inpos]) << 20) - | ((in[15 + inpos]) << 26) - ; - out[3 + outpos] = in[16 + inpos] - | ((in[17 + inpos]) << 6) - | ((in[18 + inpos]) << 12) - | ((in[19 + inpos]) << 18) - | ((in[20 + inpos]) << 24) - | ((in[21 + inpos]) << 30) - ; - out[4 + outpos] = ((in[21 + inpos]) >>> (6 - 4)) - | ((in[22 + inpos]) << 4) - | ((in[23 + inpos]) << 10) - | ((in[24 + inpos]) << 16) - | ((in[25 + inpos]) << 22) - | ((in[26 + inpos]) << 28) - ; - out[5 + outpos] = ((in[26 + inpos]) >>> (6 - 2)) - | ((in[27 + inpos]) << 2) - | ((in[28 + inpos]) << 8) - | ((in[29 + inpos]) << 14) - | ((in[30 + inpos]) << 20) - | ((in[31 + inpos]) << 26) - ; - } - - - protected static void fastpackwithoutmask7(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = in[0 + inpos] - | ((in[1 + inpos]) << 7) - | ((in[2 + inpos]) << 14) - | ((in[3 + inpos]) << 21) - | ((in[4 + inpos]) << 28) - ; - out[1 + outpos] = ((in[4 + inpos]) >>> (7 - 3)) - | ((in[5 + inpos]) << 3) - | ((in[6 + inpos]) << 10) - | ((in[7 + inpos]) << 17) - | ((in[8 + inpos]) << 24) - | ((in[9 + inpos]) << 31) - ; - out[2 + outpos] = ((in[9 + inpos]) >>> (7 - 6)) - | ((in[10 + inpos]) << 6) - | ((in[11 + inpos]) << 13) - | ((in[12 + inpos]) << 20) - | ((in[13 + inpos]) << 27) - ; - out[3 + outpos] = ((in[13 + inpos]) >>> (7 - 2)) - | ((in[14 + inpos]) << 2) - | ((in[15 + inpos]) << 9) - | ((in[16 + inpos]) << 16) - | ((in[17 + inpos]) << 23) - | ((in[18 + inpos]) << 30) - ; - out[4 + outpos] = ((in[18 + inpos]) >>> (7 - 5)) - | ((in[19 + inpos]) << 5) - | ((in[20 + inpos]) << 12) - | ((in[21 + inpos]) << 19) - | ((in[22 + inpos]) << 26) - ; - out[5 + outpos] = ((in[22 + inpos]) >>> (7 - 1)) - | ((in[23 + inpos]) << 1) - | ((in[24 + inpos]) << 8) - | ((in[25 + inpos]) << 15) - | ((in[26 + inpos]) << 22) - | ((in[27 + inpos]) << 29) - ; - out[6 + outpos] = ((in[27 + inpos]) >>> (7 - 4)) - | ((in[28 + inpos]) << 4) - | ((in[29 + inpos]) << 11) - | ((in[30 + inpos]) << 18) - | ((in[31 + inpos]) << 25) - ; - } - - - protected static void fastpackwithoutmask8(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = in[0 + inpos] - | ((in[1 + inpos]) << 8) - | ((in[2 + inpos]) << 16) - | ((in[3 + inpos]) << 24) - ; - out[1 + outpos] = in[4 + inpos] - | ((in[5 + inpos]) << 8) - | ((in[6 + inpos]) << 16) - | ((in[7 + inpos]) << 24) - ; - out[2 + outpos] = in[8 + inpos] - | ((in[9 + inpos]) << 8) - | ((in[10 + inpos]) << 16) - | ((in[11 + inpos]) << 24) - ; - out[3 + outpos] = in[12 + inpos] - | ((in[13 + inpos]) << 8) - | ((in[14 + inpos]) << 16) - | ((in[15 + inpos]) << 24) - ; - out[4 + outpos] = in[16 + inpos] - | ((in[17 + inpos]) << 8) - | ((in[18 + inpos]) << 16) - | ((in[19 + inpos]) << 24) - ; - out[5 + outpos] = in[20 + inpos] - | ((in[21 + inpos]) << 8) - | ((in[22 + inpos]) << 16) - | ((in[23 + inpos]) << 24) - ; - out[6 + outpos] = in[24 + inpos] - | ((in[25 + inpos]) << 8) - | ((in[26 + inpos]) << 16) - | ((in[27 + inpos]) << 24) - ; - out[7 + outpos] = in[28 + inpos] - | ((in[29 + inpos]) << 8) - | ((in[30 + inpos]) << 16) - | ((in[31 + inpos]) << 24) - ; - } - - - protected static void fastpackwithoutmask9(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = in[0 + inpos] - | ((in[1 + inpos]) << 9) - | ((in[2 + inpos]) << 18) - | ((in[3 + inpos]) << 27) - ; - out[1 + outpos] = ((in[3 + inpos]) >>> (9 - 4)) - | ((in[4 + inpos]) << 4) - | ((in[5 + inpos]) << 13) - | ((in[6 + inpos]) << 22) - | ((in[7 + inpos]) << 31) - ; - out[2 + outpos] = ((in[7 + inpos]) >>> (9 - 8)) - | ((in[8 + inpos]) << 8) - | ((in[9 + inpos]) << 17) - | ((in[10 + inpos]) << 26) - ; - out[3 + outpos] = ((in[10 + inpos]) >>> (9 - 3)) - | ((in[11 + inpos]) << 3) - | ((in[12 + inpos]) << 12) - | ((in[13 + inpos]) << 21) - | ((in[14 + inpos]) << 30) - ; - out[4 + outpos] = ((in[14 + inpos]) >>> (9 - 7)) - | ((in[15 + inpos]) << 7) - | ((in[16 + inpos]) << 16) - | ((in[17 + inpos]) << 25) - ; - out[5 + outpos] = ((in[17 + inpos]) >>> (9 - 2)) - | ((in[18 + inpos]) << 2) - | ((in[19 + inpos]) << 11) - | ((in[20 + inpos]) << 20) - | ((in[21 + inpos]) << 29) - ; - out[6 + outpos] = ((in[21 + inpos]) >>> (9 - 6)) - | ((in[22 + inpos]) << 6) - | ((in[23 + inpos]) << 15) - | ((in[24 + inpos]) << 24) - ; - out[7 + outpos] = ((in[24 + inpos]) >>> (9 - 1)) - | ((in[25 + inpos]) << 1) - | ((in[26 + inpos]) << 10) - | ((in[27 + inpos]) << 19) - | ((in[28 + inpos]) << 28) - ; - out[8 + outpos] = ((in[28 + inpos]) >>> (9 - 5)) - | ((in[29 + inpos]) << 5) - | ((in[30 + inpos]) << 14) - | ((in[31 + inpos]) << 23) - ; - } - - - protected static void fastpackwithoutmask10(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = in[0 + inpos] - | ((in[1 + inpos]) << 10) - | ((in[2 + inpos]) << 20) - | ((in[3 + inpos]) << 30) - ; - out[1 + outpos] = ((in[3 + inpos]) >>> (10 - 8)) - | ((in[4 + inpos]) << 8) - | ((in[5 + inpos]) << 18) - | ((in[6 + inpos]) << 28) - ; - out[2 + outpos] = ((in[6 + inpos]) >>> (10 - 6)) - | ((in[7 + inpos]) << 6) - | ((in[8 + inpos]) << 16) - | ((in[9 + inpos]) << 26) - ; - out[3 + outpos] = ((in[9 + inpos]) >>> (10 - 4)) - | ((in[10 + inpos]) << 4) - | ((in[11 + inpos]) << 14) - | ((in[12 + inpos]) << 24) - ; - out[4 + outpos] = ((in[12 + inpos]) >>> (10 - 2)) - | ((in[13 + inpos]) << 2) - | ((in[14 + inpos]) << 12) - | ((in[15 + inpos]) << 22) - ; - out[5 + outpos] = in[16 + inpos] - | ((in[17 + inpos]) << 10) - | ((in[18 + inpos]) << 20) - | ((in[19 + inpos]) << 30) - ; - out[6 + outpos] = ((in[19 + inpos]) >>> (10 - 8)) - | ((in[20 + inpos]) << 8) - | ((in[21 + inpos]) << 18) - | ((in[22 + inpos]) << 28) - ; - out[7 + outpos] = ((in[22 + inpos]) >>> (10 - 6)) - | ((in[23 + inpos]) << 6) - | ((in[24 + inpos]) << 16) - | ((in[25 + inpos]) << 26) - ; - out[8 + outpos] = ((in[25 + inpos]) >>> (10 - 4)) - | ((in[26 + inpos]) << 4) - | ((in[27 + inpos]) << 14) - | ((in[28 + inpos]) << 24) - ; - out[9 + outpos] = ((in[28 + inpos]) >>> (10 - 2)) - | ((in[29 + inpos]) << 2) - | ((in[30 + inpos]) << 12) - | ((in[31 + inpos]) << 22) - ; - } - - - protected static void fastpackwithoutmask11(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = in[0 + inpos] - | ((in[1 + inpos]) << 11) - | ((in[2 + inpos]) << 22) - ; - out[1 + outpos] = ((in[2 + inpos]) >>> (11 - 1)) - | ((in[3 + inpos]) << 1) - | ((in[4 + inpos]) << 12) - | ((in[5 + inpos]) << 23) - ; - out[2 + outpos] = ((in[5 + inpos]) >>> (11 - 2)) - | ((in[6 + inpos]) << 2) - | ((in[7 + inpos]) << 13) - | ((in[8 + inpos]) << 24) - ; - out[3 + outpos] = ((in[8 + inpos]) >>> (11 - 3)) - | ((in[9 + inpos]) << 3) - | ((in[10 + inpos]) << 14) - | ((in[11 + inpos]) << 25) - ; - out[4 + outpos] = ((in[11 + inpos]) >>> (11 - 4)) - | ((in[12 + inpos]) << 4) - | ((in[13 + inpos]) << 15) - | ((in[14 + inpos]) << 26) - ; - out[5 + outpos] = ((in[14 + inpos]) >>> (11 - 5)) - | ((in[15 + inpos]) << 5) - | ((in[16 + inpos]) << 16) - | ((in[17 + inpos]) << 27) - ; - out[6 + outpos] = ((in[17 + inpos]) >>> (11 - 6)) - | ((in[18 + inpos]) << 6) - | ((in[19 + inpos]) << 17) - | ((in[20 + inpos]) << 28) - ; - out[7 + outpos] = ((in[20 + inpos]) >>> (11 - 7)) - | ((in[21 + inpos]) << 7) - | ((in[22 + inpos]) << 18) - | ((in[23 + inpos]) << 29) - ; - out[8 + outpos] = ((in[23 + inpos]) >>> (11 - 8)) - | ((in[24 + inpos]) << 8) - | ((in[25 + inpos]) << 19) - | ((in[26 + inpos]) << 30) - ; - out[9 + outpos] = ((in[26 + inpos]) >>> (11 - 9)) - | ((in[27 + inpos]) << 9) - | ((in[28 + inpos]) << 20) - | ((in[29 + inpos]) << 31) - ; - out[10 + outpos] = ((in[29 + inpos]) >>> (11 - 10)) - | ((in[30 + inpos]) << 10) - | ((in[31 + inpos]) << 21) - ; - } - - - protected static void fastpackwithoutmask12(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = in[0 + inpos] - | ((in[1 + inpos]) << 12) - | ((in[2 + inpos]) << 24) - ; - out[1 + outpos] = ((in[2 + inpos]) >>> (12 - 4)) - | ((in[3 + inpos]) << 4) - | ((in[4 + inpos]) << 16) - | ((in[5 + inpos]) << 28) - ; - out[2 + outpos] = ((in[5 + inpos]) >>> (12 - 8)) - | ((in[6 + inpos]) << 8) - | ((in[7 + inpos]) << 20) - ; - out[3 + outpos] = in[8 + inpos] - | ((in[9 + inpos]) << 12) - | ((in[10 + inpos]) << 24) - ; - out[4 + outpos] = ((in[10 + inpos]) >>> (12 - 4)) - | ((in[11 + inpos]) << 4) - | ((in[12 + inpos]) << 16) - | ((in[13 + inpos]) << 28) - ; - out[5 + outpos] = ((in[13 + inpos]) >>> (12 - 8)) - | ((in[14 + inpos]) << 8) - | ((in[15 + inpos]) << 20) - ; - out[6 + outpos] = in[16 + inpos] - | ((in[17 + inpos]) << 12) - | ((in[18 + inpos]) << 24) - ; - out[7 + outpos] = ((in[18 + inpos]) >>> (12 - 4)) - | ((in[19 + inpos]) << 4) - | ((in[20 + inpos]) << 16) - | ((in[21 + inpos]) << 28) - ; - out[8 + outpos] = ((in[21 + inpos]) >>> (12 - 8)) - | ((in[22 + inpos]) << 8) - | ((in[23 + inpos]) << 20) - ; - out[9 + outpos] = in[24 + inpos] - | ((in[25 + inpos]) << 12) - | ((in[26 + inpos]) << 24) - ; - out[10 + outpos] = ((in[26 + inpos]) >>> (12 - 4)) - | ((in[27 + inpos]) << 4) - | ((in[28 + inpos]) << 16) - | ((in[29 + inpos]) << 28) - ; - out[11 + outpos] = ((in[29 + inpos]) >>> (12 - 8)) - | ((in[30 + inpos]) << 8) - | ((in[31 + inpos]) << 20) - ; - } - - - protected static void fastpackwithoutmask13(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = in[0 + inpos] - | ((in[1 + inpos]) << 13) - | ((in[2 + inpos]) << 26) - ; - out[1 + outpos] = ((in[2 + inpos]) >>> (13 - 7)) - | ((in[3 + inpos]) << 7) - | ((in[4 + inpos]) << 20) - ; - out[2 + outpos] = ((in[4 + inpos]) >>> (13 - 1)) - | ((in[5 + inpos]) << 1) - | ((in[6 + inpos]) << 14) - | ((in[7 + inpos]) << 27) - ; - out[3 + outpos] = ((in[7 + inpos]) >>> (13 - 8)) - | ((in[8 + inpos]) << 8) - | ((in[9 + inpos]) << 21) - ; - out[4 + outpos] = ((in[9 + inpos]) >>> (13 - 2)) - | ((in[10 + inpos]) << 2) - | ((in[11 + inpos]) << 15) - | ((in[12 + inpos]) << 28) - ; - out[5 + outpos] = ((in[12 + inpos]) >>> (13 - 9)) - | ((in[13 + inpos]) << 9) - | ((in[14 + inpos]) << 22) - ; - out[6 + outpos] = ((in[14 + inpos]) >>> (13 - 3)) - | ((in[15 + inpos]) << 3) - | ((in[16 + inpos]) << 16) - | ((in[17 + inpos]) << 29) - ; - out[7 + outpos] = ((in[17 + inpos]) >>> (13 - 10)) - | ((in[18 + inpos]) << 10) - | ((in[19 + inpos]) << 23) - ; - out[8 + outpos] = ((in[19 + inpos]) >>> (13 - 4)) - | ((in[20 + inpos]) << 4) - | ((in[21 + inpos]) << 17) - | ((in[22 + inpos]) << 30) - ; - out[9 + outpos] = ((in[22 + inpos]) >>> (13 - 11)) - | ((in[23 + inpos]) << 11) - | ((in[24 + inpos]) << 24) - ; - out[10 + outpos] = ((in[24 + inpos]) >>> (13 - 5)) - | ((in[25 + inpos]) << 5) - | ((in[26 + inpos]) << 18) - | ((in[27 + inpos]) << 31) - ; - out[11 + outpos] = ((in[27 + inpos]) >>> (13 - 12)) - | ((in[28 + inpos]) << 12) - | ((in[29 + inpos]) << 25) - ; - out[12 + outpos] = ((in[29 + inpos]) >>> (13 - 6)) - | ((in[30 + inpos]) << 6) - | ((in[31 + inpos]) << 19) - ; - } - - - protected static void fastpackwithoutmask14(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = in[0 + inpos] - | ((in[1 + inpos]) << 14) - | ((in[2 + inpos]) << 28) - ; - out[1 + outpos] = ((in[2 + inpos]) >>> (14 - 10)) - | ((in[3 + inpos]) << 10) - | ((in[4 + inpos]) << 24) - ; - out[2 + outpos] = ((in[4 + inpos]) >>> (14 - 6)) - | ((in[5 + inpos]) << 6) - | ((in[6 + inpos]) << 20) - ; - out[3 + outpos] = ((in[6 + inpos]) >>> (14 - 2)) - | ((in[7 + inpos]) << 2) - | ((in[8 + inpos]) << 16) - | ((in[9 + inpos]) << 30) - ; - out[4 + outpos] = ((in[9 + inpos]) >>> (14 - 12)) - | ((in[10 + inpos]) << 12) - | ((in[11 + inpos]) << 26) - ; - out[5 + outpos] = ((in[11 + inpos]) >>> (14 - 8)) - | ((in[12 + inpos]) << 8) - | ((in[13 + inpos]) << 22) - ; - out[6 + outpos] = ((in[13 + inpos]) >>> (14 - 4)) - | ((in[14 + inpos]) << 4) - | ((in[15 + inpos]) << 18) - ; - out[7 + outpos] = in[16 + inpos] - | ((in[17 + inpos]) << 14) - | ((in[18 + inpos]) << 28) - ; - out[8 + outpos] = ((in[18 + inpos]) >>> (14 - 10)) - | ((in[19 + inpos]) << 10) - | ((in[20 + inpos]) << 24) - ; - out[9 + outpos] = ((in[20 + inpos]) >>> (14 - 6)) - | ((in[21 + inpos]) << 6) - | ((in[22 + inpos]) << 20) - ; - out[10 + outpos] = ((in[22 + inpos]) >>> (14 - 2)) - | ((in[23 + inpos]) << 2) - | ((in[24 + inpos]) << 16) - | ((in[25 + inpos]) << 30) - ; - out[11 + outpos] = ((in[25 + inpos]) >>> (14 - 12)) - | ((in[26 + inpos]) << 12) - | ((in[27 + inpos]) << 26) - ; - out[12 + outpos] = ((in[27 + inpos]) >>> (14 - 8)) - | ((in[28 + inpos]) << 8) - | ((in[29 + inpos]) << 22) - ; - out[13 + outpos] = ((in[29 + inpos]) >>> (14 - 4)) - | ((in[30 + inpos]) << 4) - | ((in[31 + inpos]) << 18) - ; - } - - - protected static void fastpackwithoutmask15(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = in[0 + inpos] - | ((in[1 + inpos]) << 15) - | ((in[2 + inpos]) << 30) - ; - out[1 + outpos] = ((in[2 + inpos]) >>> (15 - 13)) - | ((in[3 + inpos]) << 13) - | ((in[4 + inpos]) << 28) - ; - out[2 + outpos] = ((in[4 + inpos]) >>> (15 - 11)) - | ((in[5 + inpos]) << 11) - | ((in[6 + inpos]) << 26) - ; - out[3 + outpos] = ((in[6 + inpos]) >>> (15 - 9)) - | ((in[7 + inpos]) << 9) - | ((in[8 + inpos]) << 24) - ; - out[4 + outpos] = ((in[8 + inpos]) >>> (15 - 7)) - | ((in[9 + inpos]) << 7) - | ((in[10 + inpos]) << 22) - ; - out[5 + outpos] = ((in[10 + inpos]) >>> (15 - 5)) - | ((in[11 + inpos]) << 5) - | ((in[12 + inpos]) << 20) - ; - out[6 + outpos] = ((in[12 + inpos]) >>> (15 - 3)) - | ((in[13 + inpos]) << 3) - | ((in[14 + inpos]) << 18) - ; - out[7 + outpos] = ((in[14 + inpos]) >>> (15 - 1)) - | ((in[15 + inpos]) << 1) - | ((in[16 + inpos]) << 16) - | ((in[17 + inpos]) << 31) - ; - out[8 + outpos] = ((in[17 + inpos]) >>> (15 - 14)) - | ((in[18 + inpos]) << 14) - | ((in[19 + inpos]) << 29) - ; - out[9 + outpos] = ((in[19 + inpos]) >>> (15 - 12)) - | ((in[20 + inpos]) << 12) - | ((in[21 + inpos]) << 27) - ; - out[10 + outpos] = ((in[21 + inpos]) >>> (15 - 10)) - | ((in[22 + inpos]) << 10) - | ((in[23 + inpos]) << 25) - ; - out[11 + outpos] = ((in[23 + inpos]) >>> (15 - 8)) - | ((in[24 + inpos]) << 8) - | ((in[25 + inpos]) << 23) - ; - out[12 + outpos] = ((in[25 + inpos]) >>> (15 - 6)) - | ((in[26 + inpos]) << 6) - | ((in[27 + inpos]) << 21) - ; - out[13 + outpos] = ((in[27 + inpos]) >>> (15 - 4)) - | ((in[28 + inpos]) << 4) - | ((in[29 + inpos]) << 19) - ; - out[14 + outpos] = ((in[29 + inpos]) >>> (15 - 2)) - | ((in[30 + inpos]) << 2) - | ((in[31 + inpos]) << 17) - ; - } - - - protected static void fastpackwithoutmask16(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = in[0 + inpos] - | ((in[1 + inpos]) << 16) - ; - out[1 + outpos] = in[2 + inpos] - | ((in[3 + inpos]) << 16) - ; - out[2 + outpos] = in[4 + inpos] - | ((in[5 + inpos]) << 16) - ; - out[3 + outpos] = in[6 + inpos] - | ((in[7 + inpos]) << 16) - ; - out[4 + outpos] = in[8 + inpos] - | ((in[9 + inpos]) << 16) - ; - out[5 + outpos] = in[10 + inpos] - | ((in[11 + inpos]) << 16) - ; - out[6 + outpos] = in[12 + inpos] - | ((in[13 + inpos]) << 16) - ; - out[7 + outpos] = in[14 + inpos] - | ((in[15 + inpos]) << 16) - ; - out[8 + outpos] = in[16 + inpos] - | ((in[17 + inpos]) << 16) - ; - out[9 + outpos] = in[18 + inpos] - | ((in[19 + inpos]) << 16) - ; - out[10 + outpos] = in[20 + inpos] - | ((in[21 + inpos]) << 16) - ; - out[11 + outpos] = in[22 + inpos] - | ((in[23 + inpos]) << 16) - ; - out[12 + outpos] = in[24 + inpos] - | ((in[25 + inpos]) << 16) - ; - out[13 + outpos] = in[26 + inpos] - | ((in[27 + inpos]) << 16) - ; - out[14 + outpos] = in[28 + inpos] - | ((in[29 + inpos]) << 16) - ; - out[15 + outpos] = in[30 + inpos] - | ((in[31 + inpos]) << 16) - ; - } - - - protected static void fastpackwithoutmask17(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = in[0 + inpos] - | ((in[1 + inpos]) << 17) - ; - out[1 + outpos] = ((in[1 + inpos]) >>> (17 - 2)) - | ((in[2 + inpos]) << 2) - | ((in[3 + inpos]) << 19) - ; - out[2 + outpos] = ((in[3 + inpos]) >>> (17 - 4)) - | ((in[4 + inpos]) << 4) - | ((in[5 + inpos]) << 21) - ; - out[3 + outpos] = ((in[5 + inpos]) >>> (17 - 6)) - | ((in[6 + inpos]) << 6) - | ((in[7 + inpos]) << 23) - ; - out[4 + outpos] = ((in[7 + inpos]) >>> (17 - 8)) - | ((in[8 + inpos]) << 8) - | ((in[9 + inpos]) << 25) - ; - out[5 + outpos] = ((in[9 + inpos]) >>> (17 - 10)) - | ((in[10 + inpos]) << 10) - | ((in[11 + inpos]) << 27) - ; - out[6 + outpos] = ((in[11 + inpos]) >>> (17 - 12)) - | ((in[12 + inpos]) << 12) - | ((in[13 + inpos]) << 29) - ; - out[7 + outpos] = ((in[13 + inpos]) >>> (17 - 14)) - | ((in[14 + inpos]) << 14) - | ((in[15 + inpos]) << 31) - ; - out[8 + outpos] = ((in[15 + inpos]) >>> (17 - 16)) - | ((in[16 + inpos]) << 16) - ; - out[9 + outpos] = ((in[16 + inpos]) >>> (17 - 1)) - | ((in[17 + inpos]) << 1) - | ((in[18 + inpos]) << 18) - ; - out[10 + outpos] = ((in[18 + inpos]) >>> (17 - 3)) - | ((in[19 + inpos]) << 3) - | ((in[20 + inpos]) << 20) - ; - out[11 + outpos] = ((in[20 + inpos]) >>> (17 - 5)) - | ((in[21 + inpos]) << 5) - | ((in[22 + inpos]) << 22) - ; - out[12 + outpos] = ((in[22 + inpos]) >>> (17 - 7)) - | ((in[23 + inpos]) << 7) - | ((in[24 + inpos]) << 24) - ; - out[13 + outpos] = ((in[24 + inpos]) >>> (17 - 9)) - | ((in[25 + inpos]) << 9) - | ((in[26 + inpos]) << 26) - ; - out[14 + outpos] = ((in[26 + inpos]) >>> (17 - 11)) - | ((in[27 + inpos]) << 11) - | ((in[28 + inpos]) << 28) - ; - out[15 + outpos] = ((in[28 + inpos]) >>> (17 - 13)) - | ((in[29 + inpos]) << 13) - | ((in[30 + inpos]) << 30) - ; - out[16 + outpos] = ((in[30 + inpos]) >>> (17 - 15)) - | ((in[31 + inpos]) << 15) - ; - } - - - protected static void fastpackwithoutmask18(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = in[0 + inpos] - | ((in[1 + inpos]) << 18) - ; - out[1 + outpos] = ((in[1 + inpos]) >>> (18 - 4)) - | ((in[2 + inpos]) << 4) - | ((in[3 + inpos]) << 22) - ; - out[2 + outpos] = ((in[3 + inpos]) >>> (18 - 8)) - | ((in[4 + inpos]) << 8) - | ((in[5 + inpos]) << 26) - ; - out[3 + outpos] = ((in[5 + inpos]) >>> (18 - 12)) - | ((in[6 + inpos]) << 12) - | ((in[7 + inpos]) << 30) - ; - out[4 + outpos] = ((in[7 + inpos]) >>> (18 - 16)) - | ((in[8 + inpos]) << 16) - ; - out[5 + outpos] = ((in[8 + inpos]) >>> (18 - 2)) - | ((in[9 + inpos]) << 2) - | ((in[10 + inpos]) << 20) - ; - out[6 + outpos] = ((in[10 + inpos]) >>> (18 - 6)) - | ((in[11 + inpos]) << 6) - | ((in[12 + inpos]) << 24) - ; - out[7 + outpos] = ((in[12 + inpos]) >>> (18 - 10)) - | ((in[13 + inpos]) << 10) - | ((in[14 + inpos]) << 28) - ; - out[8 + outpos] = ((in[14 + inpos]) >>> (18 - 14)) - | ((in[15 + inpos]) << 14) - ; - out[9 + outpos] = in[16 + inpos] - | ((in[17 + inpos]) << 18) - ; - out[10 + outpos] = ((in[17 + inpos]) >>> (18 - 4)) - | ((in[18 + inpos]) << 4) - | ((in[19 + inpos]) << 22) - ; - out[11 + outpos] = ((in[19 + inpos]) >>> (18 - 8)) - | ((in[20 + inpos]) << 8) - | ((in[21 + inpos]) << 26) - ; - out[12 + outpos] = ((in[21 + inpos]) >>> (18 - 12)) - | ((in[22 + inpos]) << 12) - | ((in[23 + inpos]) << 30) - ; - out[13 + outpos] = ((in[23 + inpos]) >>> (18 - 16)) - | ((in[24 + inpos]) << 16) - ; - out[14 + outpos] = ((in[24 + inpos]) >>> (18 - 2)) - | ((in[25 + inpos]) << 2) - | ((in[26 + inpos]) << 20) - ; - out[15 + outpos] = ((in[26 + inpos]) >>> (18 - 6)) - | ((in[27 + inpos]) << 6) - | ((in[28 + inpos]) << 24) - ; - out[16 + outpos] = ((in[28 + inpos]) >>> (18 - 10)) - | ((in[29 + inpos]) << 10) - | ((in[30 + inpos]) << 28) - ; - out[17 + outpos] = ((in[30 + inpos]) >>> (18 - 14)) - | ((in[31 + inpos]) << 14) - ; - } - - - protected static void fastpackwithoutmask19(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = in[0 + inpos] - | ((in[1 + inpos]) << 19) - ; - out[1 + outpos] = ((in[1 + inpos]) >>> (19 - 6)) - | ((in[2 + inpos]) << 6) - | ((in[3 + inpos]) << 25) - ; - out[2 + outpos] = ((in[3 + inpos]) >>> (19 - 12)) - | ((in[4 + inpos]) << 12) - | ((in[5 + inpos]) << 31) - ; - out[3 + outpos] = ((in[5 + inpos]) >>> (19 - 18)) - | ((in[6 + inpos]) << 18) - ; - out[4 + outpos] = ((in[6 + inpos]) >>> (19 - 5)) - | ((in[7 + inpos]) << 5) - | ((in[8 + inpos]) << 24) - ; - out[5 + outpos] = ((in[8 + inpos]) >>> (19 - 11)) - | ((in[9 + inpos]) << 11) - | ((in[10 + inpos]) << 30) - ; - out[6 + outpos] = ((in[10 + inpos]) >>> (19 - 17)) - | ((in[11 + inpos]) << 17) - ; - out[7 + outpos] = ((in[11 + inpos]) >>> (19 - 4)) - | ((in[12 + inpos]) << 4) - | ((in[13 + inpos]) << 23) - ; - out[8 + outpos] = ((in[13 + inpos]) >>> (19 - 10)) - | ((in[14 + inpos]) << 10) - | ((in[15 + inpos]) << 29) - ; - out[9 + outpos] = ((in[15 + inpos]) >>> (19 - 16)) - | ((in[16 + inpos]) << 16) - ; - out[10 + outpos] = ((in[16 + inpos]) >>> (19 - 3)) - | ((in[17 + inpos]) << 3) - | ((in[18 + inpos]) << 22) - ; - out[11 + outpos] = ((in[18 + inpos]) >>> (19 - 9)) - | ((in[19 + inpos]) << 9) - | ((in[20 + inpos]) << 28) - ; - out[12 + outpos] = ((in[20 + inpos]) >>> (19 - 15)) - | ((in[21 + inpos]) << 15) - ; - out[13 + outpos] = ((in[21 + inpos]) >>> (19 - 2)) - | ((in[22 + inpos]) << 2) - | ((in[23 + inpos]) << 21) - ; - out[14 + outpos] = ((in[23 + inpos]) >>> (19 - 8)) - | ((in[24 + inpos]) << 8) - | ((in[25 + inpos]) << 27) - ; - out[15 + outpos] = ((in[25 + inpos]) >>> (19 - 14)) - | ((in[26 + inpos]) << 14) - ; - out[16 + outpos] = ((in[26 + inpos]) >>> (19 - 1)) - | ((in[27 + inpos]) << 1) - | ((in[28 + inpos]) << 20) - ; - out[17 + outpos] = ((in[28 + inpos]) >>> (19 - 7)) - | ((in[29 + inpos]) << 7) - | ((in[30 + inpos]) << 26) - ; - out[18 + outpos] = ((in[30 + inpos]) >>> (19 - 13)) - | ((in[31 + inpos]) << 13) - ; - } - - - protected static void fastpackwithoutmask20(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = in[0 + inpos] - | ((in[1 + inpos]) << 20) - ; - out[1 + outpos] = ((in[1 + inpos]) >>> (20 - 8)) - | ((in[2 + inpos]) << 8) - | ((in[3 + inpos]) << 28) - ; - out[2 + outpos] = ((in[3 + inpos]) >>> (20 - 16)) - | ((in[4 + inpos]) << 16) - ; - out[3 + outpos] = ((in[4 + inpos]) >>> (20 - 4)) - | ((in[5 + inpos]) << 4) - | ((in[6 + inpos]) << 24) - ; - out[4 + outpos] = ((in[6 + inpos]) >>> (20 - 12)) - | ((in[7 + inpos]) << 12) - ; - out[5 + outpos] = in[8 + inpos] - | ((in[9 + inpos]) << 20) - ; - out[6 + outpos] = ((in[9 + inpos]) >>> (20 - 8)) - | ((in[10 + inpos]) << 8) - | ((in[11 + inpos]) << 28) - ; - out[7 + outpos] = ((in[11 + inpos]) >>> (20 - 16)) - | ((in[12 + inpos]) << 16) - ; - out[8 + outpos] = ((in[12 + inpos]) >>> (20 - 4)) - | ((in[13 + inpos]) << 4) - | ((in[14 + inpos]) << 24) - ; - out[9 + outpos] = ((in[14 + inpos]) >>> (20 - 12)) - | ((in[15 + inpos]) << 12) - ; - out[10 + outpos] = in[16 + inpos] - | ((in[17 + inpos]) << 20) - ; - out[11 + outpos] = ((in[17 + inpos]) >>> (20 - 8)) - | ((in[18 + inpos]) << 8) - | ((in[19 + inpos]) << 28) - ; - out[12 + outpos] = ((in[19 + inpos]) >>> (20 - 16)) - | ((in[20 + inpos]) << 16) - ; - out[13 + outpos] = ((in[20 + inpos]) >>> (20 - 4)) - | ((in[21 + inpos]) << 4) - | ((in[22 + inpos]) << 24) - ; - out[14 + outpos] = ((in[22 + inpos]) >>> (20 - 12)) - | ((in[23 + inpos]) << 12) - ; - out[15 + outpos] = in[24 + inpos] - | ((in[25 + inpos]) << 20) - ; - out[16 + outpos] = ((in[25 + inpos]) >>> (20 - 8)) - | ((in[26 + inpos]) << 8) - | ((in[27 + inpos]) << 28) - ; - out[17 + outpos] = ((in[27 + inpos]) >>> (20 - 16)) - | ((in[28 + inpos]) << 16) - ; - out[18 + outpos] = ((in[28 + inpos]) >>> (20 - 4)) - | ((in[29 + inpos]) << 4) - | ((in[30 + inpos]) << 24) - ; - out[19 + outpos] = ((in[30 + inpos]) >>> (20 - 12)) - | ((in[31 + inpos]) << 12) - ; - } - - - protected static void fastpackwithoutmask21(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = in[0 + inpos] - | ((in[1 + inpos]) << 21) - ; - out[1 + outpos] = ((in[1 + inpos]) >>> (21 - 10)) - | ((in[2 + inpos]) << 10) - | ((in[3 + inpos]) << 31) - ; - out[2 + outpos] = ((in[3 + inpos]) >>> (21 - 20)) - | ((in[4 + inpos]) << 20) - ; - out[3 + outpos] = ((in[4 + inpos]) >>> (21 - 9)) - | ((in[5 + inpos]) << 9) - | ((in[6 + inpos]) << 30) - ; - out[4 + outpos] = ((in[6 + inpos]) >>> (21 - 19)) - | ((in[7 + inpos]) << 19) - ; - out[5 + outpos] = ((in[7 + inpos]) >>> (21 - 8)) - | ((in[8 + inpos]) << 8) - | ((in[9 + inpos]) << 29) - ; - out[6 + outpos] = ((in[9 + inpos]) >>> (21 - 18)) - | ((in[10 + inpos]) << 18) - ; - out[7 + outpos] = ((in[10 + inpos]) >>> (21 - 7)) - | ((in[11 + inpos]) << 7) - | ((in[12 + inpos]) << 28) - ; - out[8 + outpos] = ((in[12 + inpos]) >>> (21 - 17)) - | ((in[13 + inpos]) << 17) - ; - out[9 + outpos] = ((in[13 + inpos]) >>> (21 - 6)) - | ((in[14 + inpos]) << 6) - | ((in[15 + inpos]) << 27) - ; - out[10 + outpos] = ((in[15 + inpos]) >>> (21 - 16)) - | ((in[16 + inpos]) << 16) - ; - out[11 + outpos] = ((in[16 + inpos]) >>> (21 - 5)) - | ((in[17 + inpos]) << 5) - | ((in[18 + inpos]) << 26) - ; - out[12 + outpos] = ((in[18 + inpos]) >>> (21 - 15)) - | ((in[19 + inpos]) << 15) - ; - out[13 + outpos] = ((in[19 + inpos]) >>> (21 - 4)) - | ((in[20 + inpos]) << 4) - | ((in[21 + inpos]) << 25) - ; - out[14 + outpos] = ((in[21 + inpos]) >>> (21 - 14)) - | ((in[22 + inpos]) << 14) - ; - out[15 + outpos] = ((in[22 + inpos]) >>> (21 - 3)) - | ((in[23 + inpos]) << 3) - | ((in[24 + inpos]) << 24) - ; - out[16 + outpos] = ((in[24 + inpos]) >>> (21 - 13)) - | ((in[25 + inpos]) << 13) - ; - out[17 + outpos] = ((in[25 + inpos]) >>> (21 - 2)) - | ((in[26 + inpos]) << 2) - | ((in[27 + inpos]) << 23) - ; - out[18 + outpos] = ((in[27 + inpos]) >>> (21 - 12)) - | ((in[28 + inpos]) << 12) - ; - out[19 + outpos] = ((in[28 + inpos]) >>> (21 - 1)) - | ((in[29 + inpos]) << 1) - | ((in[30 + inpos]) << 22) - ; - out[20 + outpos] = ((in[30 + inpos]) >>> (21 - 11)) - | ((in[31 + inpos]) << 11) - ; - } - - - protected static void fastpackwithoutmask22(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = in[0 + inpos] - | ((in[1 + inpos]) << 22) - ; - out[1 + outpos] = ((in[1 + inpos]) >>> (22 - 12)) - | ((in[2 + inpos]) << 12) - ; - out[2 + outpos] = ((in[2 + inpos]) >>> (22 - 2)) - | ((in[3 + inpos]) << 2) - | ((in[4 + inpos]) << 24) - ; - out[3 + outpos] = ((in[4 + inpos]) >>> (22 - 14)) - | ((in[5 + inpos]) << 14) - ; - out[4 + outpos] = ((in[5 + inpos]) >>> (22 - 4)) - | ((in[6 + inpos]) << 4) - | ((in[7 + inpos]) << 26) - ; - out[5 + outpos] = ((in[7 + inpos]) >>> (22 - 16)) - | ((in[8 + inpos]) << 16) - ; - out[6 + outpos] = ((in[8 + inpos]) >>> (22 - 6)) - | ((in[9 + inpos]) << 6) - | ((in[10 + inpos]) << 28) - ; - out[7 + outpos] = ((in[10 + inpos]) >>> (22 - 18)) - | ((in[11 + inpos]) << 18) - ; - out[8 + outpos] = ((in[11 + inpos]) >>> (22 - 8)) - | ((in[12 + inpos]) << 8) - | ((in[13 + inpos]) << 30) - ; - out[9 + outpos] = ((in[13 + inpos]) >>> (22 - 20)) - | ((in[14 + inpos]) << 20) - ; - out[10 + outpos] = ((in[14 + inpos]) >>> (22 - 10)) - | ((in[15 + inpos]) << 10) - ; - out[11 + outpos] = in[16 + inpos] - | ((in[17 + inpos]) << 22) - ; - out[12 + outpos] = ((in[17 + inpos]) >>> (22 - 12)) - | ((in[18 + inpos]) << 12) - ; - out[13 + outpos] = ((in[18 + inpos]) >>> (22 - 2)) - | ((in[19 + inpos]) << 2) - | ((in[20 + inpos]) << 24) - ; - out[14 + outpos] = ((in[20 + inpos]) >>> (22 - 14)) - | ((in[21 + inpos]) << 14) - ; - out[15 + outpos] = ((in[21 + inpos]) >>> (22 - 4)) - | ((in[22 + inpos]) << 4) - | ((in[23 + inpos]) << 26) - ; - out[16 + outpos] = ((in[23 + inpos]) >>> (22 - 16)) - | ((in[24 + inpos]) << 16) - ; - out[17 + outpos] = ((in[24 + inpos]) >>> (22 - 6)) - | ((in[25 + inpos]) << 6) - | ((in[26 + inpos]) << 28) - ; - out[18 + outpos] = ((in[26 + inpos]) >>> (22 - 18)) - | ((in[27 + inpos]) << 18) - ; - out[19 + outpos] = ((in[27 + inpos]) >>> (22 - 8)) - | ((in[28 + inpos]) << 8) - | ((in[29 + inpos]) << 30) - ; - out[20 + outpos] = ((in[29 + inpos]) >>> (22 - 20)) - | ((in[30 + inpos]) << 20) - ; - out[21 + outpos] = ((in[30 + inpos]) >>> (22 - 10)) - | ((in[31 + inpos]) << 10) - ; - } - - - protected static void fastpackwithoutmask23(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = in[0 + inpos] - | ((in[1 + inpos]) << 23) - ; - out[1 + outpos] = ((in[1 + inpos]) >>> (23 - 14)) - | ((in[2 + inpos]) << 14) - ; - out[2 + outpos] = ((in[2 + inpos]) >>> (23 - 5)) - | ((in[3 + inpos]) << 5) - | ((in[4 + inpos]) << 28) - ; - out[3 + outpos] = ((in[4 + inpos]) >>> (23 - 19)) - | ((in[5 + inpos]) << 19) - ; - out[4 + outpos] = ((in[5 + inpos]) >>> (23 - 10)) - | ((in[6 + inpos]) << 10) - ; - out[5 + outpos] = ((in[6 + inpos]) >>> (23 - 1)) - | ((in[7 + inpos]) << 1) - | ((in[8 + inpos]) << 24) - ; - out[6 + outpos] = ((in[8 + inpos]) >>> (23 - 15)) - | ((in[9 + inpos]) << 15) - ; - out[7 + outpos] = ((in[9 + inpos]) >>> (23 - 6)) - | ((in[10 + inpos]) << 6) - | ((in[11 + inpos]) << 29) - ; - out[8 + outpos] = ((in[11 + inpos]) >>> (23 - 20)) - | ((in[12 + inpos]) << 20) - ; - out[9 + outpos] = ((in[12 + inpos]) >>> (23 - 11)) - | ((in[13 + inpos]) << 11) - ; - out[10 + outpos] = ((in[13 + inpos]) >>> (23 - 2)) - | ((in[14 + inpos]) << 2) - | ((in[15 + inpos]) << 25) - ; - out[11 + outpos] = ((in[15 + inpos]) >>> (23 - 16)) - | ((in[16 + inpos]) << 16) - ; - out[12 + outpos] = ((in[16 + inpos]) >>> (23 - 7)) - | ((in[17 + inpos]) << 7) - | ((in[18 + inpos]) << 30) - ; - out[13 + outpos] = ((in[18 + inpos]) >>> (23 - 21)) - | ((in[19 + inpos]) << 21) - ; - out[14 + outpos] = ((in[19 + inpos]) >>> (23 - 12)) - | ((in[20 + inpos]) << 12) - ; - out[15 + outpos] = ((in[20 + inpos]) >>> (23 - 3)) - | ((in[21 + inpos]) << 3) - | ((in[22 + inpos]) << 26) - ; - out[16 + outpos] = ((in[22 + inpos]) >>> (23 - 17)) - | ((in[23 + inpos]) << 17) - ; - out[17 + outpos] = ((in[23 + inpos]) >>> (23 - 8)) - | ((in[24 + inpos]) << 8) - | ((in[25 + inpos]) << 31) - ; - out[18 + outpos] = ((in[25 + inpos]) >>> (23 - 22)) - | ((in[26 + inpos]) << 22) - ; - out[19 + outpos] = ((in[26 + inpos]) >>> (23 - 13)) - | ((in[27 + inpos]) << 13) - ; - out[20 + outpos] = ((in[27 + inpos]) >>> (23 - 4)) - | ((in[28 + inpos]) << 4) - | ((in[29 + inpos]) << 27) - ; - out[21 + outpos] = ((in[29 + inpos]) >>> (23 - 18)) - | ((in[30 + inpos]) << 18) - ; - out[22 + outpos] = ((in[30 + inpos]) >>> (23 - 9)) - | ((in[31 + inpos]) << 9) - ; - } - - - protected static void fastpackwithoutmask24(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = in[0 + inpos] - | ((in[1 + inpos]) << 24) - ; - out[1 + outpos] = ((in[1 + inpos]) >>> (24 - 16)) - | ((in[2 + inpos]) << 16) - ; - out[2 + outpos] = ((in[2 + inpos]) >>> (24 - 8)) - | ((in[3 + inpos]) << 8) - ; - out[3 + outpos] = in[4 + inpos] - | ((in[5 + inpos]) << 24) - ; - out[4 + outpos] = ((in[5 + inpos]) >>> (24 - 16)) - | ((in[6 + inpos]) << 16) - ; - out[5 + outpos] = ((in[6 + inpos]) >>> (24 - 8)) - | ((in[7 + inpos]) << 8) - ; - out[6 + outpos] = in[8 + inpos] - | ((in[9 + inpos]) << 24) - ; - out[7 + outpos] = ((in[9 + inpos]) >>> (24 - 16)) - | ((in[10 + inpos]) << 16) - ; - out[8 + outpos] = ((in[10 + inpos]) >>> (24 - 8)) - | ((in[11 + inpos]) << 8) - ; - out[9 + outpos] = in[12 + inpos] - | ((in[13 + inpos]) << 24) - ; - out[10 + outpos] = ((in[13 + inpos]) >>> (24 - 16)) - | ((in[14 + inpos]) << 16) - ; - out[11 + outpos] = ((in[14 + inpos]) >>> (24 - 8)) - | ((in[15 + inpos]) << 8) - ; - out[12 + outpos] = in[16 + inpos] - | ((in[17 + inpos]) << 24) - ; - out[13 + outpos] = ((in[17 + inpos]) >>> (24 - 16)) - | ((in[18 + inpos]) << 16) - ; - out[14 + outpos] = ((in[18 + inpos]) >>> (24 - 8)) - | ((in[19 + inpos]) << 8) - ; - out[15 + outpos] = in[20 + inpos] - | ((in[21 + inpos]) << 24) - ; - out[16 + outpos] = ((in[21 + inpos]) >>> (24 - 16)) - | ((in[22 + inpos]) << 16) - ; - out[17 + outpos] = ((in[22 + inpos]) >>> (24 - 8)) - | ((in[23 + inpos]) << 8) - ; - out[18 + outpos] = in[24 + inpos] - | ((in[25 + inpos]) << 24) - ; - out[19 + outpos] = ((in[25 + inpos]) >>> (24 - 16)) - | ((in[26 + inpos]) << 16) - ; - out[20 + outpos] = ((in[26 + inpos]) >>> (24 - 8)) - | ((in[27 + inpos]) << 8) - ; - out[21 + outpos] = in[28 + inpos] - | ((in[29 + inpos]) << 24) - ; - out[22 + outpos] = ((in[29 + inpos]) >>> (24 - 16)) - | ((in[30 + inpos]) << 16) - ; - out[23 + outpos] = ((in[30 + inpos]) >>> (24 - 8)) - | ((in[31 + inpos]) << 8) - ; - } - - - protected static void fastpackwithoutmask25(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = in[0 + inpos] - | ((in[1 + inpos]) << 25) - ; - out[1 + outpos] = ((in[1 + inpos]) >>> (25 - 18)) - | ((in[2 + inpos]) << 18) - ; - out[2 + outpos] = ((in[2 + inpos]) >>> (25 - 11)) - | ((in[3 + inpos]) << 11) - ; - out[3 + outpos] = ((in[3 + inpos]) >>> (25 - 4)) - | ((in[4 + inpos]) << 4) - | ((in[5 + inpos]) << 29) - ; - out[4 + outpos] = ((in[5 + inpos]) >>> (25 - 22)) - | ((in[6 + inpos]) << 22) - ; - out[5 + outpos] = ((in[6 + inpos]) >>> (25 - 15)) - | ((in[7 + inpos]) << 15) - ; - out[6 + outpos] = ((in[7 + inpos]) >>> (25 - 8)) - | ((in[8 + inpos]) << 8) - ; - out[7 + outpos] = ((in[8 + inpos]) >>> (25 - 1)) - | ((in[9 + inpos]) << 1) - | ((in[10 + inpos]) << 26) - ; - out[8 + outpos] = ((in[10 + inpos]) >>> (25 - 19)) - | ((in[11 + inpos]) << 19) - ; - out[9 + outpos] = ((in[11 + inpos]) >>> (25 - 12)) - | ((in[12 + inpos]) << 12) - ; - out[10 + outpos] = ((in[12 + inpos]) >>> (25 - 5)) - | ((in[13 + inpos]) << 5) - | ((in[14 + inpos]) << 30) - ; - out[11 + outpos] = ((in[14 + inpos]) >>> (25 - 23)) - | ((in[15 + inpos]) << 23) - ; - out[12 + outpos] = ((in[15 + inpos]) >>> (25 - 16)) - | ((in[16 + inpos]) << 16) - ; - out[13 + outpos] = ((in[16 + inpos]) >>> (25 - 9)) - | ((in[17 + inpos]) << 9) - ; - out[14 + outpos] = ((in[17 + inpos]) >>> (25 - 2)) - | ((in[18 + inpos]) << 2) - | ((in[19 + inpos]) << 27) - ; - out[15 + outpos] = ((in[19 + inpos]) >>> (25 - 20)) - | ((in[20 + inpos]) << 20) - ; - out[16 + outpos] = ((in[20 + inpos]) >>> (25 - 13)) - | ((in[21 + inpos]) << 13) - ; - out[17 + outpos] = ((in[21 + inpos]) >>> (25 - 6)) - | ((in[22 + inpos]) << 6) - | ((in[23 + inpos]) << 31) - ; - out[18 + outpos] = ((in[23 + inpos]) >>> (25 - 24)) - | ((in[24 + inpos]) << 24) - ; - out[19 + outpos] = ((in[24 + inpos]) >>> (25 - 17)) - | ((in[25 + inpos]) << 17) - ; - out[20 + outpos] = ((in[25 + inpos]) >>> (25 - 10)) - | ((in[26 + inpos]) << 10) - ; - out[21 + outpos] = ((in[26 + inpos]) >>> (25 - 3)) - | ((in[27 + inpos]) << 3) - | ((in[28 + inpos]) << 28) - ; - out[22 + outpos] = ((in[28 + inpos]) >>> (25 - 21)) - | ((in[29 + inpos]) << 21) - ; - out[23 + outpos] = ((in[29 + inpos]) >>> (25 - 14)) - | ((in[30 + inpos]) << 14) - ; - out[24 + outpos] = ((in[30 + inpos]) >>> (25 - 7)) - | ((in[31 + inpos]) << 7) - ; - } - - - protected static void fastpackwithoutmask26(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = in[0 + inpos] - | ((in[1 + inpos]) << 26) - ; - out[1 + outpos] = ((in[1 + inpos]) >>> (26 - 20)) - | ((in[2 + inpos]) << 20) - ; - out[2 + outpos] = ((in[2 + inpos]) >>> (26 - 14)) - | ((in[3 + inpos]) << 14) - ; - out[3 + outpos] = ((in[3 + inpos]) >>> (26 - 8)) - | ((in[4 + inpos]) << 8) - ; - out[4 + outpos] = ((in[4 + inpos]) >>> (26 - 2)) - | ((in[5 + inpos]) << 2) - | ((in[6 + inpos]) << 28) - ; - out[5 + outpos] = ((in[6 + inpos]) >>> (26 - 22)) - | ((in[7 + inpos]) << 22) - ; - out[6 + outpos] = ((in[7 + inpos]) >>> (26 - 16)) - | ((in[8 + inpos]) << 16) - ; - out[7 + outpos] = ((in[8 + inpos]) >>> (26 - 10)) - | ((in[9 + inpos]) << 10) - ; - out[8 + outpos] = ((in[9 + inpos]) >>> (26 - 4)) - | ((in[10 + inpos]) << 4) - | ((in[11 + inpos]) << 30) - ; - out[9 + outpos] = ((in[11 + inpos]) >>> (26 - 24)) - | ((in[12 + inpos]) << 24) - ; - out[10 + outpos] = ((in[12 + inpos]) >>> (26 - 18)) - | ((in[13 + inpos]) << 18) - ; - out[11 + outpos] = ((in[13 + inpos]) >>> (26 - 12)) - | ((in[14 + inpos]) << 12) - ; - out[12 + outpos] = ((in[14 + inpos]) >>> (26 - 6)) - | ((in[15 + inpos]) << 6) - ; - out[13 + outpos] = in[16 + inpos] - | ((in[17 + inpos]) << 26) - ; - out[14 + outpos] = ((in[17 + inpos]) >>> (26 - 20)) - | ((in[18 + inpos]) << 20) - ; - out[15 + outpos] = ((in[18 + inpos]) >>> (26 - 14)) - | ((in[19 + inpos]) << 14) - ; - out[16 + outpos] = ((in[19 + inpos]) >>> (26 - 8)) - | ((in[20 + inpos]) << 8) - ; - out[17 + outpos] = ((in[20 + inpos]) >>> (26 - 2)) - | ((in[21 + inpos]) << 2) - | ((in[22 + inpos]) << 28) - ; - out[18 + outpos] = ((in[22 + inpos]) >>> (26 - 22)) - | ((in[23 + inpos]) << 22) - ; - out[19 + outpos] = ((in[23 + inpos]) >>> (26 - 16)) - | ((in[24 + inpos]) << 16) - ; - out[20 + outpos] = ((in[24 + inpos]) >>> (26 - 10)) - | ((in[25 + inpos]) << 10) - ; - out[21 + outpos] = ((in[25 + inpos]) >>> (26 - 4)) - | ((in[26 + inpos]) << 4) - | ((in[27 + inpos]) << 30) - ; - out[22 + outpos] = ((in[27 + inpos]) >>> (26 - 24)) - | ((in[28 + inpos]) << 24) - ; - out[23 + outpos] = ((in[28 + inpos]) >>> (26 - 18)) - | ((in[29 + inpos]) << 18) - ; - out[24 + outpos] = ((in[29 + inpos]) >>> (26 - 12)) - | ((in[30 + inpos]) << 12) - ; - out[25 + outpos] = ((in[30 + inpos]) >>> (26 - 6)) - | ((in[31 + inpos]) << 6) - ; - } - - - protected static void fastpackwithoutmask27(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = in[0 + inpos] - | ((in[1 + inpos]) << 27) - ; - out[1 + outpos] = ((in[1 + inpos]) >>> (27 - 22)) - | ((in[2 + inpos]) << 22) - ; - out[2 + outpos] = ((in[2 + inpos]) >>> (27 - 17)) - | ((in[3 + inpos]) << 17) - ; - out[3 + outpos] = ((in[3 + inpos]) >>> (27 - 12)) - | ((in[4 + inpos]) << 12) - ; - out[4 + outpos] = ((in[4 + inpos]) >>> (27 - 7)) - | ((in[5 + inpos]) << 7) - ; - out[5 + outpos] = ((in[5 + inpos]) >>> (27 - 2)) - | ((in[6 + inpos]) << 2) - | ((in[7 + inpos]) << 29) - ; - out[6 + outpos] = ((in[7 + inpos]) >>> (27 - 24)) - | ((in[8 + inpos]) << 24) - ; - out[7 + outpos] = ((in[8 + inpos]) >>> (27 - 19)) - | ((in[9 + inpos]) << 19) - ; - out[8 + outpos] = ((in[9 + inpos]) >>> (27 - 14)) - | ((in[10 + inpos]) << 14) - ; - out[9 + outpos] = ((in[10 + inpos]) >>> (27 - 9)) - | ((in[11 + inpos]) << 9) - ; - out[10 + outpos] = ((in[11 + inpos]) >>> (27 - 4)) - | ((in[12 + inpos]) << 4) - | ((in[13 + inpos]) << 31) - ; - out[11 + outpos] = ((in[13 + inpos]) >>> (27 - 26)) - | ((in[14 + inpos]) << 26) - ; - out[12 + outpos] = ((in[14 + inpos]) >>> (27 - 21)) - | ((in[15 + inpos]) << 21) - ; - out[13 + outpos] = ((in[15 + inpos]) >>> (27 - 16)) - | ((in[16 + inpos]) << 16) - ; - out[14 + outpos] = ((in[16 + inpos]) >>> (27 - 11)) - | ((in[17 + inpos]) << 11) - ; - out[15 + outpos] = ((in[17 + inpos]) >>> (27 - 6)) - | ((in[18 + inpos]) << 6) - ; - out[16 + outpos] = ((in[18 + inpos]) >>> (27 - 1)) - | ((in[19 + inpos]) << 1) - | ((in[20 + inpos]) << 28) - ; - out[17 + outpos] = ((in[20 + inpos]) >>> (27 - 23)) - | ((in[21 + inpos]) << 23) - ; - out[18 + outpos] = ((in[21 + inpos]) >>> (27 - 18)) - | ((in[22 + inpos]) << 18) - ; - out[19 + outpos] = ((in[22 + inpos]) >>> (27 - 13)) - | ((in[23 + inpos]) << 13) - ; - out[20 + outpos] = ((in[23 + inpos]) >>> (27 - 8)) - | ((in[24 + inpos]) << 8) - ; - out[21 + outpos] = ((in[24 + inpos]) >>> (27 - 3)) - | ((in[25 + inpos]) << 3) - | ((in[26 + inpos]) << 30) - ; - out[22 + outpos] = ((in[26 + inpos]) >>> (27 - 25)) - | ((in[27 + inpos]) << 25) - ; - out[23 + outpos] = ((in[27 + inpos]) >>> (27 - 20)) - | ((in[28 + inpos]) << 20) - ; - out[24 + outpos] = ((in[28 + inpos]) >>> (27 - 15)) - | ((in[29 + inpos]) << 15) - ; - out[25 + outpos] = ((in[29 + inpos]) >>> (27 - 10)) - | ((in[30 + inpos]) << 10) - ; - out[26 + outpos] = ((in[30 + inpos]) >>> (27 - 5)) - | ((in[31 + inpos]) << 5) - ; - } - - - protected static void fastpackwithoutmask28(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = in[0 + inpos] - | ((in[1 + inpos]) << 28) - ; - out[1 + outpos] = ((in[1 + inpos]) >>> (28 - 24)) - | ((in[2 + inpos]) << 24) - ; - out[2 + outpos] = ((in[2 + inpos]) >>> (28 - 20)) - | ((in[3 + inpos]) << 20) - ; - out[3 + outpos] = ((in[3 + inpos]) >>> (28 - 16)) - | ((in[4 + inpos]) << 16) - ; - out[4 + outpos] = ((in[4 + inpos]) >>> (28 - 12)) - | ((in[5 + inpos]) << 12) - ; - out[5 + outpos] = ((in[5 + inpos]) >>> (28 - 8)) - | ((in[6 + inpos]) << 8) - ; - out[6 + outpos] = ((in[6 + inpos]) >>> (28 - 4)) - | ((in[7 + inpos]) << 4) - ; - out[7 + outpos] = in[8 + inpos] - | ((in[9 + inpos]) << 28) - ; - out[8 + outpos] = ((in[9 + inpos]) >>> (28 - 24)) - | ((in[10 + inpos]) << 24) - ; - out[9 + outpos] = ((in[10 + inpos]) >>> (28 - 20)) - | ((in[11 + inpos]) << 20) - ; - out[10 + outpos] = ((in[11 + inpos]) >>> (28 - 16)) - | ((in[12 + inpos]) << 16) - ; - out[11 + outpos] = ((in[12 + inpos]) >>> (28 - 12)) - | ((in[13 + inpos]) << 12) - ; - out[12 + outpos] = ((in[13 + inpos]) >>> (28 - 8)) - | ((in[14 + inpos]) << 8) - ; - out[13 + outpos] = ((in[14 + inpos]) >>> (28 - 4)) - | ((in[15 + inpos]) << 4) - ; - out[14 + outpos] = in[16 + inpos] - | ((in[17 + inpos]) << 28) - ; - out[15 + outpos] = ((in[17 + inpos]) >>> (28 - 24)) - | ((in[18 + inpos]) << 24) - ; - out[16 + outpos] = ((in[18 + inpos]) >>> (28 - 20)) - | ((in[19 + inpos]) << 20) - ; - out[17 + outpos] = ((in[19 + inpos]) >>> (28 - 16)) - | ((in[20 + inpos]) << 16) - ; - out[18 + outpos] = ((in[20 + inpos]) >>> (28 - 12)) - | ((in[21 + inpos]) << 12) - ; - out[19 + outpos] = ((in[21 + inpos]) >>> (28 - 8)) - | ((in[22 + inpos]) << 8) - ; - out[20 + outpos] = ((in[22 + inpos]) >>> (28 - 4)) - | ((in[23 + inpos]) << 4) - ; - out[21 + outpos] = in[24 + inpos] - | ((in[25 + inpos]) << 28) - ; - out[22 + outpos] = ((in[25 + inpos]) >>> (28 - 24)) - | ((in[26 + inpos]) << 24) - ; - out[23 + outpos] = ((in[26 + inpos]) >>> (28 - 20)) - | ((in[27 + inpos]) << 20) - ; - out[24 + outpos] = ((in[27 + inpos]) >>> (28 - 16)) - | ((in[28 + inpos]) << 16) - ; - out[25 + outpos] = ((in[28 + inpos]) >>> (28 - 12)) - | ((in[29 + inpos]) << 12) - ; - out[26 + outpos] = ((in[29 + inpos]) >>> (28 - 8)) - | ((in[30 + inpos]) << 8) - ; - out[27 + outpos] = ((in[30 + inpos]) >>> (28 - 4)) - | ((in[31 + inpos]) << 4) - ; - } - - - protected static void fastpackwithoutmask29(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = in[0 + inpos] - | ((in[1 + inpos]) << 29) - ; - out[1 + outpos] = ((in[1 + inpos]) >>> (29 - 26)) - | ((in[2 + inpos]) << 26) - ; - out[2 + outpos] = ((in[2 + inpos]) >>> (29 - 23)) - | ((in[3 + inpos]) << 23) - ; - out[3 + outpos] = ((in[3 + inpos]) >>> (29 - 20)) - | ((in[4 + inpos]) << 20) - ; - out[4 + outpos] = ((in[4 + inpos]) >>> (29 - 17)) - | ((in[5 + inpos]) << 17) - ; - out[5 + outpos] = ((in[5 + inpos]) >>> (29 - 14)) - | ((in[6 + inpos]) << 14) - ; - out[6 + outpos] = ((in[6 + inpos]) >>> (29 - 11)) - | ((in[7 + inpos]) << 11) - ; - out[7 + outpos] = ((in[7 + inpos]) >>> (29 - 8)) - | ((in[8 + inpos]) << 8) - ; - out[8 + outpos] = ((in[8 + inpos]) >>> (29 - 5)) - | ((in[9 + inpos]) << 5) - ; - out[9 + outpos] = ((in[9 + inpos]) >>> (29 - 2)) - | ((in[10 + inpos]) << 2) - | ((in[11 + inpos]) << 31) - ; - out[10 + outpos] = ((in[11 + inpos]) >>> (29 - 28)) - | ((in[12 + inpos]) << 28) - ; - out[11 + outpos] = ((in[12 + inpos]) >>> (29 - 25)) - | ((in[13 + inpos]) << 25) - ; - out[12 + outpos] = ((in[13 + inpos]) >>> (29 - 22)) - | ((in[14 + inpos]) << 22) - ; - out[13 + outpos] = ((in[14 + inpos]) >>> (29 - 19)) - | ((in[15 + inpos]) << 19) - ; - out[14 + outpos] = ((in[15 + inpos]) >>> (29 - 16)) - | ((in[16 + inpos]) << 16) - ; - out[15 + outpos] = ((in[16 + inpos]) >>> (29 - 13)) - | ((in[17 + inpos]) << 13) - ; - out[16 + outpos] = ((in[17 + inpos]) >>> (29 - 10)) - | ((in[18 + inpos]) << 10) - ; - out[17 + outpos] = ((in[18 + inpos]) >>> (29 - 7)) - | ((in[19 + inpos]) << 7) - ; - out[18 + outpos] = ((in[19 + inpos]) >>> (29 - 4)) - | ((in[20 + inpos]) << 4) - ; - out[19 + outpos] = ((in[20 + inpos]) >>> (29 - 1)) - | ((in[21 + inpos]) << 1) - | ((in[22 + inpos]) << 30) - ; - out[20 + outpos] = ((in[22 + inpos]) >>> (29 - 27)) - | ((in[23 + inpos]) << 27) - ; - out[21 + outpos] = ((in[23 + inpos]) >>> (29 - 24)) - | ((in[24 + inpos]) << 24) - ; - out[22 + outpos] = ((in[24 + inpos]) >>> (29 - 21)) - | ((in[25 + inpos]) << 21) - ; - out[23 + outpos] = ((in[25 + inpos]) >>> (29 - 18)) - | ((in[26 + inpos]) << 18) - ; - out[24 + outpos] = ((in[26 + inpos]) >>> (29 - 15)) - | ((in[27 + inpos]) << 15) - ; - out[25 + outpos] = ((in[27 + inpos]) >>> (29 - 12)) - | ((in[28 + inpos]) << 12) - ; - out[26 + outpos] = ((in[28 + inpos]) >>> (29 - 9)) - | ((in[29 + inpos]) << 9) - ; - out[27 + outpos] = ((in[29 + inpos]) >>> (29 - 6)) - | ((in[30 + inpos]) << 6) - ; - out[28 + outpos] = ((in[30 + inpos]) >>> (29 - 3)) - | ((in[31 + inpos]) << 3) - ; - } - - - protected static void fastpackwithoutmask30(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = in[0 + inpos] - | ((in[1 + inpos]) << 30) - ; - out[1 + outpos] = ((in[1 + inpos]) >>> (30 - 28)) - | ((in[2 + inpos]) << 28) - ; - out[2 + outpos] = ((in[2 + inpos]) >>> (30 - 26)) - | ((in[3 + inpos]) << 26) - ; - out[3 + outpos] = ((in[3 + inpos]) >>> (30 - 24)) - | ((in[4 + inpos]) << 24) - ; - out[4 + outpos] = ((in[4 + inpos]) >>> (30 - 22)) - | ((in[5 + inpos]) << 22) - ; - out[5 + outpos] = ((in[5 + inpos]) >>> (30 - 20)) - | ((in[6 + inpos]) << 20) - ; - out[6 + outpos] = ((in[6 + inpos]) >>> (30 - 18)) - | ((in[7 + inpos]) << 18) - ; - out[7 + outpos] = ((in[7 + inpos]) >>> (30 - 16)) - | ((in[8 + inpos]) << 16) - ; - out[8 + outpos] = ((in[8 + inpos]) >>> (30 - 14)) - | ((in[9 + inpos]) << 14) - ; - out[9 + outpos] = ((in[9 + inpos]) >>> (30 - 12)) - | ((in[10 + inpos]) << 12) - ; - out[10 + outpos] = ((in[10 + inpos]) >>> (30 - 10)) - | ((in[11 + inpos]) << 10) - ; - out[11 + outpos] = ((in[11 + inpos]) >>> (30 - 8)) - | ((in[12 + inpos]) << 8) - ; - out[12 + outpos] = ((in[12 + inpos]) >>> (30 - 6)) - | ((in[13 + inpos]) << 6) - ; - out[13 + outpos] = ((in[13 + inpos]) >>> (30 - 4)) - | ((in[14 + inpos]) << 4) - ; - out[14 + outpos] = ((in[14 + inpos]) >>> (30 - 2)) - | ((in[15 + inpos]) << 2) - ; - out[15 + outpos] = in[16 + inpos] - | ((in[17 + inpos]) << 30) - ; - out[16 + outpos] = ((in[17 + inpos]) >>> (30 - 28)) - | ((in[18 + inpos]) << 28) - ; - out[17 + outpos] = ((in[18 + inpos]) >>> (30 - 26)) - | ((in[19 + inpos]) << 26) - ; - out[18 + outpos] = ((in[19 + inpos]) >>> (30 - 24)) - | ((in[20 + inpos]) << 24) - ; - out[19 + outpos] = ((in[20 + inpos]) >>> (30 - 22)) - | ((in[21 + inpos]) << 22) - ; - out[20 + outpos] = ((in[21 + inpos]) >>> (30 - 20)) - | ((in[22 + inpos]) << 20) - ; - out[21 + outpos] = ((in[22 + inpos]) >>> (30 - 18)) - | ((in[23 + inpos]) << 18) - ; - out[22 + outpos] = ((in[23 + inpos]) >>> (30 - 16)) - | ((in[24 + inpos]) << 16) - ; - out[23 + outpos] = ((in[24 + inpos]) >>> (30 - 14)) - | ((in[25 + inpos]) << 14) - ; - out[24 + outpos] = ((in[25 + inpos]) >>> (30 - 12)) - | ((in[26 + inpos]) << 12) - ; - out[25 + outpos] = ((in[26 + inpos]) >>> (30 - 10)) - | ((in[27 + inpos]) << 10) - ; - out[26 + outpos] = ((in[27 + inpos]) >>> (30 - 8)) - | ((in[28 + inpos]) << 8) - ; - out[27 + outpos] = ((in[28 + inpos]) >>> (30 - 6)) - | ((in[29 + inpos]) << 6) - ; - out[28 + outpos] = ((in[29 + inpos]) >>> (30 - 4)) - | ((in[30 + inpos]) << 4) - ; - out[29 + outpos] = ((in[30 + inpos]) >>> (30 - 2)) - | ((in[31 + inpos]) << 2) - ; - } - - - protected static void fastpackwithoutmask31(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = in[0 + inpos] - | ((in[1 + inpos]) << 31) - ; - out[1 + outpos] = ((in[1 + inpos]) >>> (31 - 30)) - | ((in[2 + inpos]) << 30) - ; - out[2 + outpos] = ((in[2 + inpos]) >>> (31 - 29)) - | ((in[3 + inpos]) << 29) - ; - out[3 + outpos] = ((in[3 + inpos]) >>> (31 - 28)) - | ((in[4 + inpos]) << 28) - ; - out[4 + outpos] = ((in[4 + inpos]) >>> (31 - 27)) - | ((in[5 + inpos]) << 27) - ; - out[5 + outpos] = ((in[5 + inpos]) >>> (31 - 26)) - | ((in[6 + inpos]) << 26) - ; - out[6 + outpos] = ((in[6 + inpos]) >>> (31 - 25)) - | ((in[7 + inpos]) << 25) - ; - out[7 + outpos] = ((in[7 + inpos]) >>> (31 - 24)) - | ((in[8 + inpos]) << 24) - ; - out[8 + outpos] = ((in[8 + inpos]) >>> (31 - 23)) - | ((in[9 + inpos]) << 23) - ; - out[9 + outpos] = ((in[9 + inpos]) >>> (31 - 22)) - | ((in[10 + inpos]) << 22) - ; - out[10 + outpos] = ((in[10 + inpos]) >>> (31 - 21)) - | ((in[11 + inpos]) << 21) - ; - out[11 + outpos] = ((in[11 + inpos]) >>> (31 - 20)) - | ((in[12 + inpos]) << 20) - ; - out[12 + outpos] = ((in[12 + inpos]) >>> (31 - 19)) - | ((in[13 + inpos]) << 19) - ; - out[13 + outpos] = ((in[13 + inpos]) >>> (31 - 18)) - | ((in[14 + inpos]) << 18) - ; - out[14 + outpos] = ((in[14 + inpos]) >>> (31 - 17)) - | ((in[15 + inpos]) << 17) - ; - out[15 + outpos] = ((in[15 + inpos]) >>> (31 - 16)) - | ((in[16 + inpos]) << 16) - ; - out[16 + outpos] = ((in[16 + inpos]) >>> (31 - 15)) - | ((in[17 + inpos]) << 15) - ; - out[17 + outpos] = ((in[17 + inpos]) >>> (31 - 14)) - | ((in[18 + inpos]) << 14) - ; - out[18 + outpos] = ((in[18 + inpos]) >>> (31 - 13)) - | ((in[19 + inpos]) << 13) - ; - out[19 + outpos] = ((in[19 + inpos]) >>> (31 - 12)) - | ((in[20 + inpos]) << 12) - ; - out[20 + outpos] = ((in[20 + inpos]) >>> (31 - 11)) - | ((in[21 + inpos]) << 11) - ; - out[21 + outpos] = ((in[21 + inpos]) >>> (31 - 10)) - | ((in[22 + inpos]) << 10) - ; - out[22 + outpos] = ((in[22 + inpos]) >>> (31 - 9)) - | ((in[23 + inpos]) << 9) - ; - out[23 + outpos] = ((in[23 + inpos]) >>> (31 - 8)) - | ((in[24 + inpos]) << 8) - ; - out[24 + outpos] = ((in[24 + inpos]) >>> (31 - 7)) - | ((in[25 + inpos]) << 7) - ; - out[25 + outpos] = ((in[25 + inpos]) >>> (31 - 6)) - | ((in[26 + inpos]) << 6) - ; - out[26 + outpos] = ((in[26 + inpos]) >>> (31 - 5)) - | ((in[27 + inpos]) << 5) - ; - out[27 + outpos] = ((in[27 + inpos]) >>> (31 - 4)) - | ((in[28 + inpos]) << 4) - ; - out[28 + outpos] = ((in[28 + inpos]) >>> (31 - 3)) - | ((in[29 + inpos]) << 3) - ; - out[29 + outpos] = ((in[29 + inpos]) >>> (31 - 2)) - | ((in[30 + inpos]) << 2) - ; - out[30 + outpos] = ((in[30 + inpos]) >>> (31 - 1)) - | ((in[31 + inpos]) << 1) - ; - } - - - protected static void fastpack1(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (in[0 + inpos] & 1) - | ((in[1 + inpos] & 1) << 1) - | ((in[2 + inpos] & 1) << 2) - | ((in[3 + inpos] & 1) << 3) - | ((in[4 + inpos] & 1) << 4) - | ((in[5 + inpos] & 1) << 5) - | ((in[6 + inpos] & 1) << 6) - | ((in[7 + inpos] & 1) << 7) - | ((in[8 + inpos] & 1) << 8) - | ((in[9 + inpos] & 1) << 9) - | ((in[10 + inpos] & 1) << 10) - | ((in[11 + inpos] & 1) << 11) - | ((in[12 + inpos] & 1) << 12) - | ((in[13 + inpos] & 1) << 13) - | ((in[14 + inpos] & 1) << 14) - | ((in[15 + inpos] & 1) << 15) - | ((in[16 + inpos] & 1) << 16) - | ((in[17 + inpos] & 1) << 17) - | ((in[18 + inpos] & 1) << 18) - | ((in[19 + inpos] & 1) << 19) - | ((in[20 + inpos] & 1) << 20) - | ((in[21 + inpos] & 1) << 21) - | ((in[22 + inpos] & 1) << 22) - | ((in[23 + inpos] & 1) << 23) - | ((in[24 + inpos] & 1) << 24) - | ((in[25 + inpos] & 1) << 25) - | ((in[26 + inpos] & 1) << 26) - | ((in[27 + inpos] & 1) << 27) - | ((in[28 + inpos] & 1) << 28) - | ((in[29 + inpos] & 1) << 29) - | ((in[30 + inpos] & 1) << 30) - | ((in[31 + inpos]) << 31) - ; - } - - - protected static void fastpack2(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (in[0 + inpos] & 3) - | ((in[1 + inpos] & 3) << 2) - | ((in[2 + inpos] & 3) << 4) - | ((in[3 + inpos] & 3) << 6) - | ((in[4 + inpos] & 3) << 8) - | ((in[5 + inpos] & 3) << 10) - | ((in[6 + inpos] & 3) << 12) - | ((in[7 + inpos] & 3) << 14) - | ((in[8 + inpos] & 3) << 16) - | ((in[9 + inpos] & 3) << 18) - | ((in[10 + inpos] & 3) << 20) - | ((in[11 + inpos] & 3) << 22) - | ((in[12 + inpos] & 3) << 24) - | ((in[13 + inpos] & 3) << 26) - | ((in[14 + inpos] & 3) << 28) - | ((in[15 + inpos]) << 30) - ; - out[1 + outpos] = (in[16 + inpos] & 3) - | ((in[17 + inpos] & 3) << 2) - | ((in[18 + inpos] & 3) << 4) - | ((in[19 + inpos] & 3) << 6) - | ((in[20 + inpos] & 3) << 8) - | ((in[21 + inpos] & 3) << 10) - | ((in[22 + inpos] & 3) << 12) - | ((in[23 + inpos] & 3) << 14) - | ((in[24 + inpos] & 3) << 16) - | ((in[25 + inpos] & 3) << 18) - | ((in[26 + inpos] & 3) << 20) - | ((in[27 + inpos] & 3) << 22) - | ((in[28 + inpos] & 3) << 24) - | ((in[29 + inpos] & 3) << 26) - | ((in[30 + inpos] & 3) << 28) - | ((in[31 + inpos]) << 30) - ; - } - - - protected static void fastpack3(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (in[0 + inpos] & 7) - | ((in[1 + inpos] & 7) << 3) - | ((in[2 + inpos] & 7) << 6) - | ((in[3 + inpos] & 7) << 9) - | ((in[4 + inpos] & 7) << 12) - | ((in[5 + inpos] & 7) << 15) - | ((in[6 + inpos] & 7) << 18) - | ((in[7 + inpos] & 7) << 21) - | ((in[8 + inpos] & 7) << 24) - | ((in[9 + inpos] & 7) << 27) - | ((in[10 + inpos]) << 30) - ; - out[1 + outpos] = ((in[10 + inpos] & 7) >>> (3 - 1)) - | ((in[11 + inpos] & 7) << 1) - | ((in[12 + inpos] & 7) << 4) - | ((in[13 + inpos] & 7) << 7) - | ((in[14 + inpos] & 7) << 10) - | ((in[15 + inpos] & 7) << 13) - | ((in[16 + inpos] & 7) << 16) - | ((in[17 + inpos] & 7) << 19) - | ((in[18 + inpos] & 7) << 22) - | ((in[19 + inpos] & 7) << 25) - | ((in[20 + inpos] & 7) << 28) - | ((in[21 + inpos]) << 31) - ; - out[2 + outpos] = ((in[21 + inpos] & 7) >>> (3 - 2)) - | ((in[22 + inpos] & 7) << 2) - | ((in[23 + inpos] & 7) << 5) - | ((in[24 + inpos] & 7) << 8) - | ((in[25 + inpos] & 7) << 11) - | ((in[26 + inpos] & 7) << 14) - | ((in[27 + inpos] & 7) << 17) - | ((in[28 + inpos] & 7) << 20) - | ((in[29 + inpos] & 7) << 23) - | ((in[30 + inpos] & 7) << 26) - | ((in[31 + inpos]) << 29) - ; - } - - - protected static void fastpack4(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (in[0 + inpos] & 15) - | ((in[1 + inpos] & 15) << 4) - | ((in[2 + inpos] & 15) << 8) - | ((in[3 + inpos] & 15) << 12) - | ((in[4 + inpos] & 15) << 16) - | ((in[5 + inpos] & 15) << 20) - | ((in[6 + inpos] & 15) << 24) - | ((in[7 + inpos]) << 28) - ; - out[1 + outpos] = (in[8 + inpos] & 15) - | ((in[9 + inpos] & 15) << 4) - | ((in[10 + inpos] & 15) << 8) - | ((in[11 + inpos] & 15) << 12) - | ((in[12 + inpos] & 15) << 16) - | ((in[13 + inpos] & 15) << 20) - | ((in[14 + inpos] & 15) << 24) - | ((in[15 + inpos]) << 28) - ; - out[2 + outpos] = (in[16 + inpos] & 15) - | ((in[17 + inpos] & 15) << 4) - | ((in[18 + inpos] & 15) << 8) - | ((in[19 + inpos] & 15) << 12) - | ((in[20 + inpos] & 15) << 16) - | ((in[21 + inpos] & 15) << 20) - | ((in[22 + inpos] & 15) << 24) - | ((in[23 + inpos]) << 28) - ; - out[3 + outpos] = (in[24 + inpos] & 15) - | ((in[25 + inpos] & 15) << 4) - | ((in[26 + inpos] & 15) << 8) - | ((in[27 + inpos] & 15) << 12) - | ((in[28 + inpos] & 15) << 16) - | ((in[29 + inpos] & 15) << 20) - | ((in[30 + inpos] & 15) << 24) - | ((in[31 + inpos]) << 28) - ; - } - - - protected static void fastpack5(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (in[0 + inpos] & 31) - | ((in[1 + inpos] & 31) << 5) - | ((in[2 + inpos] & 31) << 10) - | ((in[3 + inpos] & 31) << 15) - | ((in[4 + inpos] & 31) << 20) - | ((in[5 + inpos] & 31) << 25) - | ((in[6 + inpos]) << 30) - ; - out[1 + outpos] = ((in[6 + inpos] & 31) >>> (5 - 3)) - | ((in[7 + inpos] & 31) << 3) - | ((in[8 + inpos] & 31) << 8) - | ((in[9 + inpos] & 31) << 13) - | ((in[10 + inpos] & 31) << 18) - | ((in[11 + inpos] & 31) << 23) - | ((in[12 + inpos]) << 28) - ; - out[2 + outpos] = ((in[12 + inpos] & 31) >>> (5 - 1)) - | ((in[13 + inpos] & 31) << 1) - | ((in[14 + inpos] & 31) << 6) - | ((in[15 + inpos] & 31) << 11) - | ((in[16 + inpos] & 31) << 16) - | ((in[17 + inpos] & 31) << 21) - | ((in[18 + inpos] & 31) << 26) - | ((in[19 + inpos]) << 31) - ; - out[3 + outpos] = ((in[19 + inpos] & 31) >>> (5 - 4)) - | ((in[20 + inpos] & 31) << 4) - | ((in[21 + inpos] & 31) << 9) - | ((in[22 + inpos] & 31) << 14) - | ((in[23 + inpos] & 31) << 19) - | ((in[24 + inpos] & 31) << 24) - | ((in[25 + inpos]) << 29) - ; - out[4 + outpos] = ((in[25 + inpos] & 31) >>> (5 - 2)) - | ((in[26 + inpos] & 31) << 2) - | ((in[27 + inpos] & 31) << 7) - | ((in[28 + inpos] & 31) << 12) - | ((in[29 + inpos] & 31) << 17) - | ((in[30 + inpos] & 31) << 22) - | ((in[31 + inpos]) << 27) - ; - } - - - protected static void fastpack6(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (in[0 + inpos] & 63) - | ((in[1 + inpos] & 63) << 6) - | ((in[2 + inpos] & 63) << 12) - | ((in[3 + inpos] & 63) << 18) - | ((in[4 + inpos] & 63) << 24) - | ((in[5 + inpos]) << 30) - ; - out[1 + outpos] = ((in[5 + inpos] & 63) >>> (6 - 4)) - | ((in[6 + inpos] & 63) << 4) - | ((in[7 + inpos] & 63) << 10) - | ((in[8 + inpos] & 63) << 16) - | ((in[9 + inpos] & 63) << 22) - | ((in[10 + inpos]) << 28) - ; - out[2 + outpos] = ((in[10 + inpos] & 63) >>> (6 - 2)) - | ((in[11 + inpos] & 63) << 2) - | ((in[12 + inpos] & 63) << 8) - | ((in[13 + inpos] & 63) << 14) - | ((in[14 + inpos] & 63) << 20) - | ((in[15 + inpos]) << 26) - ; - out[3 + outpos] = (in[16 + inpos] & 63) - | ((in[17 + inpos] & 63) << 6) - | ((in[18 + inpos] & 63) << 12) - | ((in[19 + inpos] & 63) << 18) - | ((in[20 + inpos] & 63) << 24) - | ((in[21 + inpos]) << 30) - ; - out[4 + outpos] = ((in[21 + inpos] & 63) >>> (6 - 4)) - | ((in[22 + inpos] & 63) << 4) - | ((in[23 + inpos] & 63) << 10) - | ((in[24 + inpos] & 63) << 16) - | ((in[25 + inpos] & 63) << 22) - | ((in[26 + inpos]) << 28) - ; - out[5 + outpos] = ((in[26 + inpos] & 63) >>> (6 - 2)) - | ((in[27 + inpos] & 63) << 2) - | ((in[28 + inpos] & 63) << 8) - | ((in[29 + inpos] & 63) << 14) - | ((in[30 + inpos] & 63) << 20) - | ((in[31 + inpos]) << 26) - ; - } - - - protected static void fastpack7(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (in[0 + inpos] & 127) - | ((in[1 + inpos] & 127) << 7) - | ((in[2 + inpos] & 127) << 14) - | ((in[3 + inpos] & 127) << 21) - | ((in[4 + inpos]) << 28) - ; - out[1 + outpos] = ((in[4 + inpos] & 127) >>> (7 - 3)) - | ((in[5 + inpos] & 127) << 3) - | ((in[6 + inpos] & 127) << 10) - | ((in[7 + inpos] & 127) << 17) - | ((in[8 + inpos] & 127) << 24) - | ((in[9 + inpos]) << 31) - ; - out[2 + outpos] = ((in[9 + inpos] & 127) >>> (7 - 6)) - | ((in[10 + inpos] & 127) << 6) - | ((in[11 + inpos] & 127) << 13) - | ((in[12 + inpos] & 127) << 20) - | ((in[13 + inpos]) << 27) - ; - out[3 + outpos] = ((in[13 + inpos] & 127) >>> (7 - 2)) - | ((in[14 + inpos] & 127) << 2) - | ((in[15 + inpos] & 127) << 9) - | ((in[16 + inpos] & 127) << 16) - | ((in[17 + inpos] & 127) << 23) - | ((in[18 + inpos]) << 30) - ; - out[4 + outpos] = ((in[18 + inpos] & 127) >>> (7 - 5)) - | ((in[19 + inpos] & 127) << 5) - | ((in[20 + inpos] & 127) << 12) - | ((in[21 + inpos] & 127) << 19) - | ((in[22 + inpos]) << 26) - ; - out[5 + outpos] = ((in[22 + inpos] & 127) >>> (7 - 1)) - | ((in[23 + inpos] & 127) << 1) - | ((in[24 + inpos] & 127) << 8) - | ((in[25 + inpos] & 127) << 15) - | ((in[26 + inpos] & 127) << 22) - | ((in[27 + inpos]) << 29) - ; - out[6 + outpos] = ((in[27 + inpos] & 127) >>> (7 - 4)) - | ((in[28 + inpos] & 127) << 4) - | ((in[29 + inpos] & 127) << 11) - | ((in[30 + inpos] & 127) << 18) - | ((in[31 + inpos]) << 25) - ; - } - - - protected static void fastpack8(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (in[0 + inpos] & 255) - | ((in[1 + inpos] & 255) << 8) - | ((in[2 + inpos] & 255) << 16) - | ((in[3 + inpos]) << 24) - ; - out[1 + outpos] = (in[4 + inpos] & 255) - | ((in[5 + inpos] & 255) << 8) - | ((in[6 + inpos] & 255) << 16) - | ((in[7 + inpos]) << 24) - ; - out[2 + outpos] = (in[8 + inpos] & 255) - | ((in[9 + inpos] & 255) << 8) - | ((in[10 + inpos] & 255) << 16) - | ((in[11 + inpos]) << 24) - ; - out[3 + outpos] = (in[12 + inpos] & 255) - | ((in[13 + inpos] & 255) << 8) - | ((in[14 + inpos] & 255) << 16) - | ((in[15 + inpos]) << 24) - ; - out[4 + outpos] = (in[16 + inpos] & 255) - | ((in[17 + inpos] & 255) << 8) - | ((in[18 + inpos] & 255) << 16) - | ((in[19 + inpos]) << 24) - ; - out[5 + outpos] = (in[20 + inpos] & 255) - | ((in[21 + inpos] & 255) << 8) - | ((in[22 + inpos] & 255) << 16) - | ((in[23 + inpos]) << 24) - ; - out[6 + outpos] = (in[24 + inpos] & 255) - | ((in[25 + inpos] & 255) << 8) - | ((in[26 + inpos] & 255) << 16) - | ((in[27 + inpos]) << 24) - ; - out[7 + outpos] = (in[28 + inpos] & 255) - | ((in[29 + inpos] & 255) << 8) - | ((in[30 + inpos] & 255) << 16) - | ((in[31 + inpos]) << 24) - ; - } - - - protected static void fastpack9(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (in[0 + inpos] & 511) - | ((in[1 + inpos] & 511) << 9) - | ((in[2 + inpos] & 511) << 18) - | ((in[3 + inpos]) << 27) - ; - out[1 + outpos] = ((in[3 + inpos] & 511) >>> (9 - 4)) - | ((in[4 + inpos] & 511) << 4) - | ((in[5 + inpos] & 511) << 13) - | ((in[6 + inpos] & 511) << 22) - | ((in[7 + inpos]) << 31) - ; - out[2 + outpos] = ((in[7 + inpos] & 511) >>> (9 - 8)) - | ((in[8 + inpos] & 511) << 8) - | ((in[9 + inpos] & 511) << 17) - | ((in[10 + inpos]) << 26) - ; - out[3 + outpos] = ((in[10 + inpos] & 511) >>> (9 - 3)) - | ((in[11 + inpos] & 511) << 3) - | ((in[12 + inpos] & 511) << 12) - | ((in[13 + inpos] & 511) << 21) - | ((in[14 + inpos]) << 30) - ; - out[4 + outpos] = ((in[14 + inpos] & 511) >>> (9 - 7)) - | ((in[15 + inpos] & 511) << 7) - | ((in[16 + inpos] & 511) << 16) - | ((in[17 + inpos]) << 25) - ; - out[5 + outpos] = ((in[17 + inpos] & 511) >>> (9 - 2)) - | ((in[18 + inpos] & 511) << 2) - | ((in[19 + inpos] & 511) << 11) - | ((in[20 + inpos] & 511) << 20) - | ((in[21 + inpos]) << 29) - ; - out[6 + outpos] = ((in[21 + inpos] & 511) >>> (9 - 6)) - | ((in[22 + inpos] & 511) << 6) - | ((in[23 + inpos] & 511) << 15) - | ((in[24 + inpos]) << 24) - ; - out[7 + outpos] = ((in[24 + inpos] & 511) >>> (9 - 1)) - | ((in[25 + inpos] & 511) << 1) - | ((in[26 + inpos] & 511) << 10) - | ((in[27 + inpos] & 511) << 19) - | ((in[28 + inpos]) << 28) - ; - out[8 + outpos] = ((in[28 + inpos] & 511) >>> (9 - 5)) - | ((in[29 + inpos] & 511) << 5) - | ((in[30 + inpos] & 511) << 14) - | ((in[31 + inpos]) << 23) - ; - } - - - protected static void fastpack10(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (in[0 + inpos] & 1023) - | ((in[1 + inpos] & 1023) << 10) - | ((in[2 + inpos] & 1023) << 20) - | ((in[3 + inpos]) << 30) - ; - out[1 + outpos] = ((in[3 + inpos] & 1023) >>> (10 - 8)) - | ((in[4 + inpos] & 1023) << 8) - | ((in[5 + inpos] & 1023) << 18) - | ((in[6 + inpos]) << 28) - ; - out[2 + outpos] = ((in[6 + inpos] & 1023) >>> (10 - 6)) - | ((in[7 + inpos] & 1023) << 6) - | ((in[8 + inpos] & 1023) << 16) - | ((in[9 + inpos]) << 26) - ; - out[3 + outpos] = ((in[9 + inpos] & 1023) >>> (10 - 4)) - | ((in[10 + inpos] & 1023) << 4) - | ((in[11 + inpos] & 1023) << 14) - | ((in[12 + inpos]) << 24) - ; - out[4 + outpos] = ((in[12 + inpos] & 1023) >>> (10 - 2)) - | ((in[13 + inpos] & 1023) << 2) - | ((in[14 + inpos] & 1023) << 12) - | ((in[15 + inpos]) << 22) - ; - out[5 + outpos] = (in[16 + inpos] & 1023) - | ((in[17 + inpos] & 1023) << 10) - | ((in[18 + inpos] & 1023) << 20) - | ((in[19 + inpos]) << 30) - ; - out[6 + outpos] = ((in[19 + inpos] & 1023) >>> (10 - 8)) - | ((in[20 + inpos] & 1023) << 8) - | ((in[21 + inpos] & 1023) << 18) - | ((in[22 + inpos]) << 28) - ; - out[7 + outpos] = ((in[22 + inpos] & 1023) >>> (10 - 6)) - | ((in[23 + inpos] & 1023) << 6) - | ((in[24 + inpos] & 1023) << 16) - | ((in[25 + inpos]) << 26) - ; - out[8 + outpos] = ((in[25 + inpos] & 1023) >>> (10 - 4)) - | ((in[26 + inpos] & 1023) << 4) - | ((in[27 + inpos] & 1023) << 14) - | ((in[28 + inpos]) << 24) - ; - out[9 + outpos] = ((in[28 + inpos] & 1023) >>> (10 - 2)) - | ((in[29 + inpos] & 1023) << 2) - | ((in[30 + inpos] & 1023) << 12) - | ((in[31 + inpos]) << 22) - ; - } - - - protected static void fastpack11(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (in[0 + inpos] & 2047) - | ((in[1 + inpos] & 2047) << 11) - | ((in[2 + inpos]) << 22) - ; - out[1 + outpos] = ((in[2 + inpos] & 2047) >>> (11 - 1)) - | ((in[3 + inpos] & 2047) << 1) - | ((in[4 + inpos] & 2047) << 12) - | ((in[5 + inpos]) << 23) - ; - out[2 + outpos] = ((in[5 + inpos] & 2047) >>> (11 - 2)) - | ((in[6 + inpos] & 2047) << 2) - | ((in[7 + inpos] & 2047) << 13) - | ((in[8 + inpos]) << 24) - ; - out[3 + outpos] = ((in[8 + inpos] & 2047) >>> (11 - 3)) - | ((in[9 + inpos] & 2047) << 3) - | ((in[10 + inpos] & 2047) << 14) - | ((in[11 + inpos]) << 25) - ; - out[4 + outpos] = ((in[11 + inpos] & 2047) >>> (11 - 4)) - | ((in[12 + inpos] & 2047) << 4) - | ((in[13 + inpos] & 2047) << 15) - | ((in[14 + inpos]) << 26) - ; - out[5 + outpos] = ((in[14 + inpos] & 2047) >>> (11 - 5)) - | ((in[15 + inpos] & 2047) << 5) - | ((in[16 + inpos] & 2047) << 16) - | ((in[17 + inpos]) << 27) - ; - out[6 + outpos] = ((in[17 + inpos] & 2047) >>> (11 - 6)) - | ((in[18 + inpos] & 2047) << 6) - | ((in[19 + inpos] & 2047) << 17) - | ((in[20 + inpos]) << 28) - ; - out[7 + outpos] = ((in[20 + inpos] & 2047) >>> (11 - 7)) - | ((in[21 + inpos] & 2047) << 7) - | ((in[22 + inpos] & 2047) << 18) - | ((in[23 + inpos]) << 29) - ; - out[8 + outpos] = ((in[23 + inpos] & 2047) >>> (11 - 8)) - | ((in[24 + inpos] & 2047) << 8) - | ((in[25 + inpos] & 2047) << 19) - | ((in[26 + inpos]) << 30) - ; - out[9 + outpos] = ((in[26 + inpos] & 2047) >>> (11 - 9)) - | ((in[27 + inpos] & 2047) << 9) - | ((in[28 + inpos] & 2047) << 20) - | ((in[29 + inpos]) << 31) - ; - out[10 + outpos] = ((in[29 + inpos] & 2047) >>> (11 - 10)) - | ((in[30 + inpos] & 2047) << 10) - | ((in[31 + inpos]) << 21) - ; - } - - - protected static void fastpack12(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (in[0 + inpos] & 4095) - | ((in[1 + inpos] & 4095) << 12) - | ((in[2 + inpos]) << 24) - ; - out[1 + outpos] = ((in[2 + inpos] & 4095) >>> (12 - 4)) - | ((in[3 + inpos] & 4095) << 4) - | ((in[4 + inpos] & 4095) << 16) - | ((in[5 + inpos]) << 28) - ; - out[2 + outpos] = ((in[5 + inpos] & 4095) >>> (12 - 8)) - | ((in[6 + inpos] & 4095) << 8) - | ((in[7 + inpos]) << 20) - ; - out[3 + outpos] = (in[8 + inpos] & 4095) - | ((in[9 + inpos] & 4095) << 12) - | ((in[10 + inpos]) << 24) - ; - out[4 + outpos] = ((in[10 + inpos] & 4095) >>> (12 - 4)) - | ((in[11 + inpos] & 4095) << 4) - | ((in[12 + inpos] & 4095) << 16) - | ((in[13 + inpos]) << 28) - ; - out[5 + outpos] = ((in[13 + inpos] & 4095) >>> (12 - 8)) - | ((in[14 + inpos] & 4095) << 8) - | ((in[15 + inpos]) << 20) - ; - out[6 + outpos] = (in[16 + inpos] & 4095) - | ((in[17 + inpos] & 4095) << 12) - | ((in[18 + inpos]) << 24) - ; - out[7 + outpos] = ((in[18 + inpos] & 4095) >>> (12 - 4)) - | ((in[19 + inpos] & 4095) << 4) - | ((in[20 + inpos] & 4095) << 16) - | ((in[21 + inpos]) << 28) - ; - out[8 + outpos] = ((in[21 + inpos] & 4095) >>> (12 - 8)) - | ((in[22 + inpos] & 4095) << 8) - | ((in[23 + inpos]) << 20) - ; - out[9 + outpos] = (in[24 + inpos] & 4095) - | ((in[25 + inpos] & 4095) << 12) - | ((in[26 + inpos]) << 24) - ; - out[10 + outpos] = ((in[26 + inpos] & 4095) >>> (12 - 4)) - | ((in[27 + inpos] & 4095) << 4) - | ((in[28 + inpos] & 4095) << 16) - | ((in[29 + inpos]) << 28) - ; - out[11 + outpos] = ((in[29 + inpos] & 4095) >>> (12 - 8)) - | ((in[30 + inpos] & 4095) << 8) - | ((in[31 + inpos]) << 20) - ; - } - - - protected static void fastpack13(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (in[0 + inpos] & 8191) - | ((in[1 + inpos] & 8191) << 13) - | ((in[2 + inpos]) << 26) - ; - out[1 + outpos] = ((in[2 + inpos] & 8191) >>> (13 - 7)) - | ((in[3 + inpos] & 8191) << 7) - | ((in[4 + inpos]) << 20) - ; - out[2 + outpos] = ((in[4 + inpos] & 8191) >>> (13 - 1)) - | ((in[5 + inpos] & 8191) << 1) - | ((in[6 + inpos] & 8191) << 14) - | ((in[7 + inpos]) << 27) - ; - out[3 + outpos] = ((in[7 + inpos] & 8191) >>> (13 - 8)) - | ((in[8 + inpos] & 8191) << 8) - | ((in[9 + inpos]) << 21) - ; - out[4 + outpos] = ((in[9 + inpos] & 8191) >>> (13 - 2)) - | ((in[10 + inpos] & 8191) << 2) - | ((in[11 + inpos] & 8191) << 15) - | ((in[12 + inpos]) << 28) - ; - out[5 + outpos] = ((in[12 + inpos] & 8191) >>> (13 - 9)) - | ((in[13 + inpos] & 8191) << 9) - | ((in[14 + inpos]) << 22) - ; - out[6 + outpos] = ((in[14 + inpos] & 8191) >>> (13 - 3)) - | ((in[15 + inpos] & 8191) << 3) - | ((in[16 + inpos] & 8191) << 16) - | ((in[17 + inpos]) << 29) - ; - out[7 + outpos] = ((in[17 + inpos] & 8191) >>> (13 - 10)) - | ((in[18 + inpos] & 8191) << 10) - | ((in[19 + inpos]) << 23) - ; - out[8 + outpos] = ((in[19 + inpos] & 8191) >>> (13 - 4)) - | ((in[20 + inpos] & 8191) << 4) - | ((in[21 + inpos] & 8191) << 17) - | ((in[22 + inpos]) << 30) - ; - out[9 + outpos] = ((in[22 + inpos] & 8191) >>> (13 - 11)) - | ((in[23 + inpos] & 8191) << 11) - | ((in[24 + inpos]) << 24) - ; - out[10 + outpos] = ((in[24 + inpos] & 8191) >>> (13 - 5)) - | ((in[25 + inpos] & 8191) << 5) - | ((in[26 + inpos] & 8191) << 18) - | ((in[27 + inpos]) << 31) - ; - out[11 + outpos] = ((in[27 + inpos] & 8191) >>> (13 - 12)) - | ((in[28 + inpos] & 8191) << 12) - | ((in[29 + inpos]) << 25) - ; - out[12 + outpos] = ((in[29 + inpos] & 8191) >>> (13 - 6)) - | ((in[30 + inpos] & 8191) << 6) - | ((in[31 + inpos]) << 19) - ; - } - - - protected static void fastpack14(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (in[0 + inpos] & 16383) - | ((in[1 + inpos] & 16383) << 14) - | ((in[2 + inpos]) << 28) - ; - out[1 + outpos] = ((in[2 + inpos] & 16383) >>> (14 - 10)) - | ((in[3 + inpos] & 16383) << 10) - | ((in[4 + inpos]) << 24) - ; - out[2 + outpos] = ((in[4 + inpos] & 16383) >>> (14 - 6)) - | ((in[5 + inpos] & 16383) << 6) - | ((in[6 + inpos]) << 20) - ; - out[3 + outpos] = ((in[6 + inpos] & 16383) >>> (14 - 2)) - | ((in[7 + inpos] & 16383) << 2) - | ((in[8 + inpos] & 16383) << 16) - | ((in[9 + inpos]) << 30) - ; - out[4 + outpos] = ((in[9 + inpos] & 16383) >>> (14 - 12)) - | ((in[10 + inpos] & 16383) << 12) - | ((in[11 + inpos]) << 26) - ; - out[5 + outpos] = ((in[11 + inpos] & 16383) >>> (14 - 8)) - | ((in[12 + inpos] & 16383) << 8) - | ((in[13 + inpos]) << 22) - ; - out[6 + outpos] = ((in[13 + inpos] & 16383) >>> (14 - 4)) - | ((in[14 + inpos] & 16383) << 4) - | ((in[15 + inpos]) << 18) - ; - out[7 + outpos] = (in[16 + inpos] & 16383) - | ((in[17 + inpos] & 16383) << 14) - | ((in[18 + inpos]) << 28) - ; - out[8 + outpos] = ((in[18 + inpos] & 16383) >>> (14 - 10)) - | ((in[19 + inpos] & 16383) << 10) - | ((in[20 + inpos]) << 24) - ; - out[9 + outpos] = ((in[20 + inpos] & 16383) >>> (14 - 6)) - | ((in[21 + inpos] & 16383) << 6) - | ((in[22 + inpos]) << 20) - ; - out[10 + outpos] = ((in[22 + inpos] & 16383) >>> (14 - 2)) - | ((in[23 + inpos] & 16383) << 2) - | ((in[24 + inpos] & 16383) << 16) - | ((in[25 + inpos]) << 30) - ; - out[11 + outpos] = ((in[25 + inpos] & 16383) >>> (14 - 12)) - | ((in[26 + inpos] & 16383) << 12) - | ((in[27 + inpos]) << 26) - ; - out[12 + outpos] = ((in[27 + inpos] & 16383) >>> (14 - 8)) - | ((in[28 + inpos] & 16383) << 8) - | ((in[29 + inpos]) << 22) - ; - out[13 + outpos] = ((in[29 + inpos] & 16383) >>> (14 - 4)) - | ((in[30 + inpos] & 16383) << 4) - | ((in[31 + inpos]) << 18) - ; - } - - - protected static void fastpack15(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (in[0 + inpos] & 32767) - | ((in[1 + inpos] & 32767) << 15) - | ((in[2 + inpos]) << 30) - ; - out[1 + outpos] = ((in[2 + inpos] & 32767) >>> (15 - 13)) - | ((in[3 + inpos] & 32767) << 13) - | ((in[4 + inpos]) << 28) - ; - out[2 + outpos] = ((in[4 + inpos] & 32767) >>> (15 - 11)) - | ((in[5 + inpos] & 32767) << 11) - | ((in[6 + inpos]) << 26) - ; - out[3 + outpos] = ((in[6 + inpos] & 32767) >>> (15 - 9)) - | ((in[7 + inpos] & 32767) << 9) - | ((in[8 + inpos]) << 24) - ; - out[4 + outpos] = ((in[8 + inpos] & 32767) >>> (15 - 7)) - | ((in[9 + inpos] & 32767) << 7) - | ((in[10 + inpos]) << 22) - ; - out[5 + outpos] = ((in[10 + inpos] & 32767) >>> (15 - 5)) - | ((in[11 + inpos] & 32767) << 5) - | ((in[12 + inpos]) << 20) - ; - out[6 + outpos] = ((in[12 + inpos] & 32767) >>> (15 - 3)) - | ((in[13 + inpos] & 32767) << 3) - | ((in[14 + inpos]) << 18) - ; - out[7 + outpos] = ((in[14 + inpos] & 32767) >>> (15 - 1)) - | ((in[15 + inpos] & 32767) << 1) - | ((in[16 + inpos] & 32767) << 16) - | ((in[17 + inpos]) << 31) - ; - out[8 + outpos] = ((in[17 + inpos] & 32767) >>> (15 - 14)) - | ((in[18 + inpos] & 32767) << 14) - | ((in[19 + inpos]) << 29) - ; - out[9 + outpos] = ((in[19 + inpos] & 32767) >>> (15 - 12)) - | ((in[20 + inpos] & 32767) << 12) - | ((in[21 + inpos]) << 27) - ; - out[10 + outpos] = ((in[21 + inpos] & 32767) >>> (15 - 10)) - | ((in[22 + inpos] & 32767) << 10) - | ((in[23 + inpos]) << 25) - ; - out[11 + outpos] = ((in[23 + inpos] & 32767) >>> (15 - 8)) - | ((in[24 + inpos] & 32767) << 8) - | ((in[25 + inpos]) << 23) - ; - out[12 + outpos] = ((in[25 + inpos] & 32767) >>> (15 - 6)) - | ((in[26 + inpos] & 32767) << 6) - | ((in[27 + inpos]) << 21) - ; - out[13 + outpos] = ((in[27 + inpos] & 32767) >>> (15 - 4)) - | ((in[28 + inpos] & 32767) << 4) - | ((in[29 + inpos]) << 19) - ; - out[14 + outpos] = ((in[29 + inpos] & 32767) >>> (15 - 2)) - | ((in[30 + inpos] & 32767) << 2) - | ((in[31 + inpos]) << 17) - ; - } - - - protected static void fastpack16(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (in[0 + inpos] & 65535) - | ((in[1 + inpos]) << 16) - ; - out[1 + outpos] = (in[2 + inpos] & 65535) - | ((in[3 + inpos]) << 16) - ; - out[2 + outpos] = (in[4 + inpos] & 65535) - | ((in[5 + inpos]) << 16) - ; - out[3 + outpos] = (in[6 + inpos] & 65535) - | ((in[7 + inpos]) << 16) - ; - out[4 + outpos] = (in[8 + inpos] & 65535) - | ((in[9 + inpos]) << 16) - ; - out[5 + outpos] = (in[10 + inpos] & 65535) - | ((in[11 + inpos]) << 16) - ; - out[6 + outpos] = (in[12 + inpos] & 65535) - | ((in[13 + inpos]) << 16) - ; - out[7 + outpos] = (in[14 + inpos] & 65535) - | ((in[15 + inpos]) << 16) - ; - out[8 + outpos] = (in[16 + inpos] & 65535) - | ((in[17 + inpos]) << 16) - ; - out[9 + outpos] = (in[18 + inpos] & 65535) - | ((in[19 + inpos]) << 16) - ; - out[10 + outpos] = (in[20 + inpos] & 65535) - | ((in[21 + inpos]) << 16) - ; - out[11 + outpos] = (in[22 + inpos] & 65535) - | ((in[23 + inpos]) << 16) - ; - out[12 + outpos] = (in[24 + inpos] & 65535) - | ((in[25 + inpos]) << 16) - ; - out[13 + outpos] = (in[26 + inpos] & 65535) - | ((in[27 + inpos]) << 16) - ; - out[14 + outpos] = (in[28 + inpos] & 65535) - | ((in[29 + inpos]) << 16) - ; - out[15 + outpos] = (in[30 + inpos] & 65535) - | ((in[31 + inpos]) << 16) - ; - } - - - protected static void fastpack17(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (in[0 + inpos] & 131071) - | ((in[1 + inpos]) << 17) - ; - out[1 + outpos] = ((in[1 + inpos] & 131071) >>> (17 - 2)) - | ((in[2 + inpos] & 131071) << 2) - | ((in[3 + inpos]) << 19) - ; - out[2 + outpos] = ((in[3 + inpos] & 131071) >>> (17 - 4)) - | ((in[4 + inpos] & 131071) << 4) - | ((in[5 + inpos]) << 21) - ; - out[3 + outpos] = ((in[5 + inpos] & 131071) >>> (17 - 6)) - | ((in[6 + inpos] & 131071) << 6) - | ((in[7 + inpos]) << 23) - ; - out[4 + outpos] = ((in[7 + inpos] & 131071) >>> (17 - 8)) - | ((in[8 + inpos] & 131071) << 8) - | ((in[9 + inpos]) << 25) - ; - out[5 + outpos] = ((in[9 + inpos] & 131071) >>> (17 - 10)) - | ((in[10 + inpos] & 131071) << 10) - | ((in[11 + inpos]) << 27) - ; - out[6 + outpos] = ((in[11 + inpos] & 131071) >>> (17 - 12)) - | ((in[12 + inpos] & 131071) << 12) - | ((in[13 + inpos]) << 29) - ; - out[7 + outpos] = ((in[13 + inpos] & 131071) >>> (17 - 14)) - | ((in[14 + inpos] & 131071) << 14) - | ((in[15 + inpos]) << 31) - ; - out[8 + outpos] = ((in[15 + inpos] & 131071) >>> (17 - 16)) - | ((in[16 + inpos]) << 16) - ; - out[9 + outpos] = ((in[16 + inpos] & 131071) >>> (17 - 1)) - | ((in[17 + inpos] & 131071) << 1) - | ((in[18 + inpos]) << 18) - ; - out[10 + outpos] = ((in[18 + inpos] & 131071) >>> (17 - 3)) - | ((in[19 + inpos] & 131071) << 3) - | ((in[20 + inpos]) << 20) - ; - out[11 + outpos] = ((in[20 + inpos] & 131071) >>> (17 - 5)) - | ((in[21 + inpos] & 131071) << 5) - | ((in[22 + inpos]) << 22) - ; - out[12 + outpos] = ((in[22 + inpos] & 131071) >>> (17 - 7)) - | ((in[23 + inpos] & 131071) << 7) - | ((in[24 + inpos]) << 24) - ; - out[13 + outpos] = ((in[24 + inpos] & 131071) >>> (17 - 9)) - | ((in[25 + inpos] & 131071) << 9) - | ((in[26 + inpos]) << 26) - ; - out[14 + outpos] = ((in[26 + inpos] & 131071) >>> (17 - 11)) - | ((in[27 + inpos] & 131071) << 11) - | ((in[28 + inpos]) << 28) - ; - out[15 + outpos] = ((in[28 + inpos] & 131071) >>> (17 - 13)) - | ((in[29 + inpos] & 131071) << 13) - | ((in[30 + inpos]) << 30) - ; - out[16 + outpos] = ((in[30 + inpos] & 131071) >>> (17 - 15)) - | ((in[31 + inpos]) << 15) - ; - } - - - protected static void fastpack18(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (in[0 + inpos] & 262143) - | ((in[1 + inpos]) << 18) - ; - out[1 + outpos] = ((in[1 + inpos] & 262143) >>> (18 - 4)) - | ((in[2 + inpos] & 262143) << 4) - | ((in[3 + inpos]) << 22) - ; - out[2 + outpos] = ((in[3 + inpos] & 262143) >>> (18 - 8)) - | ((in[4 + inpos] & 262143) << 8) - | ((in[5 + inpos]) << 26) - ; - out[3 + outpos] = ((in[5 + inpos] & 262143) >>> (18 - 12)) - | ((in[6 + inpos] & 262143) << 12) - | ((in[7 + inpos]) << 30) - ; - out[4 + outpos] = ((in[7 + inpos] & 262143) >>> (18 - 16)) - | ((in[8 + inpos]) << 16) - ; - out[5 + outpos] = ((in[8 + inpos] & 262143) >>> (18 - 2)) - | ((in[9 + inpos] & 262143) << 2) - | ((in[10 + inpos]) << 20) - ; - out[6 + outpos] = ((in[10 + inpos] & 262143) >>> (18 - 6)) - | ((in[11 + inpos] & 262143) << 6) - | ((in[12 + inpos]) << 24) - ; - out[7 + outpos] = ((in[12 + inpos] & 262143) >>> (18 - 10)) - | ((in[13 + inpos] & 262143) << 10) - | ((in[14 + inpos]) << 28) - ; - out[8 + outpos] = ((in[14 + inpos] & 262143) >>> (18 - 14)) - | ((in[15 + inpos]) << 14) - ; - out[9 + outpos] = (in[16 + inpos] & 262143) - | ((in[17 + inpos]) << 18) - ; - out[10 + outpos] = ((in[17 + inpos] & 262143) >>> (18 - 4)) - | ((in[18 + inpos] & 262143) << 4) - | ((in[19 + inpos]) << 22) - ; - out[11 + outpos] = ((in[19 + inpos] & 262143) >>> (18 - 8)) - | ((in[20 + inpos] & 262143) << 8) - | ((in[21 + inpos]) << 26) - ; - out[12 + outpos] = ((in[21 + inpos] & 262143) >>> (18 - 12)) - | ((in[22 + inpos] & 262143) << 12) - | ((in[23 + inpos]) << 30) - ; - out[13 + outpos] = ((in[23 + inpos] & 262143) >>> (18 - 16)) - | ((in[24 + inpos]) << 16) - ; - out[14 + outpos] = ((in[24 + inpos] & 262143) >>> (18 - 2)) - | ((in[25 + inpos] & 262143) << 2) - | ((in[26 + inpos]) << 20) - ; - out[15 + outpos] = ((in[26 + inpos] & 262143) >>> (18 - 6)) - | ((in[27 + inpos] & 262143) << 6) - | ((in[28 + inpos]) << 24) - ; - out[16 + outpos] = ((in[28 + inpos] & 262143) >>> (18 - 10)) - | ((in[29 + inpos] & 262143) << 10) - | ((in[30 + inpos]) << 28) - ; - out[17 + outpos] = ((in[30 + inpos] & 262143) >>> (18 - 14)) - | ((in[31 + inpos]) << 14) - ; - } - - - protected static void fastpack19(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (in[0 + inpos] & 524287) - | ((in[1 + inpos]) << 19) - ; - out[1 + outpos] = ((in[1 + inpos] & 524287) >>> (19 - 6)) - | ((in[2 + inpos] & 524287) << 6) - | ((in[3 + inpos]) << 25) - ; - out[2 + outpos] = ((in[3 + inpos] & 524287) >>> (19 - 12)) - | ((in[4 + inpos] & 524287) << 12) - | ((in[5 + inpos]) << 31) - ; - out[3 + outpos] = ((in[5 + inpos] & 524287) >>> (19 - 18)) - | ((in[6 + inpos]) << 18) - ; - out[4 + outpos] = ((in[6 + inpos] & 524287) >>> (19 - 5)) - | ((in[7 + inpos] & 524287) << 5) - | ((in[8 + inpos]) << 24) - ; - out[5 + outpos] = ((in[8 + inpos] & 524287) >>> (19 - 11)) - | ((in[9 + inpos] & 524287) << 11) - | ((in[10 + inpos]) << 30) - ; - out[6 + outpos] = ((in[10 + inpos] & 524287) >>> (19 - 17)) - | ((in[11 + inpos]) << 17) - ; - out[7 + outpos] = ((in[11 + inpos] & 524287) >>> (19 - 4)) - | ((in[12 + inpos] & 524287) << 4) - | ((in[13 + inpos]) << 23) - ; - out[8 + outpos] = ((in[13 + inpos] & 524287) >>> (19 - 10)) - | ((in[14 + inpos] & 524287) << 10) - | ((in[15 + inpos]) << 29) - ; - out[9 + outpos] = ((in[15 + inpos] & 524287) >>> (19 - 16)) - | ((in[16 + inpos]) << 16) - ; - out[10 + outpos] = ((in[16 + inpos] & 524287) >>> (19 - 3)) - | ((in[17 + inpos] & 524287) << 3) - | ((in[18 + inpos]) << 22) - ; - out[11 + outpos] = ((in[18 + inpos] & 524287) >>> (19 - 9)) - | ((in[19 + inpos] & 524287) << 9) - | ((in[20 + inpos]) << 28) - ; - out[12 + outpos] = ((in[20 + inpos] & 524287) >>> (19 - 15)) - | ((in[21 + inpos]) << 15) - ; - out[13 + outpos] = ((in[21 + inpos] & 524287) >>> (19 - 2)) - | ((in[22 + inpos] & 524287) << 2) - | ((in[23 + inpos]) << 21) - ; - out[14 + outpos] = ((in[23 + inpos] & 524287) >>> (19 - 8)) - | ((in[24 + inpos] & 524287) << 8) - | ((in[25 + inpos]) << 27) - ; - out[15 + outpos] = ((in[25 + inpos] & 524287) >>> (19 - 14)) - | ((in[26 + inpos]) << 14) - ; - out[16 + outpos] = ((in[26 + inpos] & 524287) >>> (19 - 1)) - | ((in[27 + inpos] & 524287) << 1) - | ((in[28 + inpos]) << 20) - ; - out[17 + outpos] = ((in[28 + inpos] & 524287) >>> (19 - 7)) - | ((in[29 + inpos] & 524287) << 7) - | ((in[30 + inpos]) << 26) - ; - out[18 + outpos] = ((in[30 + inpos] & 524287) >>> (19 - 13)) - | ((in[31 + inpos]) << 13) - ; - } - - - protected static void fastpack20(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (in[0 + inpos] & 1048575) - | ((in[1 + inpos]) << 20) - ; - out[1 + outpos] = ((in[1 + inpos] & 1048575) >>> (20 - 8)) - | ((in[2 + inpos] & 1048575) << 8) - | ((in[3 + inpos]) << 28) - ; - out[2 + outpos] = ((in[3 + inpos] & 1048575) >>> (20 - 16)) - | ((in[4 + inpos]) << 16) - ; - out[3 + outpos] = ((in[4 + inpos] & 1048575) >>> (20 - 4)) - | ((in[5 + inpos] & 1048575) << 4) - | ((in[6 + inpos]) << 24) - ; - out[4 + outpos] = ((in[6 + inpos] & 1048575) >>> (20 - 12)) - | ((in[7 + inpos]) << 12) - ; - out[5 + outpos] = (in[8 + inpos] & 1048575) - | ((in[9 + inpos]) << 20) - ; - out[6 + outpos] = ((in[9 + inpos] & 1048575) >>> (20 - 8)) - | ((in[10 + inpos] & 1048575) << 8) - | ((in[11 + inpos]) << 28) - ; - out[7 + outpos] = ((in[11 + inpos] & 1048575) >>> (20 - 16)) - | ((in[12 + inpos]) << 16) - ; - out[8 + outpos] = ((in[12 + inpos] & 1048575) >>> (20 - 4)) - | ((in[13 + inpos] & 1048575) << 4) - | ((in[14 + inpos]) << 24) - ; - out[9 + outpos] = ((in[14 + inpos] & 1048575) >>> (20 - 12)) - | ((in[15 + inpos]) << 12) - ; - out[10 + outpos] = (in[16 + inpos] & 1048575) - | ((in[17 + inpos]) << 20) - ; - out[11 + outpos] = ((in[17 + inpos] & 1048575) >>> (20 - 8)) - | ((in[18 + inpos] & 1048575) << 8) - | ((in[19 + inpos]) << 28) - ; - out[12 + outpos] = ((in[19 + inpos] & 1048575) >>> (20 - 16)) - | ((in[20 + inpos]) << 16) - ; - out[13 + outpos] = ((in[20 + inpos] & 1048575) >>> (20 - 4)) - | ((in[21 + inpos] & 1048575) << 4) - | ((in[22 + inpos]) << 24) - ; - out[14 + outpos] = ((in[22 + inpos] & 1048575) >>> (20 - 12)) - | ((in[23 + inpos]) << 12) - ; - out[15 + outpos] = (in[24 + inpos] & 1048575) - | ((in[25 + inpos]) << 20) - ; - out[16 + outpos] = ((in[25 + inpos] & 1048575) >>> (20 - 8)) - | ((in[26 + inpos] & 1048575) << 8) - | ((in[27 + inpos]) << 28) - ; - out[17 + outpos] = ((in[27 + inpos] & 1048575) >>> (20 - 16)) - | ((in[28 + inpos]) << 16) - ; - out[18 + outpos] = ((in[28 + inpos] & 1048575) >>> (20 - 4)) - | ((in[29 + inpos] & 1048575) << 4) - | ((in[30 + inpos]) << 24) - ; - out[19 + outpos] = ((in[30 + inpos] & 1048575) >>> (20 - 12)) - | ((in[31 + inpos]) << 12) - ; - } - - - protected static void fastpack21(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (in[0 + inpos] & 2097151) - | ((in[1 + inpos]) << 21) - ; - out[1 + outpos] = ((in[1 + inpos] & 2097151) >>> (21 - 10)) - | ((in[2 + inpos] & 2097151) << 10) - | ((in[3 + inpos]) << 31) - ; - out[2 + outpos] = ((in[3 + inpos] & 2097151) >>> (21 - 20)) - | ((in[4 + inpos]) << 20) - ; - out[3 + outpos] = ((in[4 + inpos] & 2097151) >>> (21 - 9)) - | ((in[5 + inpos] & 2097151) << 9) - | ((in[6 + inpos]) << 30) - ; - out[4 + outpos] = ((in[6 + inpos] & 2097151) >>> (21 - 19)) - | ((in[7 + inpos]) << 19) - ; - out[5 + outpos] = ((in[7 + inpos] & 2097151) >>> (21 - 8)) - | ((in[8 + inpos] & 2097151) << 8) - | ((in[9 + inpos]) << 29) - ; - out[6 + outpos] = ((in[9 + inpos] & 2097151) >>> (21 - 18)) - | ((in[10 + inpos]) << 18) - ; - out[7 + outpos] = ((in[10 + inpos] & 2097151) >>> (21 - 7)) - | ((in[11 + inpos] & 2097151) << 7) - | ((in[12 + inpos]) << 28) - ; - out[8 + outpos] = ((in[12 + inpos] & 2097151) >>> (21 - 17)) - | ((in[13 + inpos]) << 17) - ; - out[9 + outpos] = ((in[13 + inpos] & 2097151) >>> (21 - 6)) - | ((in[14 + inpos] & 2097151) << 6) - | ((in[15 + inpos]) << 27) - ; - out[10 + outpos] = ((in[15 + inpos] & 2097151) >>> (21 - 16)) - | ((in[16 + inpos]) << 16) - ; - out[11 + outpos] = ((in[16 + inpos] & 2097151) >>> (21 - 5)) - | ((in[17 + inpos] & 2097151) << 5) - | ((in[18 + inpos]) << 26) - ; - out[12 + outpos] = ((in[18 + inpos] & 2097151) >>> (21 - 15)) - | ((in[19 + inpos]) << 15) - ; - out[13 + outpos] = ((in[19 + inpos] & 2097151) >>> (21 - 4)) - | ((in[20 + inpos] & 2097151) << 4) - | ((in[21 + inpos]) << 25) - ; - out[14 + outpos] = ((in[21 + inpos] & 2097151) >>> (21 - 14)) - | ((in[22 + inpos]) << 14) - ; - out[15 + outpos] = ((in[22 + inpos] & 2097151) >>> (21 - 3)) - | ((in[23 + inpos] & 2097151) << 3) - | ((in[24 + inpos]) << 24) - ; - out[16 + outpos] = ((in[24 + inpos] & 2097151) >>> (21 - 13)) - | ((in[25 + inpos]) << 13) - ; - out[17 + outpos] = ((in[25 + inpos] & 2097151) >>> (21 - 2)) - | ((in[26 + inpos] & 2097151) << 2) - | ((in[27 + inpos]) << 23) - ; - out[18 + outpos] = ((in[27 + inpos] & 2097151) >>> (21 - 12)) - | ((in[28 + inpos]) << 12) - ; - out[19 + outpos] = ((in[28 + inpos] & 2097151) >>> (21 - 1)) - | ((in[29 + inpos] & 2097151) << 1) - | ((in[30 + inpos]) << 22) - ; - out[20 + outpos] = ((in[30 + inpos] & 2097151) >>> (21 - 11)) - | ((in[31 + inpos]) << 11) - ; - } + protected static void fastpack0(final int[] in, int inpos, + final int[] out, int outpos) { + // nothing + } + protected static void fastpack1(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = (in[0 + inpos] & 1) + | ((in[1 + inpos] & 1) << 1) + | ((in[2 + inpos] & 1) << 2) + | ((in[3 + inpos] & 1) << 3) + | ((in[4 + inpos] & 1) << 4) + | ((in[5 + inpos] & 1) << 5) + | ((in[6 + inpos] & 1) << 6) + | ((in[7 + inpos] & 1) << 7) + | ((in[8 + inpos] & 1) << 8) + | ((in[9 + inpos] & 1) << 9) + | ((in[10 + inpos] & 1) << 10) + | ((in[11 + inpos] & 1) << 11) + | ((in[12 + inpos] & 1) << 12) + | ((in[13 + inpos] & 1) << 13) + | ((in[14 + inpos] & 1) << 14) + | ((in[15 + inpos] & 1) << 15) + | ((in[16 + inpos] & 1) << 16) + | ((in[17 + inpos] & 1) << 17) + | ((in[18 + inpos] & 1) << 18) + | ((in[19 + inpos] & 1) << 19) + | ((in[20 + inpos] & 1) << 20) + | ((in[21 + inpos] & 1) << 21) + | ((in[22 + inpos] & 1) << 22) + | ((in[23 + inpos] & 1) << 23) + | ((in[24 + inpos] & 1) << 24) + | ((in[25 + inpos] & 1) << 25) + | ((in[26 + inpos] & 1) << 26) + | ((in[27 + inpos] & 1) << 27) + | ((in[28 + inpos] & 1) << 28) + | ((in[29 + inpos] & 1) << 29) + | ((in[30 + inpos] & 1) << 30) + | ((in[31 + inpos]) << 31); + } - protected static void fastpack22(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (in[0 + inpos] & 4194303) - | ((in[1 + inpos]) << 22) - ; - out[1 + outpos] = ((in[1 + inpos] & 4194303) >>> (22 - 12)) - | ((in[2 + inpos]) << 12) - ; - out[2 + outpos] = ((in[2 + inpos] & 4194303) >>> (22 - 2)) - | ((in[3 + inpos] & 4194303) << 2) - | ((in[4 + inpos]) << 24) - ; - out[3 + outpos] = ((in[4 + inpos] & 4194303) >>> (22 - 14)) - | ((in[5 + inpos]) << 14) - ; - out[4 + outpos] = ((in[5 + inpos] & 4194303) >>> (22 - 4)) - | ((in[6 + inpos] & 4194303) << 4) - | ((in[7 + inpos]) << 26) - ; - out[5 + outpos] = ((in[7 + inpos] & 4194303) >>> (22 - 16)) - | ((in[8 + inpos]) << 16) - ; - out[6 + outpos] = ((in[8 + inpos] & 4194303) >>> (22 - 6)) - | ((in[9 + inpos] & 4194303) << 6) - | ((in[10 + inpos]) << 28) - ; - out[7 + outpos] = ((in[10 + inpos] & 4194303) >>> (22 - 18)) - | ((in[11 + inpos]) << 18) - ; - out[8 + outpos] = ((in[11 + inpos] & 4194303) >>> (22 - 8)) - | ((in[12 + inpos] & 4194303) << 8) - | ((in[13 + inpos]) << 30) - ; - out[9 + outpos] = ((in[13 + inpos] & 4194303) >>> (22 - 20)) - | ((in[14 + inpos]) << 20) - ; - out[10 + outpos] = ((in[14 + inpos] & 4194303) >>> (22 - 10)) - | ((in[15 + inpos]) << 10) - ; - out[11 + outpos] = (in[16 + inpos] & 4194303) - | ((in[17 + inpos]) << 22) - ; - out[12 + outpos] = ((in[17 + inpos] & 4194303) >>> (22 - 12)) - | ((in[18 + inpos]) << 12) - ; - out[13 + outpos] = ((in[18 + inpos] & 4194303) >>> (22 - 2)) - | ((in[19 + inpos] & 4194303) << 2) - | ((in[20 + inpos]) << 24) - ; - out[14 + outpos] = ((in[20 + inpos] & 4194303) >>> (22 - 14)) - | ((in[21 + inpos]) << 14) - ; - out[15 + outpos] = ((in[21 + inpos] & 4194303) >>> (22 - 4)) - | ((in[22 + inpos] & 4194303) << 4) - | ((in[23 + inpos]) << 26) - ; - out[16 + outpos] = ((in[23 + inpos] & 4194303) >>> (22 - 16)) - | ((in[24 + inpos]) << 16) - ; - out[17 + outpos] = ((in[24 + inpos] & 4194303) >>> (22 - 6)) - | ((in[25 + inpos] & 4194303) << 6) - | ((in[26 + inpos]) << 28) - ; - out[18 + outpos] = ((in[26 + inpos] & 4194303) >>> (22 - 18)) - | ((in[27 + inpos]) << 18) - ; - out[19 + outpos] = ((in[27 + inpos] & 4194303) >>> (22 - 8)) - | ((in[28 + inpos] & 4194303) << 8) - | ((in[29 + inpos]) << 30) - ; - out[20 + outpos] = ((in[29 + inpos] & 4194303) >>> (22 - 20)) - | ((in[30 + inpos]) << 20) - ; - out[21 + outpos] = ((in[30 + inpos] & 4194303) >>> (22 - 10)) - | ((in[31 + inpos]) << 10) - ; - } + protected static void fastpack10(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = (in[0 + inpos] & 1023) + | ((in[1 + inpos] & 1023) << 10) + | ((in[2 + inpos] & 1023) << 20) + | ((in[3 + inpos]) << 30); + out[1 + outpos] = ((in[3 + inpos] & 1023) >>> (10 - 8)) + | ((in[4 + inpos] & 1023) << 8) + | ((in[5 + inpos] & 1023) << 18) + | ((in[6 + inpos]) << 28); + out[2 + outpos] = ((in[6 + inpos] & 1023) >>> (10 - 6)) + | ((in[7 + inpos] & 1023) << 6) + | ((in[8 + inpos] & 1023) << 16) + | ((in[9 + inpos]) << 26); + out[3 + outpos] = ((in[9 + inpos] & 1023) >>> (10 - 4)) + | ((in[10 + inpos] & 1023) << 4) + | ((in[11 + inpos] & 1023) << 14) + | ((in[12 + inpos]) << 24); + out[4 + outpos] = ((in[12 + inpos] & 1023) >>> (10 - 2)) + | ((in[13 + inpos] & 1023) << 2) + | ((in[14 + inpos] & 1023) << 12) + | ((in[15 + inpos]) << 22); + out[5 + outpos] = (in[16 + inpos] & 1023) + | ((in[17 + inpos] & 1023) << 10) + | ((in[18 + inpos] & 1023) << 20) + | ((in[19 + inpos]) << 30); + out[6 + outpos] = ((in[19 + inpos] & 1023) >>> (10 - 8)) + | ((in[20 + inpos] & 1023) << 8) + | ((in[21 + inpos] & 1023) << 18) + | ((in[22 + inpos]) << 28); + out[7 + outpos] = ((in[22 + inpos] & 1023) >>> (10 - 6)) + | ((in[23 + inpos] & 1023) << 6) + | ((in[24 + inpos] & 1023) << 16) + | ((in[25 + inpos]) << 26); + out[8 + outpos] = ((in[25 + inpos] & 1023) >>> (10 - 4)) + | ((in[26 + inpos] & 1023) << 4) + | ((in[27 + inpos] & 1023) << 14) + | ((in[28 + inpos]) << 24); + out[9 + outpos] = ((in[28 + inpos] & 1023) >>> (10 - 2)) + | ((in[29 + inpos] & 1023) << 2) + | ((in[30 + inpos] & 1023) << 12) + | ((in[31 + inpos]) << 22); + } + protected static void fastpack11(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = (in[0 + inpos] & 2047) + | ((in[1 + inpos] & 2047) << 11) + | ((in[2 + inpos]) << 22); + out[1 + outpos] = ((in[2 + inpos] & 2047) >>> (11 - 1)) + | ((in[3 + inpos] & 2047) << 1) + | ((in[4 + inpos] & 2047) << 12) + | ((in[5 + inpos]) << 23); + out[2 + outpos] = ((in[5 + inpos] & 2047) >>> (11 - 2)) + | ((in[6 + inpos] & 2047) << 2) + | ((in[7 + inpos] & 2047) << 13) + | ((in[8 + inpos]) << 24); + out[3 + outpos] = ((in[8 + inpos] & 2047) >>> (11 - 3)) + | ((in[9 + inpos] & 2047) << 3) + | ((in[10 + inpos] & 2047) << 14) + | ((in[11 + inpos]) << 25); + out[4 + outpos] = ((in[11 + inpos] & 2047) >>> (11 - 4)) + | ((in[12 + inpos] & 2047) << 4) + | ((in[13 + inpos] & 2047) << 15) + | ((in[14 + inpos]) << 26); + out[5 + outpos] = ((in[14 + inpos] & 2047) >>> (11 - 5)) + | ((in[15 + inpos] & 2047) << 5) + | ((in[16 + inpos] & 2047) << 16) + | ((in[17 + inpos]) << 27); + out[6 + outpos] = ((in[17 + inpos] & 2047) >>> (11 - 6)) + | ((in[18 + inpos] & 2047) << 6) + | ((in[19 + inpos] & 2047) << 17) + | ((in[20 + inpos]) << 28); + out[7 + outpos] = ((in[20 + inpos] & 2047) >>> (11 - 7)) + | ((in[21 + inpos] & 2047) << 7) + | ((in[22 + inpos] & 2047) << 18) + | ((in[23 + inpos]) << 29); + out[8 + outpos] = ((in[23 + inpos] & 2047) >>> (11 - 8)) + | ((in[24 + inpos] & 2047) << 8) + | ((in[25 + inpos] & 2047) << 19) + | ((in[26 + inpos]) << 30); + out[9 + outpos] = ((in[26 + inpos] & 2047) >>> (11 - 9)) + | ((in[27 + inpos] & 2047) << 9) + | ((in[28 + inpos] & 2047) << 20) + | ((in[29 + inpos]) << 31); + out[10 + outpos] = ((in[29 + inpos] & 2047) >>> (11 - 10)) + | ((in[30 + inpos] & 2047) << 10) + | ((in[31 + inpos]) << 21); + } - protected static void fastpack23(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (in[0 + inpos] & 8388607) - | ((in[1 + inpos]) << 23) - ; - out[1 + outpos] = ((in[1 + inpos] & 8388607) >>> (23 - 14)) - | ((in[2 + inpos]) << 14) - ; - out[2 + outpos] = ((in[2 + inpos] & 8388607) >>> (23 - 5)) - | ((in[3 + inpos] & 8388607) << 5) - | ((in[4 + inpos]) << 28) - ; - out[3 + outpos] = ((in[4 + inpos] & 8388607) >>> (23 - 19)) - | ((in[5 + inpos]) << 19) - ; - out[4 + outpos] = ((in[5 + inpos] & 8388607) >>> (23 - 10)) - | ((in[6 + inpos]) << 10) - ; - out[5 + outpos] = ((in[6 + inpos] & 8388607) >>> (23 - 1)) - | ((in[7 + inpos] & 8388607) << 1) - | ((in[8 + inpos]) << 24) - ; - out[6 + outpos] = ((in[8 + inpos] & 8388607) >>> (23 - 15)) - | ((in[9 + inpos]) << 15) - ; - out[7 + outpos] = ((in[9 + inpos] & 8388607) >>> (23 - 6)) - | ((in[10 + inpos] & 8388607) << 6) - | ((in[11 + inpos]) << 29) - ; - out[8 + outpos] = ((in[11 + inpos] & 8388607) >>> (23 - 20)) - | ((in[12 + inpos]) << 20) - ; - out[9 + outpos] = ((in[12 + inpos] & 8388607) >>> (23 - 11)) - | ((in[13 + inpos]) << 11) - ; - out[10 + outpos] = ((in[13 + inpos] & 8388607) >>> (23 - 2)) - | ((in[14 + inpos] & 8388607) << 2) - | ((in[15 + inpos]) << 25) - ; - out[11 + outpos] = ((in[15 + inpos] & 8388607) >>> (23 - 16)) - | ((in[16 + inpos]) << 16) - ; - out[12 + outpos] = ((in[16 + inpos] & 8388607) >>> (23 - 7)) - | ((in[17 + inpos] & 8388607) << 7) - | ((in[18 + inpos]) << 30) - ; - out[13 + outpos] = ((in[18 + inpos] & 8388607) >>> (23 - 21)) - | ((in[19 + inpos]) << 21) - ; - out[14 + outpos] = ((in[19 + inpos] & 8388607) >>> (23 - 12)) - | ((in[20 + inpos]) << 12) - ; - out[15 + outpos] = ((in[20 + inpos] & 8388607) >>> (23 - 3)) - | ((in[21 + inpos] & 8388607) << 3) - | ((in[22 + inpos]) << 26) - ; - out[16 + outpos] = ((in[22 + inpos] & 8388607) >>> (23 - 17)) - | ((in[23 + inpos]) << 17) - ; - out[17 + outpos] = ((in[23 + inpos] & 8388607) >>> (23 - 8)) - | ((in[24 + inpos] & 8388607) << 8) - | ((in[25 + inpos]) << 31) - ; - out[18 + outpos] = ((in[25 + inpos] & 8388607) >>> (23 - 22)) - | ((in[26 + inpos]) << 22) - ; - out[19 + outpos] = ((in[26 + inpos] & 8388607) >>> (23 - 13)) - | ((in[27 + inpos]) << 13) - ; - out[20 + outpos] = ((in[27 + inpos] & 8388607) >>> (23 - 4)) - | ((in[28 + inpos] & 8388607) << 4) - | ((in[29 + inpos]) << 27) - ; - out[21 + outpos] = ((in[29 + inpos] & 8388607) >>> (23 - 18)) - | ((in[30 + inpos]) << 18) - ; - out[22 + outpos] = ((in[30 + inpos] & 8388607) >>> (23 - 9)) - | ((in[31 + inpos]) << 9) - ; - } + protected static void fastpack12(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = (in[0 + inpos] & 4095) + | ((in[1 + inpos] & 4095) << 12) + | ((in[2 + inpos]) << 24); + out[1 + outpos] = ((in[2 + inpos] & 4095) >>> (12 - 4)) + | ((in[3 + inpos] & 4095) << 4) + | ((in[4 + inpos] & 4095) << 16) + | ((in[5 + inpos]) << 28); + out[2 + outpos] = ((in[5 + inpos] & 4095) >>> (12 - 8)) + | ((in[6 + inpos] & 4095) << 8) + | ((in[7 + inpos]) << 20); + out[3 + outpos] = (in[8 + inpos] & 4095) + | ((in[9 + inpos] & 4095) << 12) + | ((in[10 + inpos]) << 24); + out[4 + outpos] = ((in[10 + inpos] & 4095) >>> (12 - 4)) + | ((in[11 + inpos] & 4095) << 4) + | ((in[12 + inpos] & 4095) << 16) + | ((in[13 + inpos]) << 28); + out[5 + outpos] = ((in[13 + inpos] & 4095) >>> (12 - 8)) + | ((in[14 + inpos] & 4095) << 8) + | ((in[15 + inpos]) << 20); + out[6 + outpos] = (in[16 + inpos] & 4095) + | ((in[17 + inpos] & 4095) << 12) + | ((in[18 + inpos]) << 24); + out[7 + outpos] = ((in[18 + inpos] & 4095) >>> (12 - 4)) + | ((in[19 + inpos] & 4095) << 4) + | ((in[20 + inpos] & 4095) << 16) + | ((in[21 + inpos]) << 28); + out[8 + outpos] = ((in[21 + inpos] & 4095) >>> (12 - 8)) + | ((in[22 + inpos] & 4095) << 8) + | ((in[23 + inpos]) << 20); + out[9 + outpos] = (in[24 + inpos] & 4095) + | ((in[25 + inpos] & 4095) << 12) + | ((in[26 + inpos]) << 24); + out[10 + outpos] = ((in[26 + inpos] & 4095) >>> (12 - 4)) + | ((in[27 + inpos] & 4095) << 4) + | ((in[28 + inpos] & 4095) << 16) + | ((in[29 + inpos]) << 28); + out[11 + outpos] = ((in[29 + inpos] & 4095) >>> (12 - 8)) + | ((in[30 + inpos] & 4095) << 8) + | ((in[31 + inpos]) << 20); + } + protected static void fastpack13(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = (in[0 + inpos] & 8191) + | ((in[1 + inpos] & 8191) << 13) + | ((in[2 + inpos]) << 26); + out[1 + outpos] = ((in[2 + inpos] & 8191) >>> (13 - 7)) + | ((in[3 + inpos] & 8191) << 7) + | ((in[4 + inpos]) << 20); + out[2 + outpos] = ((in[4 + inpos] & 8191) >>> (13 - 1)) + | ((in[5 + inpos] & 8191) << 1) + | ((in[6 + inpos] & 8191) << 14) + | ((in[7 + inpos]) << 27); + out[3 + outpos] = ((in[7 + inpos] & 8191) >>> (13 - 8)) + | ((in[8 + inpos] & 8191) << 8) + | ((in[9 + inpos]) << 21); + out[4 + outpos] = ((in[9 + inpos] & 8191) >>> (13 - 2)) + | ((in[10 + inpos] & 8191) << 2) + | ((in[11 + inpos] & 8191) << 15) + | ((in[12 + inpos]) << 28); + out[5 + outpos] = ((in[12 + inpos] & 8191) >>> (13 - 9)) + | ((in[13 + inpos] & 8191) << 9) + | ((in[14 + inpos]) << 22); + out[6 + outpos] = ((in[14 + inpos] & 8191) >>> (13 - 3)) + | ((in[15 + inpos] & 8191) << 3) + | ((in[16 + inpos] & 8191) << 16) + | ((in[17 + inpos]) << 29); + out[7 + outpos] = ((in[17 + inpos] & 8191) >>> (13 - 10)) + | ((in[18 + inpos] & 8191) << 10) + | ((in[19 + inpos]) << 23); + out[8 + outpos] = ((in[19 + inpos] & 8191) >>> (13 - 4)) + | ((in[20 + inpos] & 8191) << 4) + | ((in[21 + inpos] & 8191) << 17) + | ((in[22 + inpos]) << 30); + out[9 + outpos] = ((in[22 + inpos] & 8191) >>> (13 - 11)) + | ((in[23 + inpos] & 8191) << 11) + | ((in[24 + inpos]) << 24); + out[10 + outpos] = ((in[24 + inpos] & 8191) >>> (13 - 5)) + | ((in[25 + inpos] & 8191) << 5) + | ((in[26 + inpos] & 8191) << 18) + | ((in[27 + inpos]) << 31); + out[11 + outpos] = ((in[27 + inpos] & 8191) >>> (13 - 12)) + | ((in[28 + inpos] & 8191) << 12) + | ((in[29 + inpos]) << 25); + out[12 + outpos] = ((in[29 + inpos] & 8191) >>> (13 - 6)) + | ((in[30 + inpos] & 8191) << 6) + | ((in[31 + inpos]) << 19); + } - protected static void fastpack24(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (in[0 + inpos] & 16777215) - | ((in[1 + inpos]) << 24) - ; - out[1 + outpos] = ((in[1 + inpos] & 16777215) >>> (24 - 16)) - | ((in[2 + inpos]) << 16) - ; - out[2 + outpos] = ((in[2 + inpos] & 16777215) >>> (24 - 8)) - | ((in[3 + inpos]) << 8) - ; - out[3 + outpos] = (in[4 + inpos] & 16777215) - | ((in[5 + inpos]) << 24) - ; - out[4 + outpos] = ((in[5 + inpos] & 16777215) >>> (24 - 16)) - | ((in[6 + inpos]) << 16) - ; - out[5 + outpos] = ((in[6 + inpos] & 16777215) >>> (24 - 8)) - | ((in[7 + inpos]) << 8) - ; - out[6 + outpos] = (in[8 + inpos] & 16777215) - | ((in[9 + inpos]) << 24) - ; - out[7 + outpos] = ((in[9 + inpos] & 16777215) >>> (24 - 16)) - | ((in[10 + inpos]) << 16) - ; - out[8 + outpos] = ((in[10 + inpos] & 16777215) >>> (24 - 8)) - | ((in[11 + inpos]) << 8) - ; - out[9 + outpos] = (in[12 + inpos] & 16777215) - | ((in[13 + inpos]) << 24) - ; - out[10 + outpos] = ((in[13 + inpos] & 16777215) >>> (24 - 16)) - | ((in[14 + inpos]) << 16) - ; - out[11 + outpos] = ((in[14 + inpos] & 16777215) >>> (24 - 8)) - | ((in[15 + inpos]) << 8) - ; - out[12 + outpos] = (in[16 + inpos] & 16777215) - | ((in[17 + inpos]) << 24) - ; - out[13 + outpos] = ((in[17 + inpos] & 16777215) >>> (24 - 16)) - | ((in[18 + inpos]) << 16) - ; - out[14 + outpos] = ((in[18 + inpos] & 16777215) >>> (24 - 8)) - | ((in[19 + inpos]) << 8) - ; - out[15 + outpos] = (in[20 + inpos] & 16777215) - | ((in[21 + inpos]) << 24) - ; - out[16 + outpos] = ((in[21 + inpos] & 16777215) >>> (24 - 16)) - | ((in[22 + inpos]) << 16) - ; - out[17 + outpos] = ((in[22 + inpos] & 16777215) >>> (24 - 8)) - | ((in[23 + inpos]) << 8) - ; - out[18 + outpos] = (in[24 + inpos] & 16777215) - | ((in[25 + inpos]) << 24) - ; - out[19 + outpos] = ((in[25 + inpos] & 16777215) >>> (24 - 16)) - | ((in[26 + inpos]) << 16) - ; - out[20 + outpos] = ((in[26 + inpos] & 16777215) >>> (24 - 8)) - | ((in[27 + inpos]) << 8) - ; - out[21 + outpos] = (in[28 + inpos] & 16777215) - | ((in[29 + inpos]) << 24) - ; - out[22 + outpos] = ((in[29 + inpos] & 16777215) >>> (24 - 16)) - | ((in[30 + inpos]) << 16) - ; - out[23 + outpos] = ((in[30 + inpos] & 16777215) >>> (24 - 8)) - | ((in[31 + inpos]) << 8) - ; - } + protected static void fastpack14(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = (in[0 + inpos] & 16383) + | ((in[1 + inpos] & 16383) << 14) + | ((in[2 + inpos]) << 28); + out[1 + outpos] = ((in[2 + inpos] & 16383) >>> (14 - 10)) + | ((in[3 + inpos] & 16383) << 10) + | ((in[4 + inpos]) << 24); + out[2 + outpos] = ((in[4 + inpos] & 16383) >>> (14 - 6)) + | ((in[5 + inpos] & 16383) << 6) + | ((in[6 + inpos]) << 20); + out[3 + outpos] = ((in[6 + inpos] & 16383) >>> (14 - 2)) + | ((in[7 + inpos] & 16383) << 2) + | ((in[8 + inpos] & 16383) << 16) + | ((in[9 + inpos]) << 30); + out[4 + outpos] = ((in[9 + inpos] & 16383) >>> (14 - 12)) + | ((in[10 + inpos] & 16383) << 12) + | ((in[11 + inpos]) << 26); + out[5 + outpos] = ((in[11 + inpos] & 16383) >>> (14 - 8)) + | ((in[12 + inpos] & 16383) << 8) + | ((in[13 + inpos]) << 22); + out[6 + outpos] = ((in[13 + inpos] & 16383) >>> (14 - 4)) + | ((in[14 + inpos] & 16383) << 4) + | ((in[15 + inpos]) << 18); + out[7 + outpos] = (in[16 + inpos] & 16383) + | ((in[17 + inpos] & 16383) << 14) + | ((in[18 + inpos]) << 28); + out[8 + outpos] = ((in[18 + inpos] & 16383) >>> (14 - 10)) + | ((in[19 + inpos] & 16383) << 10) + | ((in[20 + inpos]) << 24); + out[9 + outpos] = ((in[20 + inpos] & 16383) >>> (14 - 6)) + | ((in[21 + inpos] & 16383) << 6) + | ((in[22 + inpos]) << 20); + out[10 + outpos] = ((in[22 + inpos] & 16383) >>> (14 - 2)) + | ((in[23 + inpos] & 16383) << 2) + | ((in[24 + inpos] & 16383) << 16) + | ((in[25 + inpos]) << 30); + out[11 + outpos] = ((in[25 + inpos] & 16383) >>> (14 - 12)) + | ((in[26 + inpos] & 16383) << 12) + | ((in[27 + inpos]) << 26); + out[12 + outpos] = ((in[27 + inpos] & 16383) >>> (14 - 8)) + | ((in[28 + inpos] & 16383) << 8) + | ((in[29 + inpos]) << 22); + out[13 + outpos] = ((in[29 + inpos] & 16383) >>> (14 - 4)) + | ((in[30 + inpos] & 16383) << 4) + | ((in[31 + inpos]) << 18); + } + protected static void fastpack15(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = (in[0 + inpos] & 32767) + | ((in[1 + inpos] & 32767) << 15) + | ((in[2 + inpos]) << 30); + out[1 + outpos] = ((in[2 + inpos] & 32767) >>> (15 - 13)) + | ((in[3 + inpos] & 32767) << 13) + | ((in[4 + inpos]) << 28); + out[2 + outpos] = ((in[4 + inpos] & 32767) >>> (15 - 11)) + | ((in[5 + inpos] & 32767) << 11) + | ((in[6 + inpos]) << 26); + out[3 + outpos] = ((in[6 + inpos] & 32767) >>> (15 - 9)) + | ((in[7 + inpos] & 32767) << 9) + | ((in[8 + inpos]) << 24); + out[4 + outpos] = ((in[8 + inpos] & 32767) >>> (15 - 7)) + | ((in[9 + inpos] & 32767) << 7) + | ((in[10 + inpos]) << 22); + out[5 + outpos] = ((in[10 + inpos] & 32767) >>> (15 - 5)) + | ((in[11 + inpos] & 32767) << 5) + | ((in[12 + inpos]) << 20); + out[6 + outpos] = ((in[12 + inpos] & 32767) >>> (15 - 3)) + | ((in[13 + inpos] & 32767) << 3) + | ((in[14 + inpos]) << 18); + out[7 + outpos] = ((in[14 + inpos] & 32767) >>> (15 - 1)) + | ((in[15 + inpos] & 32767) << 1) + | ((in[16 + inpos] & 32767) << 16) + | ((in[17 + inpos]) << 31); + out[8 + outpos] = ((in[17 + inpos] & 32767) >>> (15 - 14)) + | ((in[18 + inpos] & 32767) << 14) + | ((in[19 + inpos]) << 29); + out[9 + outpos] = ((in[19 + inpos] & 32767) >>> (15 - 12)) + | ((in[20 + inpos] & 32767) << 12) + | ((in[21 + inpos]) << 27); + out[10 + outpos] = ((in[21 + inpos] & 32767) >>> (15 - 10)) + | ((in[22 + inpos] & 32767) << 10) + | ((in[23 + inpos]) << 25); + out[11 + outpos] = ((in[23 + inpos] & 32767) >>> (15 - 8)) + | ((in[24 + inpos] & 32767) << 8) + | ((in[25 + inpos]) << 23); + out[12 + outpos] = ((in[25 + inpos] & 32767) >>> (15 - 6)) + | ((in[26 + inpos] & 32767) << 6) + | ((in[27 + inpos]) << 21); + out[13 + outpos] = ((in[27 + inpos] & 32767) >>> (15 - 4)) + | ((in[28 + inpos] & 32767) << 4) + | ((in[29 + inpos]) << 19); + out[14 + outpos] = ((in[29 + inpos] & 32767) >>> (15 - 2)) + | ((in[30 + inpos] & 32767) << 2) + | ((in[31 + inpos]) << 17); + } - protected static void fastpack25(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (in[0 + inpos] & 33554431) - | ((in[1 + inpos]) << 25) - ; - out[1 + outpos] = ((in[1 + inpos] & 33554431) >>> (25 - 18)) - | ((in[2 + inpos]) << 18) - ; - out[2 + outpos] = ((in[2 + inpos] & 33554431) >>> (25 - 11)) - | ((in[3 + inpos]) << 11) - ; - out[3 + outpos] = ((in[3 + inpos] & 33554431) >>> (25 - 4)) - | ((in[4 + inpos] & 33554431) << 4) - | ((in[5 + inpos]) << 29) - ; - out[4 + outpos] = ((in[5 + inpos] & 33554431) >>> (25 - 22)) - | ((in[6 + inpos]) << 22) - ; - out[5 + outpos] = ((in[6 + inpos] & 33554431) >>> (25 - 15)) - | ((in[7 + inpos]) << 15) - ; - out[6 + outpos] = ((in[7 + inpos] & 33554431) >>> (25 - 8)) - | ((in[8 + inpos]) << 8) - ; - out[7 + outpos] = ((in[8 + inpos] & 33554431) >>> (25 - 1)) - | ((in[9 + inpos] & 33554431) << 1) - | ((in[10 + inpos]) << 26) - ; - out[8 + outpos] = ((in[10 + inpos] & 33554431) >>> (25 - 19)) - | ((in[11 + inpos]) << 19) - ; - out[9 + outpos] = ((in[11 + inpos] & 33554431) >>> (25 - 12)) - | ((in[12 + inpos]) << 12) - ; - out[10 + outpos] = ((in[12 + inpos] & 33554431) >>> (25 - 5)) - | ((in[13 + inpos] & 33554431) << 5) - | ((in[14 + inpos]) << 30) - ; - out[11 + outpos] = ((in[14 + inpos] & 33554431) >>> (25 - 23)) - | ((in[15 + inpos]) << 23) - ; - out[12 + outpos] = ((in[15 + inpos] & 33554431) >>> (25 - 16)) - | ((in[16 + inpos]) << 16) - ; - out[13 + outpos] = ((in[16 + inpos] & 33554431) >>> (25 - 9)) - | ((in[17 + inpos]) << 9) - ; - out[14 + outpos] = ((in[17 + inpos] & 33554431) >>> (25 - 2)) - | ((in[18 + inpos] & 33554431) << 2) - | ((in[19 + inpos]) << 27) - ; - out[15 + outpos] = ((in[19 + inpos] & 33554431) >>> (25 - 20)) - | ((in[20 + inpos]) << 20) - ; - out[16 + outpos] = ((in[20 + inpos] & 33554431) >>> (25 - 13)) - | ((in[21 + inpos]) << 13) - ; - out[17 + outpos] = ((in[21 + inpos] & 33554431) >>> (25 - 6)) - | ((in[22 + inpos] & 33554431) << 6) - | ((in[23 + inpos]) << 31) - ; - out[18 + outpos] = ((in[23 + inpos] & 33554431) >>> (25 - 24)) - | ((in[24 + inpos]) << 24) - ; - out[19 + outpos] = ((in[24 + inpos] & 33554431) >>> (25 - 17)) - | ((in[25 + inpos]) << 17) - ; - out[20 + outpos] = ((in[25 + inpos] & 33554431) >>> (25 - 10)) - | ((in[26 + inpos]) << 10) - ; - out[21 + outpos] = ((in[26 + inpos] & 33554431) >>> (25 - 3)) - | ((in[27 + inpos] & 33554431) << 3) - | ((in[28 + inpos]) << 28) - ; - out[22 + outpos] = ((in[28 + inpos] & 33554431) >>> (25 - 21)) - | ((in[29 + inpos]) << 21) - ; - out[23 + outpos] = ((in[29 + inpos] & 33554431) >>> (25 - 14)) - | ((in[30 + inpos]) << 14) - ; - out[24 + outpos] = ((in[30 + inpos] & 33554431) >>> (25 - 7)) - | ((in[31 + inpos]) << 7) - ; - } + protected static void fastpack16(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = (in[0 + inpos] & 65535) + | ((in[1 + inpos]) << 16); + out[1 + outpos] = (in[2 + inpos] & 65535) + | ((in[3 + inpos]) << 16); + out[2 + outpos] = (in[4 + inpos] & 65535) + | ((in[5 + inpos]) << 16); + out[3 + outpos] = (in[6 + inpos] & 65535) + | ((in[7 + inpos]) << 16); + out[4 + outpos] = (in[8 + inpos] & 65535) + | ((in[9 + inpos]) << 16); + out[5 + outpos] = (in[10 + inpos] & 65535) + | ((in[11 + inpos]) << 16); + out[6 + outpos] = (in[12 + inpos] & 65535) + | ((in[13 + inpos]) << 16); + out[7 + outpos] = (in[14 + inpos] & 65535) + | ((in[15 + inpos]) << 16); + out[8 + outpos] = (in[16 + inpos] & 65535) + | ((in[17 + inpos]) << 16); + out[9 + outpos] = (in[18 + inpos] & 65535) + | ((in[19 + inpos]) << 16); + out[10 + outpos] = (in[20 + inpos] & 65535) + | ((in[21 + inpos]) << 16); + out[11 + outpos] = (in[22 + inpos] & 65535) + | ((in[23 + inpos]) << 16); + out[12 + outpos] = (in[24 + inpos] & 65535) + | ((in[25 + inpos]) << 16); + out[13 + outpos] = (in[26 + inpos] & 65535) + | ((in[27 + inpos]) << 16); + out[14 + outpos] = (in[28 + inpos] & 65535) + | ((in[29 + inpos]) << 16); + out[15 + outpos] = (in[30 + inpos] & 65535) + | ((in[31 + inpos]) << 16); + } + protected static void fastpack17(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = (in[0 + inpos] & 131071) + | ((in[1 + inpos]) << 17); + out[1 + outpos] = ((in[1 + inpos] & 131071) >>> (17 - 2)) + | ((in[2 + inpos] & 131071) << 2) + | ((in[3 + inpos]) << 19); + out[2 + outpos] = ((in[3 + inpos] & 131071) >>> (17 - 4)) + | ((in[4 + inpos] & 131071) << 4) + | ((in[5 + inpos]) << 21); + out[3 + outpos] = ((in[5 + inpos] & 131071) >>> (17 - 6)) + | ((in[6 + inpos] & 131071) << 6) + | ((in[7 + inpos]) << 23); + out[4 + outpos] = ((in[7 + inpos] & 131071) >>> (17 - 8)) + | ((in[8 + inpos] & 131071) << 8) + | ((in[9 + inpos]) << 25); + out[5 + outpos] = ((in[9 + inpos] & 131071) >>> (17 - 10)) + | ((in[10 + inpos] & 131071) << 10) + | ((in[11 + inpos]) << 27); + out[6 + outpos] = ((in[11 + inpos] & 131071) >>> (17 - 12)) + | ((in[12 + inpos] & 131071) << 12) + | ((in[13 + inpos]) << 29); + out[7 + outpos] = ((in[13 + inpos] & 131071) >>> (17 - 14)) + | ((in[14 + inpos] & 131071) << 14) + | ((in[15 + inpos]) << 31); + out[8 + outpos] = ((in[15 + inpos] & 131071) >>> (17 - 16)) + | ((in[16 + inpos]) << 16); + out[9 + outpos] = ((in[16 + inpos] & 131071) >>> (17 - 1)) + | ((in[17 + inpos] & 131071) << 1) + | ((in[18 + inpos]) << 18); + out[10 + outpos] = ((in[18 + inpos] & 131071) >>> (17 - 3)) + | ((in[19 + inpos] & 131071) << 3) + | ((in[20 + inpos]) << 20); + out[11 + outpos] = ((in[20 + inpos] & 131071) >>> (17 - 5)) + | ((in[21 + inpos] & 131071) << 5) + | ((in[22 + inpos]) << 22); + out[12 + outpos] = ((in[22 + inpos] & 131071) >>> (17 - 7)) + | ((in[23 + inpos] & 131071) << 7) + | ((in[24 + inpos]) << 24); + out[13 + outpos] = ((in[24 + inpos] & 131071) >>> (17 - 9)) + | ((in[25 + inpos] & 131071) << 9) + | ((in[26 + inpos]) << 26); + out[14 + outpos] = ((in[26 + inpos] & 131071) >>> (17 - 11)) + | ((in[27 + inpos] & 131071) << 11) + | ((in[28 + inpos]) << 28); + out[15 + outpos] = ((in[28 + inpos] & 131071) >>> (17 - 13)) + | ((in[29 + inpos] & 131071) << 13) + | ((in[30 + inpos]) << 30); + out[16 + outpos] = ((in[30 + inpos] & 131071) >>> (17 - 15)) + | ((in[31 + inpos]) << 15); + } - protected static void fastpack26(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (in[0 + inpos] & 67108863) - | ((in[1 + inpos]) << 26) - ; - out[1 + outpos] = ((in[1 + inpos] & 67108863) >>> (26 - 20)) - | ((in[2 + inpos]) << 20) - ; - out[2 + outpos] = ((in[2 + inpos] & 67108863) >>> (26 - 14)) - | ((in[3 + inpos]) << 14) - ; - out[3 + outpos] = ((in[3 + inpos] & 67108863) >>> (26 - 8)) - | ((in[4 + inpos]) << 8) - ; - out[4 + outpos] = ((in[4 + inpos] & 67108863) >>> (26 - 2)) - | ((in[5 + inpos] & 67108863) << 2) - | ((in[6 + inpos]) << 28) - ; - out[5 + outpos] = ((in[6 + inpos] & 67108863) >>> (26 - 22)) - | ((in[7 + inpos]) << 22) - ; - out[6 + outpos] = ((in[7 + inpos] & 67108863) >>> (26 - 16)) - | ((in[8 + inpos]) << 16) - ; - out[7 + outpos] = ((in[8 + inpos] & 67108863) >>> (26 - 10)) - | ((in[9 + inpos]) << 10) - ; - out[8 + outpos] = ((in[9 + inpos] & 67108863) >>> (26 - 4)) - | ((in[10 + inpos] & 67108863) << 4) - | ((in[11 + inpos]) << 30) - ; - out[9 + outpos] = ((in[11 + inpos] & 67108863) >>> (26 - 24)) - | ((in[12 + inpos]) << 24) - ; - out[10 + outpos] = ((in[12 + inpos] & 67108863) >>> (26 - 18)) - | ((in[13 + inpos]) << 18) - ; - out[11 + outpos] = ((in[13 + inpos] & 67108863) >>> (26 - 12)) - | ((in[14 + inpos]) << 12) - ; - out[12 + outpos] = ((in[14 + inpos] & 67108863) >>> (26 - 6)) - | ((in[15 + inpos]) << 6) - ; - out[13 + outpos] = (in[16 + inpos] & 67108863) - | ((in[17 + inpos]) << 26) - ; - out[14 + outpos] = ((in[17 + inpos] & 67108863) >>> (26 - 20)) - | ((in[18 + inpos]) << 20) - ; - out[15 + outpos] = ((in[18 + inpos] & 67108863) >>> (26 - 14)) - | ((in[19 + inpos]) << 14) - ; - out[16 + outpos] = ((in[19 + inpos] & 67108863) >>> (26 - 8)) - | ((in[20 + inpos]) << 8) - ; - out[17 + outpos] = ((in[20 + inpos] & 67108863) >>> (26 - 2)) - | ((in[21 + inpos] & 67108863) << 2) - | ((in[22 + inpos]) << 28) - ; - out[18 + outpos] = ((in[22 + inpos] & 67108863) >>> (26 - 22)) - | ((in[23 + inpos]) << 22) - ; - out[19 + outpos] = ((in[23 + inpos] & 67108863) >>> (26 - 16)) - | ((in[24 + inpos]) << 16) - ; - out[20 + outpos] = ((in[24 + inpos] & 67108863) >>> (26 - 10)) - | ((in[25 + inpos]) << 10) - ; - out[21 + outpos] = ((in[25 + inpos] & 67108863) >>> (26 - 4)) - | ((in[26 + inpos] & 67108863) << 4) - | ((in[27 + inpos]) << 30) - ; - out[22 + outpos] = ((in[27 + inpos] & 67108863) >>> (26 - 24)) - | ((in[28 + inpos]) << 24) - ; - out[23 + outpos] = ((in[28 + inpos] & 67108863) >>> (26 - 18)) - | ((in[29 + inpos]) << 18) - ; - out[24 + outpos] = ((in[29 + inpos] & 67108863) >>> (26 - 12)) - | ((in[30 + inpos]) << 12) - ; - out[25 + outpos] = ((in[30 + inpos] & 67108863) >>> (26 - 6)) - | ((in[31 + inpos]) << 6) - ; - } + protected static void fastpack18(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = (in[0 + inpos] & 262143) + | ((in[1 + inpos]) << 18); + out[1 + outpos] = ((in[1 + inpos] & 262143) >>> (18 - 4)) + | ((in[2 + inpos] & 262143) << 4) + | ((in[3 + inpos]) << 22); + out[2 + outpos] = ((in[3 + inpos] & 262143) >>> (18 - 8)) + | ((in[4 + inpos] & 262143) << 8) + | ((in[5 + inpos]) << 26); + out[3 + outpos] = ((in[5 + inpos] & 262143) >>> (18 - 12)) + | ((in[6 + inpos] & 262143) << 12) + | ((in[7 + inpos]) << 30); + out[4 + outpos] = ((in[7 + inpos] & 262143) >>> (18 - 16)) + | ((in[8 + inpos]) << 16); + out[5 + outpos] = ((in[8 + inpos] & 262143) >>> (18 - 2)) + | ((in[9 + inpos] & 262143) << 2) + | ((in[10 + inpos]) << 20); + out[6 + outpos] = ((in[10 + inpos] & 262143) >>> (18 - 6)) + | ((in[11 + inpos] & 262143) << 6) + | ((in[12 + inpos]) << 24); + out[7 + outpos] = ((in[12 + inpos] & 262143) >>> (18 - 10)) + | ((in[13 + inpos] & 262143) << 10) + | ((in[14 + inpos]) << 28); + out[8 + outpos] = ((in[14 + inpos] & 262143) >>> (18 - 14)) + | ((in[15 + inpos]) << 14); + out[9 + outpos] = (in[16 + inpos] & 262143) + | ((in[17 + inpos]) << 18); + out[10 + outpos] = ((in[17 + inpos] & 262143) >>> (18 - 4)) + | ((in[18 + inpos] & 262143) << 4) + | ((in[19 + inpos]) << 22); + out[11 + outpos] = ((in[19 + inpos] & 262143) >>> (18 - 8)) + | ((in[20 + inpos] & 262143) << 8) + | ((in[21 + inpos]) << 26); + out[12 + outpos] = ((in[21 + inpos] & 262143) >>> (18 - 12)) + | ((in[22 + inpos] & 262143) << 12) + | ((in[23 + inpos]) << 30); + out[13 + outpos] = ((in[23 + inpos] & 262143) >>> (18 - 16)) + | ((in[24 + inpos]) << 16); + out[14 + outpos] = ((in[24 + inpos] & 262143) >>> (18 - 2)) + | ((in[25 + inpos] & 262143) << 2) + | ((in[26 + inpos]) << 20); + out[15 + outpos] = ((in[26 + inpos] & 262143) >>> (18 - 6)) + | ((in[27 + inpos] & 262143) << 6) + | ((in[28 + inpos]) << 24); + out[16 + outpos] = ((in[28 + inpos] & 262143) >>> (18 - 10)) + | ((in[29 + inpos] & 262143) << 10) + | ((in[30 + inpos]) << 28); + out[17 + outpos] = ((in[30 + inpos] & 262143) >>> (18 - 14)) + | ((in[31 + inpos]) << 14); + } + protected static void fastpack19(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = (in[0 + inpos] & 524287) + | ((in[1 + inpos]) << 19); + out[1 + outpos] = ((in[1 + inpos] & 524287) >>> (19 - 6)) + | ((in[2 + inpos] & 524287) << 6) + | ((in[3 + inpos]) << 25); + out[2 + outpos] = ((in[3 + inpos] & 524287) >>> (19 - 12)) + | ((in[4 + inpos] & 524287) << 12) + | ((in[5 + inpos]) << 31); + out[3 + outpos] = ((in[5 + inpos] & 524287) >>> (19 - 18)) + | ((in[6 + inpos]) << 18); + out[4 + outpos] = ((in[6 + inpos] & 524287) >>> (19 - 5)) + | ((in[7 + inpos] & 524287) << 5) + | ((in[8 + inpos]) << 24); + out[5 + outpos] = ((in[8 + inpos] & 524287) >>> (19 - 11)) + | ((in[9 + inpos] & 524287) << 11) + | ((in[10 + inpos]) << 30); + out[6 + outpos] = ((in[10 + inpos] & 524287) >>> (19 - 17)) + | ((in[11 + inpos]) << 17); + out[7 + outpos] = ((in[11 + inpos] & 524287) >>> (19 - 4)) + | ((in[12 + inpos] & 524287) << 4) + | ((in[13 + inpos]) << 23); + out[8 + outpos] = ((in[13 + inpos] & 524287) >>> (19 - 10)) + | ((in[14 + inpos] & 524287) << 10) + | ((in[15 + inpos]) << 29); + out[9 + outpos] = ((in[15 + inpos] & 524287) >>> (19 - 16)) + | ((in[16 + inpos]) << 16); + out[10 + outpos] = ((in[16 + inpos] & 524287) >>> (19 - 3)) + | ((in[17 + inpos] & 524287) << 3) + | ((in[18 + inpos]) << 22); + out[11 + outpos] = ((in[18 + inpos] & 524287) >>> (19 - 9)) + | ((in[19 + inpos] & 524287) << 9) + | ((in[20 + inpos]) << 28); + out[12 + outpos] = ((in[20 + inpos] & 524287) >>> (19 - 15)) + | ((in[21 + inpos]) << 15); + out[13 + outpos] = ((in[21 + inpos] & 524287) >>> (19 - 2)) + | ((in[22 + inpos] & 524287) << 2) + | ((in[23 + inpos]) << 21); + out[14 + outpos] = ((in[23 + inpos] & 524287) >>> (19 - 8)) + | ((in[24 + inpos] & 524287) << 8) + | ((in[25 + inpos]) << 27); + out[15 + outpos] = ((in[25 + inpos] & 524287) >>> (19 - 14)) + | ((in[26 + inpos]) << 14); + out[16 + outpos] = ((in[26 + inpos] & 524287) >>> (19 - 1)) + | ((in[27 + inpos] & 524287) << 1) + | ((in[28 + inpos]) << 20); + out[17 + outpos] = ((in[28 + inpos] & 524287) >>> (19 - 7)) + | ((in[29 + inpos] & 524287) << 7) + | ((in[30 + inpos]) << 26); + out[18 + outpos] = ((in[30 + inpos] & 524287) >>> (19 - 13)) + | ((in[31 + inpos]) << 13); + } - protected static void fastpack27(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (in[0 + inpos] & 134217727) - | ((in[1 + inpos]) << 27) - ; - out[1 + outpos] = ((in[1 + inpos] & 134217727) >>> (27 - 22)) - | ((in[2 + inpos]) << 22) - ; - out[2 + outpos] = ((in[2 + inpos] & 134217727) >>> (27 - 17)) - | ((in[3 + inpos]) << 17) - ; - out[3 + outpos] = ((in[3 + inpos] & 134217727) >>> (27 - 12)) - | ((in[4 + inpos]) << 12) - ; - out[4 + outpos] = ((in[4 + inpos] & 134217727) >>> (27 - 7)) - | ((in[5 + inpos]) << 7) - ; - out[5 + outpos] = ((in[5 + inpos] & 134217727) >>> (27 - 2)) - | ((in[6 + inpos] & 134217727) << 2) - | ((in[7 + inpos]) << 29) - ; - out[6 + outpos] = ((in[7 + inpos] & 134217727) >>> (27 - 24)) - | ((in[8 + inpos]) << 24) - ; - out[7 + outpos] = ((in[8 + inpos] & 134217727) >>> (27 - 19)) - | ((in[9 + inpos]) << 19) - ; - out[8 + outpos] = ((in[9 + inpos] & 134217727) >>> (27 - 14)) - | ((in[10 + inpos]) << 14) - ; - out[9 + outpos] = ((in[10 + inpos] & 134217727) >>> (27 - 9)) - | ((in[11 + inpos]) << 9) - ; - out[10 + outpos] = ((in[11 + inpos] & 134217727) >>> (27 - 4)) - | ((in[12 + inpos] & 134217727) << 4) - | ((in[13 + inpos]) << 31) - ; - out[11 + outpos] = ((in[13 + inpos] & 134217727) >>> (27 - 26)) - | ((in[14 + inpos]) << 26) - ; - out[12 + outpos] = ((in[14 + inpos] & 134217727) >>> (27 - 21)) - | ((in[15 + inpos]) << 21) - ; - out[13 + outpos] = ((in[15 + inpos] & 134217727) >>> (27 - 16)) - | ((in[16 + inpos]) << 16) - ; - out[14 + outpos] = ((in[16 + inpos] & 134217727) >>> (27 - 11)) - | ((in[17 + inpos]) << 11) - ; - out[15 + outpos] = ((in[17 + inpos] & 134217727) >>> (27 - 6)) - | ((in[18 + inpos]) << 6) - ; - out[16 + outpos] = ((in[18 + inpos] & 134217727) >>> (27 - 1)) - | ((in[19 + inpos] & 134217727) << 1) - | ((in[20 + inpos]) << 28) - ; - out[17 + outpos] = ((in[20 + inpos] & 134217727) >>> (27 - 23)) - | ((in[21 + inpos]) << 23) - ; - out[18 + outpos] = ((in[21 + inpos] & 134217727) >>> (27 - 18)) - | ((in[22 + inpos]) << 18) - ; - out[19 + outpos] = ((in[22 + inpos] & 134217727) >>> (27 - 13)) - | ((in[23 + inpos]) << 13) - ; - out[20 + outpos] = ((in[23 + inpos] & 134217727) >>> (27 - 8)) - | ((in[24 + inpos]) << 8) - ; - out[21 + outpos] = ((in[24 + inpos] & 134217727) >>> (27 - 3)) - | ((in[25 + inpos] & 134217727) << 3) - | ((in[26 + inpos]) << 30) - ; - out[22 + outpos] = ((in[26 + inpos] & 134217727) >>> (27 - 25)) - | ((in[27 + inpos]) << 25) - ; - out[23 + outpos] = ((in[27 + inpos] & 134217727) >>> (27 - 20)) - | ((in[28 + inpos]) << 20) - ; - out[24 + outpos] = ((in[28 + inpos] & 134217727) >>> (27 - 15)) - | ((in[29 + inpos]) << 15) - ; - out[25 + outpos] = ((in[29 + inpos] & 134217727) >>> (27 - 10)) - | ((in[30 + inpos]) << 10) - ; - out[26 + outpos] = ((in[30 + inpos] & 134217727) >>> (27 - 5)) - | ((in[31 + inpos]) << 5) - ; - } + protected static void fastpack2(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = (in[0 + inpos] & 3) + | ((in[1 + inpos] & 3) << 2) + | ((in[2 + inpos] & 3) << 4) + | ((in[3 + inpos] & 3) << 6) + | ((in[4 + inpos] & 3) << 8) + | ((in[5 + inpos] & 3) << 10) + | ((in[6 + inpos] & 3) << 12) + | ((in[7 + inpos] & 3) << 14) + | ((in[8 + inpos] & 3) << 16) + | ((in[9 + inpos] & 3) << 18) + | ((in[10 + inpos] & 3) << 20) + | ((in[11 + inpos] & 3) << 22) + | ((in[12 + inpos] & 3) << 24) + | ((in[13 + inpos] & 3) << 26) + | ((in[14 + inpos] & 3) << 28) + | ((in[15 + inpos]) << 30); + out[1 + outpos] = (in[16 + inpos] & 3) + | ((in[17 + inpos] & 3) << 2) + | ((in[18 + inpos] & 3) << 4) + | ((in[19 + inpos] & 3) << 6) + | ((in[20 + inpos] & 3) << 8) + | ((in[21 + inpos] & 3) << 10) + | ((in[22 + inpos] & 3) << 12) + | ((in[23 + inpos] & 3) << 14) + | ((in[24 + inpos] & 3) << 16) + | ((in[25 + inpos] & 3) << 18) + | ((in[26 + inpos] & 3) << 20) + | ((in[27 + inpos] & 3) << 22) + | ((in[28 + inpos] & 3) << 24) + | ((in[29 + inpos] & 3) << 26) + | ((in[30 + inpos] & 3) << 28) + | ((in[31 + inpos]) << 30); + } + protected static void fastpack20(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = (in[0 + inpos] & 1048575) + | ((in[1 + inpos]) << 20); + out[1 + outpos] = ((in[1 + inpos] & 1048575) >>> (20 - 8)) + | ((in[2 + inpos] & 1048575) << 8) + | ((in[3 + inpos]) << 28); + out[2 + outpos] = ((in[3 + inpos] & 1048575) >>> (20 - 16)) + | ((in[4 + inpos]) << 16); + out[3 + outpos] = ((in[4 + inpos] & 1048575) >>> (20 - 4)) + | ((in[5 + inpos] & 1048575) << 4) + | ((in[6 + inpos]) << 24); + out[4 + outpos] = ((in[6 + inpos] & 1048575) >>> (20 - 12)) + | ((in[7 + inpos]) << 12); + out[5 + outpos] = (in[8 + inpos] & 1048575) + | ((in[9 + inpos]) << 20); + out[6 + outpos] = ((in[9 + inpos] & 1048575) >>> (20 - 8)) + | ((in[10 + inpos] & 1048575) << 8) + | ((in[11 + inpos]) << 28); + out[7 + outpos] = ((in[11 + inpos] & 1048575) >>> (20 - 16)) + | ((in[12 + inpos]) << 16); + out[8 + outpos] = ((in[12 + inpos] & 1048575) >>> (20 - 4)) + | ((in[13 + inpos] & 1048575) << 4) + | ((in[14 + inpos]) << 24); + out[9 + outpos] = ((in[14 + inpos] & 1048575) >>> (20 - 12)) + | ((in[15 + inpos]) << 12); + out[10 + outpos] = (in[16 + inpos] & 1048575) + | ((in[17 + inpos]) << 20); + out[11 + outpos] = ((in[17 + inpos] & 1048575) >>> (20 - 8)) + | ((in[18 + inpos] & 1048575) << 8) + | ((in[19 + inpos]) << 28); + out[12 + outpos] = ((in[19 + inpos] & 1048575) >>> (20 - 16)) + | ((in[20 + inpos]) << 16); + out[13 + outpos] = ((in[20 + inpos] & 1048575) >>> (20 - 4)) + | ((in[21 + inpos] & 1048575) << 4) + | ((in[22 + inpos]) << 24); + out[14 + outpos] = ((in[22 + inpos] & 1048575) >>> (20 - 12)) + | ((in[23 + inpos]) << 12); + out[15 + outpos] = (in[24 + inpos] & 1048575) + | ((in[25 + inpos]) << 20); + out[16 + outpos] = ((in[25 + inpos] & 1048575) >>> (20 - 8)) + | ((in[26 + inpos] & 1048575) << 8) + | ((in[27 + inpos]) << 28); + out[17 + outpos] = ((in[27 + inpos] & 1048575) >>> (20 - 16)) + | ((in[28 + inpos]) << 16); + out[18 + outpos] = ((in[28 + inpos] & 1048575) >>> (20 - 4)) + | ((in[29 + inpos] & 1048575) << 4) + | ((in[30 + inpos]) << 24); + out[19 + outpos] = ((in[30 + inpos] & 1048575) >>> (20 - 12)) + | ((in[31 + inpos]) << 12); + } - protected static void fastpack28(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (in[0 + inpos] & 268435455) - | ((in[1 + inpos]) << 28) - ; - out[1 + outpos] = ((in[1 + inpos] & 268435455) >>> (28 - 24)) - | ((in[2 + inpos]) << 24) - ; - out[2 + outpos] = ((in[2 + inpos] & 268435455) >>> (28 - 20)) - | ((in[3 + inpos]) << 20) - ; - out[3 + outpos] = ((in[3 + inpos] & 268435455) >>> (28 - 16)) - | ((in[4 + inpos]) << 16) - ; - out[4 + outpos] = ((in[4 + inpos] & 268435455) >>> (28 - 12)) - | ((in[5 + inpos]) << 12) - ; - out[5 + outpos] = ((in[5 + inpos] & 268435455) >>> (28 - 8)) - | ((in[6 + inpos]) << 8) - ; - out[6 + outpos] = ((in[6 + inpos] & 268435455) >>> (28 - 4)) - | ((in[7 + inpos]) << 4) - ; - out[7 + outpos] = (in[8 + inpos] & 268435455) - | ((in[9 + inpos]) << 28) - ; - out[8 + outpos] = ((in[9 + inpos] & 268435455) >>> (28 - 24)) - | ((in[10 + inpos]) << 24) - ; - out[9 + outpos] = ((in[10 + inpos] & 268435455) >>> (28 - 20)) - | ((in[11 + inpos]) << 20) - ; - out[10 + outpos] = ((in[11 + inpos] & 268435455) >>> (28 - 16)) - | ((in[12 + inpos]) << 16) - ; - out[11 + outpos] = ((in[12 + inpos] & 268435455) >>> (28 - 12)) - | ((in[13 + inpos]) << 12) - ; - out[12 + outpos] = ((in[13 + inpos] & 268435455) >>> (28 - 8)) - | ((in[14 + inpos]) << 8) - ; - out[13 + outpos] = ((in[14 + inpos] & 268435455) >>> (28 - 4)) - | ((in[15 + inpos]) << 4) - ; - out[14 + outpos] = (in[16 + inpos] & 268435455) - | ((in[17 + inpos]) << 28) - ; - out[15 + outpos] = ((in[17 + inpos] & 268435455) >>> (28 - 24)) - | ((in[18 + inpos]) << 24) - ; - out[16 + outpos] = ((in[18 + inpos] & 268435455) >>> (28 - 20)) - | ((in[19 + inpos]) << 20) - ; - out[17 + outpos] = ((in[19 + inpos] & 268435455) >>> (28 - 16)) - | ((in[20 + inpos]) << 16) - ; - out[18 + outpos] = ((in[20 + inpos] & 268435455) >>> (28 - 12)) - | ((in[21 + inpos]) << 12) - ; - out[19 + outpos] = ((in[21 + inpos] & 268435455) >>> (28 - 8)) - | ((in[22 + inpos]) << 8) - ; - out[20 + outpos] = ((in[22 + inpos] & 268435455) >>> (28 - 4)) - | ((in[23 + inpos]) << 4) - ; - out[21 + outpos] = (in[24 + inpos] & 268435455) - | ((in[25 + inpos]) << 28) - ; - out[22 + outpos] = ((in[25 + inpos] & 268435455) >>> (28 - 24)) - | ((in[26 + inpos]) << 24) - ; - out[23 + outpos] = ((in[26 + inpos] & 268435455) >>> (28 - 20)) - | ((in[27 + inpos]) << 20) - ; - out[24 + outpos] = ((in[27 + inpos] & 268435455) >>> (28 - 16)) - | ((in[28 + inpos]) << 16) - ; - out[25 + outpos] = ((in[28 + inpos] & 268435455) >>> (28 - 12)) - | ((in[29 + inpos]) << 12) - ; - out[26 + outpos] = ((in[29 + inpos] & 268435455) >>> (28 - 8)) - | ((in[30 + inpos]) << 8) - ; - out[27 + outpos] = ((in[30 + inpos] & 268435455) >>> (28 - 4)) - | ((in[31 + inpos]) << 4) - ; - } + protected static void fastpack21(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = (in[0 + inpos] & 2097151) + | ((in[1 + inpos]) << 21); + out[1 + outpos] = ((in[1 + inpos] & 2097151) >>> (21 - 10)) + | ((in[2 + inpos] & 2097151) << 10) + | ((in[3 + inpos]) << 31); + out[2 + outpos] = ((in[3 + inpos] & 2097151) >>> (21 - 20)) + | ((in[4 + inpos]) << 20); + out[3 + outpos] = ((in[4 + inpos] & 2097151) >>> (21 - 9)) + | ((in[5 + inpos] & 2097151) << 9) + | ((in[6 + inpos]) << 30); + out[4 + outpos] = ((in[6 + inpos] & 2097151) >>> (21 - 19)) + | ((in[7 + inpos]) << 19); + out[5 + outpos] = ((in[7 + inpos] & 2097151) >>> (21 - 8)) + | ((in[8 + inpos] & 2097151) << 8) + | ((in[9 + inpos]) << 29); + out[6 + outpos] = ((in[9 + inpos] & 2097151) >>> (21 - 18)) + | ((in[10 + inpos]) << 18); + out[7 + outpos] = ((in[10 + inpos] & 2097151) >>> (21 - 7)) + | ((in[11 + inpos] & 2097151) << 7) + | ((in[12 + inpos]) << 28); + out[8 + outpos] = ((in[12 + inpos] & 2097151) >>> (21 - 17)) + | ((in[13 + inpos]) << 17); + out[9 + outpos] = ((in[13 + inpos] & 2097151) >>> (21 - 6)) + | ((in[14 + inpos] & 2097151) << 6) + | ((in[15 + inpos]) << 27); + out[10 + outpos] = ((in[15 + inpos] & 2097151) >>> (21 - 16)) + | ((in[16 + inpos]) << 16); + out[11 + outpos] = ((in[16 + inpos] & 2097151) >>> (21 - 5)) + | ((in[17 + inpos] & 2097151) << 5) + | ((in[18 + inpos]) << 26); + out[12 + outpos] = ((in[18 + inpos] & 2097151) >>> (21 - 15)) + | ((in[19 + inpos]) << 15); + out[13 + outpos] = ((in[19 + inpos] & 2097151) >>> (21 - 4)) + | ((in[20 + inpos] & 2097151) << 4) + | ((in[21 + inpos]) << 25); + out[14 + outpos] = ((in[21 + inpos] & 2097151) >>> (21 - 14)) + | ((in[22 + inpos]) << 14); + out[15 + outpos] = ((in[22 + inpos] & 2097151) >>> (21 - 3)) + | ((in[23 + inpos] & 2097151) << 3) + | ((in[24 + inpos]) << 24); + out[16 + outpos] = ((in[24 + inpos] & 2097151) >>> (21 - 13)) + | ((in[25 + inpos]) << 13); + out[17 + outpos] = ((in[25 + inpos] & 2097151) >>> (21 - 2)) + | ((in[26 + inpos] & 2097151) << 2) + | ((in[27 + inpos]) << 23); + out[18 + outpos] = ((in[27 + inpos] & 2097151) >>> (21 - 12)) + | ((in[28 + inpos]) << 12); + out[19 + outpos] = ((in[28 + inpos] & 2097151) >>> (21 - 1)) + | ((in[29 + inpos] & 2097151) << 1) + | ((in[30 + inpos]) << 22); + out[20 + outpos] = ((in[30 + inpos] & 2097151) >>> (21 - 11)) + | ((in[31 + inpos]) << 11); + } + protected static void fastpack22(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = (in[0 + inpos] & 4194303) + | ((in[1 + inpos]) << 22); + out[1 + outpos] = ((in[1 + inpos] & 4194303) >>> (22 - 12)) + | ((in[2 + inpos]) << 12); + out[2 + outpos] = ((in[2 + inpos] & 4194303) >>> (22 - 2)) + | ((in[3 + inpos] & 4194303) << 2) + | ((in[4 + inpos]) << 24); + out[3 + outpos] = ((in[4 + inpos] & 4194303) >>> (22 - 14)) + | ((in[5 + inpos]) << 14); + out[4 + outpos] = ((in[5 + inpos] & 4194303) >>> (22 - 4)) + | ((in[6 + inpos] & 4194303) << 4) + | ((in[7 + inpos]) << 26); + out[5 + outpos] = ((in[7 + inpos] & 4194303) >>> (22 - 16)) + | ((in[8 + inpos]) << 16); + out[6 + outpos] = ((in[8 + inpos] & 4194303) >>> (22 - 6)) + | ((in[9 + inpos] & 4194303) << 6) + | ((in[10 + inpos]) << 28); + out[7 + outpos] = ((in[10 + inpos] & 4194303) >>> (22 - 18)) + | ((in[11 + inpos]) << 18); + out[8 + outpos] = ((in[11 + inpos] & 4194303) >>> (22 - 8)) + | ((in[12 + inpos] & 4194303) << 8) + | ((in[13 + inpos]) << 30); + out[9 + outpos] = ((in[13 + inpos] & 4194303) >>> (22 - 20)) + | ((in[14 + inpos]) << 20); + out[10 + outpos] = ((in[14 + inpos] & 4194303) >>> (22 - 10)) + | ((in[15 + inpos]) << 10); + out[11 + outpos] = (in[16 + inpos] & 4194303) + | ((in[17 + inpos]) << 22); + out[12 + outpos] = ((in[17 + inpos] & 4194303) >>> (22 - 12)) + | ((in[18 + inpos]) << 12); + out[13 + outpos] = ((in[18 + inpos] & 4194303) >>> (22 - 2)) + | ((in[19 + inpos] & 4194303) << 2) + | ((in[20 + inpos]) << 24); + out[14 + outpos] = ((in[20 + inpos] & 4194303) >>> (22 - 14)) + | ((in[21 + inpos]) << 14); + out[15 + outpos] = ((in[21 + inpos] & 4194303) >>> (22 - 4)) + | ((in[22 + inpos] & 4194303) << 4) + | ((in[23 + inpos]) << 26); + out[16 + outpos] = ((in[23 + inpos] & 4194303) >>> (22 - 16)) + | ((in[24 + inpos]) << 16); + out[17 + outpos] = ((in[24 + inpos] & 4194303) >>> (22 - 6)) + | ((in[25 + inpos] & 4194303) << 6) + | ((in[26 + inpos]) << 28); + out[18 + outpos] = ((in[26 + inpos] & 4194303) >>> (22 - 18)) + | ((in[27 + inpos]) << 18); + out[19 + outpos] = ((in[27 + inpos] & 4194303) >>> (22 - 8)) + | ((in[28 + inpos] & 4194303) << 8) + | ((in[29 + inpos]) << 30); + out[20 + outpos] = ((in[29 + inpos] & 4194303) >>> (22 - 20)) + | ((in[30 + inpos]) << 20); + out[21 + outpos] = ((in[30 + inpos] & 4194303) >>> (22 - 10)) + | ((in[31 + inpos]) << 10); + } - protected static void fastpack29(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (in[0 + inpos] & 536870911) - | ((in[1 + inpos]) << 29) - ; - out[1 + outpos] = ((in[1 + inpos] & 536870911) >>> (29 - 26)) - | ((in[2 + inpos]) << 26) - ; - out[2 + outpos] = ((in[2 + inpos] & 536870911) >>> (29 - 23)) - | ((in[3 + inpos]) << 23) - ; - out[3 + outpos] = ((in[3 + inpos] & 536870911) >>> (29 - 20)) - | ((in[4 + inpos]) << 20) - ; - out[4 + outpos] = ((in[4 + inpos] & 536870911) >>> (29 - 17)) - | ((in[5 + inpos]) << 17) - ; - out[5 + outpos] = ((in[5 + inpos] & 536870911) >>> (29 - 14)) - | ((in[6 + inpos]) << 14) - ; - out[6 + outpos] = ((in[6 + inpos] & 536870911) >>> (29 - 11)) - | ((in[7 + inpos]) << 11) - ; - out[7 + outpos] = ((in[7 + inpos] & 536870911) >>> (29 - 8)) - | ((in[8 + inpos]) << 8) - ; - out[8 + outpos] = ((in[8 + inpos] & 536870911) >>> (29 - 5)) - | ((in[9 + inpos]) << 5) - ; - out[9 + outpos] = ((in[9 + inpos] & 536870911) >>> (29 - 2)) - | ((in[10 + inpos] & 536870911) << 2) - | ((in[11 + inpos]) << 31) - ; - out[10 + outpos] = ((in[11 + inpos] & 536870911) >>> (29 - 28)) - | ((in[12 + inpos]) << 28) - ; - out[11 + outpos] = ((in[12 + inpos] & 536870911) >>> (29 - 25)) - | ((in[13 + inpos]) << 25) - ; - out[12 + outpos] = ((in[13 + inpos] & 536870911) >>> (29 - 22)) - | ((in[14 + inpos]) << 22) - ; - out[13 + outpos] = ((in[14 + inpos] & 536870911) >>> (29 - 19)) - | ((in[15 + inpos]) << 19) - ; - out[14 + outpos] = ((in[15 + inpos] & 536870911) >>> (29 - 16)) - | ((in[16 + inpos]) << 16) - ; - out[15 + outpos] = ((in[16 + inpos] & 536870911) >>> (29 - 13)) - | ((in[17 + inpos]) << 13) - ; - out[16 + outpos] = ((in[17 + inpos] & 536870911) >>> (29 - 10)) - | ((in[18 + inpos]) << 10) - ; - out[17 + outpos] = ((in[18 + inpos] & 536870911) >>> (29 - 7)) - | ((in[19 + inpos]) << 7) - ; - out[18 + outpos] = ((in[19 + inpos] & 536870911) >>> (29 - 4)) - | ((in[20 + inpos]) << 4) - ; - out[19 + outpos] = ((in[20 + inpos] & 536870911) >>> (29 - 1)) - | ((in[21 + inpos] & 536870911) << 1) - | ((in[22 + inpos]) << 30) - ; - out[20 + outpos] = ((in[22 + inpos] & 536870911) >>> (29 - 27)) - | ((in[23 + inpos]) << 27) - ; - out[21 + outpos] = ((in[23 + inpos] & 536870911) >>> (29 - 24)) - | ((in[24 + inpos]) << 24) - ; - out[22 + outpos] = ((in[24 + inpos] & 536870911) >>> (29 - 21)) - | ((in[25 + inpos]) << 21) - ; - out[23 + outpos] = ((in[25 + inpos] & 536870911) >>> (29 - 18)) - | ((in[26 + inpos]) << 18) - ; - out[24 + outpos] = ((in[26 + inpos] & 536870911) >>> (29 - 15)) - | ((in[27 + inpos]) << 15) - ; - out[25 + outpos] = ((in[27 + inpos] & 536870911) >>> (29 - 12)) - | ((in[28 + inpos]) << 12) - ; - out[26 + outpos] = ((in[28 + inpos] & 536870911) >>> (29 - 9)) - | ((in[29 + inpos]) << 9) - ; - out[27 + outpos] = ((in[29 + inpos] & 536870911) >>> (29 - 6)) - | ((in[30 + inpos]) << 6) - ; - out[28 + outpos] = ((in[30 + inpos] & 536870911) >>> (29 - 3)) - | ((in[31 + inpos]) << 3) - ; - } + protected static void fastpack23(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = (in[0 + inpos] & 8388607) + | ((in[1 + inpos]) << 23); + out[1 + outpos] = ((in[1 + inpos] & 8388607) >>> (23 - 14)) + | ((in[2 + inpos]) << 14); + out[2 + outpos] = ((in[2 + inpos] & 8388607) >>> (23 - 5)) + | ((in[3 + inpos] & 8388607) << 5) + | ((in[4 + inpos]) << 28); + out[3 + outpos] = ((in[4 + inpos] & 8388607) >>> (23 - 19)) + | ((in[5 + inpos]) << 19); + out[4 + outpos] = ((in[5 + inpos] & 8388607) >>> (23 - 10)) + | ((in[6 + inpos]) << 10); + out[5 + outpos] = ((in[6 + inpos] & 8388607) >>> (23 - 1)) + | ((in[7 + inpos] & 8388607) << 1) + | ((in[8 + inpos]) << 24); + out[6 + outpos] = ((in[8 + inpos] & 8388607) >>> (23 - 15)) + | ((in[9 + inpos]) << 15); + out[7 + outpos] = ((in[9 + inpos] & 8388607) >>> (23 - 6)) + | ((in[10 + inpos] & 8388607) << 6) + | ((in[11 + inpos]) << 29); + out[8 + outpos] = ((in[11 + inpos] & 8388607) >>> (23 - 20)) + | ((in[12 + inpos]) << 20); + out[9 + outpos] = ((in[12 + inpos] & 8388607) >>> (23 - 11)) + | ((in[13 + inpos]) << 11); + out[10 + outpos] = ((in[13 + inpos] & 8388607) >>> (23 - 2)) + | ((in[14 + inpos] & 8388607) << 2) + | ((in[15 + inpos]) << 25); + out[11 + outpos] = ((in[15 + inpos] & 8388607) >>> (23 - 16)) + | ((in[16 + inpos]) << 16); + out[12 + outpos] = ((in[16 + inpos] & 8388607) >>> (23 - 7)) + | ((in[17 + inpos] & 8388607) << 7) + | ((in[18 + inpos]) << 30); + out[13 + outpos] = ((in[18 + inpos] & 8388607) >>> (23 - 21)) + | ((in[19 + inpos]) << 21); + out[14 + outpos] = ((in[19 + inpos] & 8388607) >>> (23 - 12)) + | ((in[20 + inpos]) << 12); + out[15 + outpos] = ((in[20 + inpos] & 8388607) >>> (23 - 3)) + | ((in[21 + inpos] & 8388607) << 3) + | ((in[22 + inpos]) << 26); + out[16 + outpos] = ((in[22 + inpos] & 8388607) >>> (23 - 17)) + | ((in[23 + inpos]) << 17); + out[17 + outpos] = ((in[23 + inpos] & 8388607) >>> (23 - 8)) + | ((in[24 + inpos] & 8388607) << 8) + | ((in[25 + inpos]) << 31); + out[18 + outpos] = ((in[25 + inpos] & 8388607) >>> (23 - 22)) + | ((in[26 + inpos]) << 22); + out[19 + outpos] = ((in[26 + inpos] & 8388607) >>> (23 - 13)) + | ((in[27 + inpos]) << 13); + out[20 + outpos] = ((in[27 + inpos] & 8388607) >>> (23 - 4)) + | ((in[28 + inpos] & 8388607) << 4) + | ((in[29 + inpos]) << 27); + out[21 + outpos] = ((in[29 + inpos] & 8388607) >>> (23 - 18)) + | ((in[30 + inpos]) << 18); + out[22 + outpos] = ((in[30 + inpos] & 8388607) >>> (23 - 9)) + | ((in[31 + inpos]) << 9); + } + protected static void fastpack24(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = (in[0 + inpos] & 16777215) + | ((in[1 + inpos]) << 24); + out[1 + outpos] = ((in[1 + inpos] & 16777215) >>> (24 - 16)) + | ((in[2 + inpos]) << 16); + out[2 + outpos] = ((in[2 + inpos] & 16777215) >>> (24 - 8)) + | ((in[3 + inpos]) << 8); + out[3 + outpos] = (in[4 + inpos] & 16777215) + | ((in[5 + inpos]) << 24); + out[4 + outpos] = ((in[5 + inpos] & 16777215) >>> (24 - 16)) + | ((in[6 + inpos]) << 16); + out[5 + outpos] = ((in[6 + inpos] & 16777215) >>> (24 - 8)) + | ((in[7 + inpos]) << 8); + out[6 + outpos] = (in[8 + inpos] & 16777215) + | ((in[9 + inpos]) << 24); + out[7 + outpos] = ((in[9 + inpos] & 16777215) >>> (24 - 16)) + | ((in[10 + inpos]) << 16); + out[8 + outpos] = ((in[10 + inpos] & 16777215) >>> (24 - 8)) + | ((in[11 + inpos]) << 8); + out[9 + outpos] = (in[12 + inpos] & 16777215) + | ((in[13 + inpos]) << 24); + out[10 + outpos] = ((in[13 + inpos] & 16777215) >>> (24 - 16)) + | ((in[14 + inpos]) << 16); + out[11 + outpos] = ((in[14 + inpos] & 16777215) >>> (24 - 8)) + | ((in[15 + inpos]) << 8); + out[12 + outpos] = (in[16 + inpos] & 16777215) + | ((in[17 + inpos]) << 24); + out[13 + outpos] = ((in[17 + inpos] & 16777215) >>> (24 - 16)) + | ((in[18 + inpos]) << 16); + out[14 + outpos] = ((in[18 + inpos] & 16777215) >>> (24 - 8)) + | ((in[19 + inpos]) << 8); + out[15 + outpos] = (in[20 + inpos] & 16777215) + | ((in[21 + inpos]) << 24); + out[16 + outpos] = ((in[21 + inpos] & 16777215) >>> (24 - 16)) + | ((in[22 + inpos]) << 16); + out[17 + outpos] = ((in[22 + inpos] & 16777215) >>> (24 - 8)) + | ((in[23 + inpos]) << 8); + out[18 + outpos] = (in[24 + inpos] & 16777215) + | ((in[25 + inpos]) << 24); + out[19 + outpos] = ((in[25 + inpos] & 16777215) >>> (24 - 16)) + | ((in[26 + inpos]) << 16); + out[20 + outpos] = ((in[26 + inpos] & 16777215) >>> (24 - 8)) + | ((in[27 + inpos]) << 8); + out[21 + outpos] = (in[28 + inpos] & 16777215) + | ((in[29 + inpos]) << 24); + out[22 + outpos] = ((in[29 + inpos] & 16777215) >>> (24 - 16)) + | ((in[30 + inpos]) << 16); + out[23 + outpos] = ((in[30 + inpos] & 16777215) >>> (24 - 8)) + | ((in[31 + inpos]) << 8); + } - protected static void fastpack30(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (in[0 + inpos] & 1073741823) - | ((in[1 + inpos]) << 30) - ; - out[1 + outpos] = ((in[1 + inpos] & 1073741823) >>> (30 - 28)) - | ((in[2 + inpos]) << 28) - ; - out[2 + outpos] = ((in[2 + inpos] & 1073741823) >>> (30 - 26)) - | ((in[3 + inpos]) << 26) - ; - out[3 + outpos] = ((in[3 + inpos] & 1073741823) >>> (30 - 24)) - | ((in[4 + inpos]) << 24) - ; - out[4 + outpos] = ((in[4 + inpos] & 1073741823) >>> (30 - 22)) - | ((in[5 + inpos]) << 22) - ; - out[5 + outpos] = ((in[5 + inpos] & 1073741823) >>> (30 - 20)) - | ((in[6 + inpos]) << 20) - ; - out[6 + outpos] = ((in[6 + inpos] & 1073741823) >>> (30 - 18)) - | ((in[7 + inpos]) << 18) - ; - out[7 + outpos] = ((in[7 + inpos] & 1073741823) >>> (30 - 16)) - | ((in[8 + inpos]) << 16) - ; - out[8 + outpos] = ((in[8 + inpos] & 1073741823) >>> (30 - 14)) - | ((in[9 + inpos]) << 14) - ; - out[9 + outpos] = ((in[9 + inpos] & 1073741823) >>> (30 - 12)) - | ((in[10 + inpos]) << 12) - ; - out[10 + outpos] = ((in[10 + inpos] & 1073741823) >>> (30 - 10)) - | ((in[11 + inpos]) << 10) - ; - out[11 + outpos] = ((in[11 + inpos] & 1073741823) >>> (30 - 8)) - | ((in[12 + inpos]) << 8) - ; - out[12 + outpos] = ((in[12 + inpos] & 1073741823) >>> (30 - 6)) - | ((in[13 + inpos]) << 6) - ; - out[13 + outpos] = ((in[13 + inpos] & 1073741823) >>> (30 - 4)) - | ((in[14 + inpos]) << 4) - ; - out[14 + outpos] = ((in[14 + inpos] & 1073741823) >>> (30 - 2)) - | ((in[15 + inpos]) << 2) - ; - out[15 + outpos] = (in[16 + inpos] & 1073741823) - | ((in[17 + inpos]) << 30) - ; - out[16 + outpos] = ((in[17 + inpos] & 1073741823) >>> (30 - 28)) - | ((in[18 + inpos]) << 28) - ; - out[17 + outpos] = ((in[18 + inpos] & 1073741823) >>> (30 - 26)) - | ((in[19 + inpos]) << 26) - ; - out[18 + outpos] = ((in[19 + inpos] & 1073741823) >>> (30 - 24)) - | ((in[20 + inpos]) << 24) - ; - out[19 + outpos] = ((in[20 + inpos] & 1073741823) >>> (30 - 22)) - | ((in[21 + inpos]) << 22) - ; - out[20 + outpos] = ((in[21 + inpos] & 1073741823) >>> (30 - 20)) - | ((in[22 + inpos]) << 20) - ; - out[21 + outpos] = ((in[22 + inpos] & 1073741823) >>> (30 - 18)) - | ((in[23 + inpos]) << 18) - ; - out[22 + outpos] = ((in[23 + inpos] & 1073741823) >>> (30 - 16)) - | ((in[24 + inpos]) << 16) - ; - out[23 + outpos] = ((in[24 + inpos] & 1073741823) >>> (30 - 14)) - | ((in[25 + inpos]) << 14) - ; - out[24 + outpos] = ((in[25 + inpos] & 1073741823) >>> (30 - 12)) - | ((in[26 + inpos]) << 12) - ; - out[25 + outpos] = ((in[26 + inpos] & 1073741823) >>> (30 - 10)) - | ((in[27 + inpos]) << 10) - ; - out[26 + outpos] = ((in[27 + inpos] & 1073741823) >>> (30 - 8)) - | ((in[28 + inpos]) << 8) - ; - out[27 + outpos] = ((in[28 + inpos] & 1073741823) >>> (30 - 6)) - | ((in[29 + inpos]) << 6) - ; - out[28 + outpos] = ((in[29 + inpos] & 1073741823) >>> (30 - 4)) - | ((in[30 + inpos]) << 4) - ; - out[29 + outpos] = ((in[30 + inpos] & 1073741823) >>> (30 - 2)) - | ((in[31 + inpos]) << 2) - ; - } + protected static void fastpack25(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = (in[0 + inpos] & 33554431) + | ((in[1 + inpos]) << 25); + out[1 + outpos] = ((in[1 + inpos] & 33554431) >>> (25 - 18)) + | ((in[2 + inpos]) << 18); + out[2 + outpos] = ((in[2 + inpos] & 33554431) >>> (25 - 11)) + | ((in[3 + inpos]) << 11); + out[3 + outpos] = ((in[3 + inpos] & 33554431) >>> (25 - 4)) + | ((in[4 + inpos] & 33554431) << 4) + | ((in[5 + inpos]) << 29); + out[4 + outpos] = ((in[5 + inpos] & 33554431) >>> (25 - 22)) + | ((in[6 + inpos]) << 22); + out[5 + outpos] = ((in[6 + inpos] & 33554431) >>> (25 - 15)) + | ((in[7 + inpos]) << 15); + out[6 + outpos] = ((in[7 + inpos] & 33554431) >>> (25 - 8)) + | ((in[8 + inpos]) << 8); + out[7 + outpos] = ((in[8 + inpos] & 33554431) >>> (25 - 1)) + | ((in[9 + inpos] & 33554431) << 1) + | ((in[10 + inpos]) << 26); + out[8 + outpos] = ((in[10 + inpos] & 33554431) >>> (25 - 19)) + | ((in[11 + inpos]) << 19); + out[9 + outpos] = ((in[11 + inpos] & 33554431) >>> (25 - 12)) + | ((in[12 + inpos]) << 12); + out[10 + outpos] = ((in[12 + inpos] & 33554431) >>> (25 - 5)) + | ((in[13 + inpos] & 33554431) << 5) + | ((in[14 + inpos]) << 30); + out[11 + outpos] = ((in[14 + inpos] & 33554431) >>> (25 - 23)) + | ((in[15 + inpos]) << 23); + out[12 + outpos] = ((in[15 + inpos] & 33554431) >>> (25 - 16)) + | ((in[16 + inpos]) << 16); + out[13 + outpos] = ((in[16 + inpos] & 33554431) >>> (25 - 9)) + | ((in[17 + inpos]) << 9); + out[14 + outpos] = ((in[17 + inpos] & 33554431) >>> (25 - 2)) + | ((in[18 + inpos] & 33554431) << 2) + | ((in[19 + inpos]) << 27); + out[15 + outpos] = ((in[19 + inpos] & 33554431) >>> (25 - 20)) + | ((in[20 + inpos]) << 20); + out[16 + outpos] = ((in[20 + inpos] & 33554431) >>> (25 - 13)) + | ((in[21 + inpos]) << 13); + out[17 + outpos] = ((in[21 + inpos] & 33554431) >>> (25 - 6)) + | ((in[22 + inpos] & 33554431) << 6) + | ((in[23 + inpos]) << 31); + out[18 + outpos] = ((in[23 + inpos] & 33554431) >>> (25 - 24)) + | ((in[24 + inpos]) << 24); + out[19 + outpos] = ((in[24 + inpos] & 33554431) >>> (25 - 17)) + | ((in[25 + inpos]) << 17); + out[20 + outpos] = ((in[25 + inpos] & 33554431) >>> (25 - 10)) + | ((in[26 + inpos]) << 10); + out[21 + outpos] = ((in[26 + inpos] & 33554431) >>> (25 - 3)) + | ((in[27 + inpos] & 33554431) << 3) + | ((in[28 + inpos]) << 28); + out[22 + outpos] = ((in[28 + inpos] & 33554431) >>> (25 - 21)) + | ((in[29 + inpos]) << 21); + out[23 + outpos] = ((in[29 + inpos] & 33554431) >>> (25 - 14)) + | ((in[30 + inpos]) << 14); + out[24 + outpos] = ((in[30 + inpos] & 33554431) >>> (25 - 7)) + | ((in[31 + inpos]) << 7); + } + protected static void fastpack26(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = (in[0 + inpos] & 67108863) + | ((in[1 + inpos]) << 26); + out[1 + outpos] = ((in[1 + inpos] & 67108863) >>> (26 - 20)) + | ((in[2 + inpos]) << 20); + out[2 + outpos] = ((in[2 + inpos] & 67108863) >>> (26 - 14)) + | ((in[3 + inpos]) << 14); + out[3 + outpos] = ((in[3 + inpos] & 67108863) >>> (26 - 8)) + | ((in[4 + inpos]) << 8); + out[4 + outpos] = ((in[4 + inpos] & 67108863) >>> (26 - 2)) + | ((in[5 + inpos] & 67108863) << 2) + | ((in[6 + inpos]) << 28); + out[5 + outpos] = ((in[6 + inpos] & 67108863) >>> (26 - 22)) + | ((in[7 + inpos]) << 22); + out[6 + outpos] = ((in[7 + inpos] & 67108863) >>> (26 - 16)) + | ((in[8 + inpos]) << 16); + out[7 + outpos] = ((in[8 + inpos] & 67108863) >>> (26 - 10)) + | ((in[9 + inpos]) << 10); + out[8 + outpos] = ((in[9 + inpos] & 67108863) >>> (26 - 4)) + | ((in[10 + inpos] & 67108863) << 4) + | ((in[11 + inpos]) << 30); + out[9 + outpos] = ((in[11 + inpos] & 67108863) >>> (26 - 24)) + | ((in[12 + inpos]) << 24); + out[10 + outpos] = ((in[12 + inpos] & 67108863) >>> (26 - 18)) + | ((in[13 + inpos]) << 18); + out[11 + outpos] = ((in[13 + inpos] & 67108863) >>> (26 - 12)) + | ((in[14 + inpos]) << 12); + out[12 + outpos] = ((in[14 + inpos] & 67108863) >>> (26 - 6)) + | ((in[15 + inpos]) << 6); + out[13 + outpos] = (in[16 + inpos] & 67108863) + | ((in[17 + inpos]) << 26); + out[14 + outpos] = ((in[17 + inpos] & 67108863) >>> (26 - 20)) + | ((in[18 + inpos]) << 20); + out[15 + outpos] = ((in[18 + inpos] & 67108863) >>> (26 - 14)) + | ((in[19 + inpos]) << 14); + out[16 + outpos] = ((in[19 + inpos] & 67108863) >>> (26 - 8)) + | ((in[20 + inpos]) << 8); + out[17 + outpos] = ((in[20 + inpos] & 67108863) >>> (26 - 2)) + | ((in[21 + inpos] & 67108863) << 2) + | ((in[22 + inpos]) << 28); + out[18 + outpos] = ((in[22 + inpos] & 67108863) >>> (26 - 22)) + | ((in[23 + inpos]) << 22); + out[19 + outpos] = ((in[23 + inpos] & 67108863) >>> (26 - 16)) + | ((in[24 + inpos]) << 16); + out[20 + outpos] = ((in[24 + inpos] & 67108863) >>> (26 - 10)) + | ((in[25 + inpos]) << 10); + out[21 + outpos] = ((in[25 + inpos] & 67108863) >>> (26 - 4)) + | ((in[26 + inpos] & 67108863) << 4) + | ((in[27 + inpos]) << 30); + out[22 + outpos] = ((in[27 + inpos] & 67108863) >>> (26 - 24)) + | ((in[28 + inpos]) << 24); + out[23 + outpos] = ((in[28 + inpos] & 67108863) >>> (26 - 18)) + | ((in[29 + inpos]) << 18); + out[24 + outpos] = ((in[29 + inpos] & 67108863) >>> (26 - 12)) + | ((in[30 + inpos]) << 12); + out[25 + outpos] = ((in[30 + inpos] & 67108863) >>> (26 - 6)) + | ((in[31 + inpos]) << 6); + } - protected static void fastpack31(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (in[0 + inpos] & 2147483647) - | ((in[1 + inpos]) << 31) - ; - out[1 + outpos] = ((in[1 + inpos] & 2147483647) >>> (31 - 30)) - | ((in[2 + inpos]) << 30) - ; - out[2 + outpos] = ((in[2 + inpos] & 2147483647) >>> (31 - 29)) - | ((in[3 + inpos]) << 29) - ; - out[3 + outpos] = ((in[3 + inpos] & 2147483647) >>> (31 - 28)) - | ((in[4 + inpos]) << 28) - ; - out[4 + outpos] = ((in[4 + inpos] & 2147483647) >>> (31 - 27)) - | ((in[5 + inpos]) << 27) - ; - out[5 + outpos] = ((in[5 + inpos] & 2147483647) >>> (31 - 26)) - | ((in[6 + inpos]) << 26) - ; - out[6 + outpos] = ((in[6 + inpos] & 2147483647) >>> (31 - 25)) - | ((in[7 + inpos]) << 25) - ; - out[7 + outpos] = ((in[7 + inpos] & 2147483647) >>> (31 - 24)) - | ((in[8 + inpos]) << 24) - ; - out[8 + outpos] = ((in[8 + inpos] & 2147483647) >>> (31 - 23)) - | ((in[9 + inpos]) << 23) - ; - out[9 + outpos] = ((in[9 + inpos] & 2147483647) >>> (31 - 22)) - | ((in[10 + inpos]) << 22) - ; - out[10 + outpos] = ((in[10 + inpos] & 2147483647) >>> (31 - 21)) - | ((in[11 + inpos]) << 21) - ; - out[11 + outpos] = ((in[11 + inpos] & 2147483647) >>> (31 - 20)) - | ((in[12 + inpos]) << 20) - ; - out[12 + outpos] = ((in[12 + inpos] & 2147483647) >>> (31 - 19)) - | ((in[13 + inpos]) << 19) - ; - out[13 + outpos] = ((in[13 + inpos] & 2147483647) >>> (31 - 18)) - | ((in[14 + inpos]) << 18) - ; - out[14 + outpos] = ((in[14 + inpos] & 2147483647) >>> (31 - 17)) - | ((in[15 + inpos]) << 17) - ; - out[15 + outpos] = ((in[15 + inpos] & 2147483647) >>> (31 - 16)) - | ((in[16 + inpos]) << 16) - ; - out[16 + outpos] = ((in[16 + inpos] & 2147483647) >>> (31 - 15)) - | ((in[17 + inpos]) << 15) - ; - out[17 + outpos] = ((in[17 + inpos] & 2147483647) >>> (31 - 14)) - | ((in[18 + inpos]) << 14) - ; - out[18 + outpos] = ((in[18 + inpos] & 2147483647) >>> (31 - 13)) - | ((in[19 + inpos]) << 13) - ; - out[19 + outpos] = ((in[19 + inpos] & 2147483647) >>> (31 - 12)) - | ((in[20 + inpos]) << 12) - ; - out[20 + outpos] = ((in[20 + inpos] & 2147483647) >>> (31 - 11)) - | ((in[21 + inpos]) << 11) - ; - out[21 + outpos] = ((in[21 + inpos] & 2147483647) >>> (31 - 10)) - | ((in[22 + inpos]) << 10) - ; - out[22 + outpos] = ((in[22 + inpos] & 2147483647) >>> (31 - 9)) - | ((in[23 + inpos]) << 9) - ; - out[23 + outpos] = ((in[23 + inpos] & 2147483647) >>> (31 - 8)) - | ((in[24 + inpos]) << 8) - ; - out[24 + outpos] = ((in[24 + inpos] & 2147483647) >>> (31 - 7)) - | ((in[25 + inpos]) << 7) - ; - out[25 + outpos] = ((in[25 + inpos] & 2147483647) >>> (31 - 6)) - | ((in[26 + inpos]) << 6) - ; - out[26 + outpos] = ((in[26 + inpos] & 2147483647) >>> (31 - 5)) - | ((in[27 + inpos]) << 5) - ; - out[27 + outpos] = ((in[27 + inpos] & 2147483647) >>> (31 - 4)) - | ((in[28 + inpos]) << 4) - ; - out[28 + outpos] = ((in[28 + inpos] & 2147483647) >>> (31 - 3)) - | ((in[29 + inpos]) << 3) - ; - out[29 + outpos] = ((in[29 + inpos] & 2147483647) >>> (31 - 2)) - | ((in[30 + inpos]) << 2) - ; - out[30 + outpos] = ((in[30 + inpos] & 2147483647) >>> (31 - 1)) - | ((in[31 + inpos]) << 1) - ; - } + protected static void fastpack27(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = (in[0 + inpos] & 134217727) + | ((in[1 + inpos]) << 27); + out[1 + outpos] = ((in[1 + inpos] & 134217727) >>> (27 - 22)) + | ((in[2 + inpos]) << 22); + out[2 + outpos] = ((in[2 + inpos] & 134217727) >>> (27 - 17)) + | ((in[3 + inpos]) << 17); + out[3 + outpos] = ((in[3 + inpos] & 134217727) >>> (27 - 12)) + | ((in[4 + inpos]) << 12); + out[4 + outpos] = ((in[4 + inpos] & 134217727) >>> (27 - 7)) + | ((in[5 + inpos]) << 7); + out[5 + outpos] = ((in[5 + inpos] & 134217727) >>> (27 - 2)) + | ((in[6 + inpos] & 134217727) << 2) + | ((in[7 + inpos]) << 29); + out[6 + outpos] = ((in[7 + inpos] & 134217727) >>> (27 - 24)) + | ((in[8 + inpos]) << 24); + out[7 + outpos] = ((in[8 + inpos] & 134217727) >>> (27 - 19)) + | ((in[9 + inpos]) << 19); + out[8 + outpos] = ((in[9 + inpos] & 134217727) >>> (27 - 14)) + | ((in[10 + inpos]) << 14); + out[9 + outpos] = ((in[10 + inpos] & 134217727) >>> (27 - 9)) + | ((in[11 + inpos]) << 9); + out[10 + outpos] = ((in[11 + inpos] & 134217727) >>> (27 - 4)) + | ((in[12 + inpos] & 134217727) << 4) + | ((in[13 + inpos]) << 31); + out[11 + outpos] = ((in[13 + inpos] & 134217727) >>> (27 - 26)) + | ((in[14 + inpos]) << 26); + out[12 + outpos] = ((in[14 + inpos] & 134217727) >>> (27 - 21)) + | ((in[15 + inpos]) << 21); + out[13 + outpos] = ((in[15 + inpos] & 134217727) >>> (27 - 16)) + | ((in[16 + inpos]) << 16); + out[14 + outpos] = ((in[16 + inpos] & 134217727) >>> (27 - 11)) + | ((in[17 + inpos]) << 11); + out[15 + outpos] = ((in[17 + inpos] & 134217727) >>> (27 - 6)) + | ((in[18 + inpos]) << 6); + out[16 + outpos] = ((in[18 + inpos] & 134217727) >>> (27 - 1)) + | ((in[19 + inpos] & 134217727) << 1) + | ((in[20 + inpos]) << 28); + out[17 + outpos] = ((in[20 + inpos] & 134217727) >>> (27 - 23)) + | ((in[21 + inpos]) << 23); + out[18 + outpos] = ((in[21 + inpos] & 134217727) >>> (27 - 18)) + | ((in[22 + inpos]) << 18); + out[19 + outpos] = ((in[22 + inpos] & 134217727) >>> (27 - 13)) + | ((in[23 + inpos]) << 13); + out[20 + outpos] = ((in[23 + inpos] & 134217727) >>> (27 - 8)) + | ((in[24 + inpos]) << 8); + out[21 + outpos] = ((in[24 + inpos] & 134217727) >>> (27 - 3)) + | ((in[25 + inpos] & 134217727) << 3) + | ((in[26 + inpos]) << 30); + out[22 + outpos] = ((in[26 + inpos] & 134217727) >>> (27 - 25)) + | ((in[27 + inpos]) << 25); + out[23 + outpos] = ((in[27 + inpos] & 134217727) >>> (27 - 20)) + | ((in[28 + inpos]) << 20); + out[24 + outpos] = ((in[28 + inpos] & 134217727) >>> (27 - 15)) + | ((in[29 + inpos]) << 15); + out[25 + outpos] = ((in[29 + inpos] & 134217727) >>> (27 - 10)) + | ((in[30 + inpos]) << 10); + out[26 + outpos] = ((in[30 + inpos] & 134217727) >>> (27 - 5)) + | ((in[31 + inpos]) << 5); + } + protected static void fastpack28(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = (in[0 + inpos] & 268435455) + | ((in[1 + inpos]) << 28); + out[1 + outpos] = ((in[1 + inpos] & 268435455) >>> (28 - 24)) + | ((in[2 + inpos]) << 24); + out[2 + outpos] = ((in[2 + inpos] & 268435455) >>> (28 - 20)) + | ((in[3 + inpos]) << 20); + out[3 + outpos] = ((in[3 + inpos] & 268435455) >>> (28 - 16)) + | ((in[4 + inpos]) << 16); + out[4 + outpos] = ((in[4 + inpos] & 268435455) >>> (28 - 12)) + | ((in[5 + inpos]) << 12); + out[5 + outpos] = ((in[5 + inpos] & 268435455) >>> (28 - 8)) + | ((in[6 + inpos]) << 8); + out[6 + outpos] = ((in[6 + inpos] & 268435455) >>> (28 - 4)) + | ((in[7 + inpos]) << 4); + out[7 + outpos] = (in[8 + inpos] & 268435455) + | ((in[9 + inpos]) << 28); + out[8 + outpos] = ((in[9 + inpos] & 268435455) >>> (28 - 24)) + | ((in[10 + inpos]) << 24); + out[9 + outpos] = ((in[10 + inpos] & 268435455) >>> (28 - 20)) + | ((in[11 + inpos]) << 20); + out[10 + outpos] = ((in[11 + inpos] & 268435455) >>> (28 - 16)) + | ((in[12 + inpos]) << 16); + out[11 + outpos] = ((in[12 + inpos] & 268435455) >>> (28 - 12)) + | ((in[13 + inpos]) << 12); + out[12 + outpos] = ((in[13 + inpos] & 268435455) >>> (28 - 8)) + | ((in[14 + inpos]) << 8); + out[13 + outpos] = ((in[14 + inpos] & 268435455) >>> (28 - 4)) + | ((in[15 + inpos]) << 4); + out[14 + outpos] = (in[16 + inpos] & 268435455) + | ((in[17 + inpos]) << 28); + out[15 + outpos] = ((in[17 + inpos] & 268435455) >>> (28 - 24)) + | ((in[18 + inpos]) << 24); + out[16 + outpos] = ((in[18 + inpos] & 268435455) >>> (28 - 20)) + | ((in[19 + inpos]) << 20); + out[17 + outpos] = ((in[19 + inpos] & 268435455) >>> (28 - 16)) + | ((in[20 + inpos]) << 16); + out[18 + outpos] = ((in[20 + inpos] & 268435455) >>> (28 - 12)) + | ((in[21 + inpos]) << 12); + out[19 + outpos] = ((in[21 + inpos] & 268435455) >>> (28 - 8)) + | ((in[22 + inpos]) << 8); + out[20 + outpos] = ((in[22 + inpos] & 268435455) >>> (28 - 4)) + | ((in[23 + inpos]) << 4); + out[21 + outpos] = (in[24 + inpos] & 268435455) + | ((in[25 + inpos]) << 28); + out[22 + outpos] = ((in[25 + inpos] & 268435455) >>> (28 - 24)) + | ((in[26 + inpos]) << 24); + out[23 + outpos] = ((in[26 + inpos] & 268435455) >>> (28 - 20)) + | ((in[27 + inpos]) << 20); + out[24 + outpos] = ((in[27 + inpos] & 268435455) >>> (28 - 16)) + | ((in[28 + inpos]) << 16); + out[25 + outpos] = ((in[28 + inpos] & 268435455) >>> (28 - 12)) + | ((in[29 + inpos]) << 12); + out[26 + outpos] = ((in[29 + inpos] & 268435455) >>> (28 - 8)) + | ((in[30 + inpos]) << 8); + out[27 + outpos] = ((in[30 + inpos] & 268435455) >>> (28 - 4)) + | ((in[31 + inpos]) << 4); + } - protected static void fastunpack1(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = ((in[0 + inpos] >>> 0) & 1) - ; - out[1 + outpos] = ((in[0 + inpos] >>> 1) & 1) - ; - out[2 + outpos] = ((in[0 + inpos] >>> 2) & 1) - ; - out[3 + outpos] = ((in[0 + inpos] >>> 3) & 1) - ; - out[4 + outpos] = ((in[0 + inpos] >>> 4) & 1) - ; - out[5 + outpos] = ((in[0 + inpos] >>> 5) & 1) - ; - out[6 + outpos] = ((in[0 + inpos] >>> 6) & 1) - ; - out[7 + outpos] = ((in[0 + inpos] >>> 7) & 1) - ; - out[8 + outpos] = ((in[0 + inpos] >>> 8) & 1) - ; - out[9 + outpos] = ((in[0 + inpos] >>> 9) & 1) - ; - out[10 + outpos] = ((in[0 + inpos] >>> 10) & 1) - ; - out[11 + outpos] = ((in[0 + inpos] >>> 11) & 1) - ; - out[12 + outpos] = ((in[0 + inpos] >>> 12) & 1) - ; - out[13 + outpos] = ((in[0 + inpos] >>> 13) & 1) - ; - out[14 + outpos] = ((in[0 + inpos] >>> 14) & 1) - ; - out[15 + outpos] = ((in[0 + inpos] >>> 15) & 1) - ; - out[16 + outpos] = ((in[0 + inpos] >>> 16) & 1) - ; - out[17 + outpos] = ((in[0 + inpos] >>> 17) & 1) - ; - out[18 + outpos] = ((in[0 + inpos] >>> 18) & 1) - ; - out[19 + outpos] = ((in[0 + inpos] >>> 19) & 1) - ; - out[20 + outpos] = ((in[0 + inpos] >>> 20) & 1) - ; - out[21 + outpos] = ((in[0 + inpos] >>> 21) & 1) - ; - out[22 + outpos] = ((in[0 + inpos] >>> 22) & 1) - ; - out[23 + outpos] = ((in[0 + inpos] >>> 23) & 1) - ; - out[24 + outpos] = ((in[0 + inpos] >>> 24) & 1) - ; - out[25 + outpos] = ((in[0 + inpos] >>> 25) & 1) - ; - out[26 + outpos] = ((in[0 + inpos] >>> 26) & 1) - ; - out[27 + outpos] = ((in[0 + inpos] >>> 27) & 1) - ; - out[28 + outpos] = ((in[0 + inpos] >>> 28) & 1) - ; - out[29 + outpos] = ((in[0 + inpos] >>> 29) & 1) - ; - out[30 + outpos] = ((in[0 + inpos] >>> 30) & 1) - ; - out[31 + outpos] = (in[0 + inpos] >>> 31) - ; - } + protected static void fastpack29(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = (in[0 + inpos] & 536870911) + | ((in[1 + inpos]) << 29); + out[1 + outpos] = ((in[1 + inpos] & 536870911) >>> (29 - 26)) + | ((in[2 + inpos]) << 26); + out[2 + outpos] = ((in[2 + inpos] & 536870911) >>> (29 - 23)) + | ((in[3 + inpos]) << 23); + out[3 + outpos] = ((in[3 + inpos] & 536870911) >>> (29 - 20)) + | ((in[4 + inpos]) << 20); + out[4 + outpos] = ((in[4 + inpos] & 536870911) >>> (29 - 17)) + | ((in[5 + inpos]) << 17); + out[5 + outpos] = ((in[5 + inpos] & 536870911) >>> (29 - 14)) + | ((in[6 + inpos]) << 14); + out[6 + outpos] = ((in[6 + inpos] & 536870911) >>> (29 - 11)) + | ((in[7 + inpos]) << 11); + out[7 + outpos] = ((in[7 + inpos] & 536870911) >>> (29 - 8)) + | ((in[8 + inpos]) << 8); + out[8 + outpos] = ((in[8 + inpos] & 536870911) >>> (29 - 5)) + | ((in[9 + inpos]) << 5); + out[9 + outpos] = ((in[9 + inpos] & 536870911) >>> (29 - 2)) + | ((in[10 + inpos] & 536870911) << 2) + | ((in[11 + inpos]) << 31); + out[10 + outpos] = ((in[11 + inpos] & 536870911) >>> (29 - 28)) + | ((in[12 + inpos]) << 28); + out[11 + outpos] = ((in[12 + inpos] & 536870911) >>> (29 - 25)) + | ((in[13 + inpos]) << 25); + out[12 + outpos] = ((in[13 + inpos] & 536870911) >>> (29 - 22)) + | ((in[14 + inpos]) << 22); + out[13 + outpos] = ((in[14 + inpos] & 536870911) >>> (29 - 19)) + | ((in[15 + inpos]) << 19); + out[14 + outpos] = ((in[15 + inpos] & 536870911) >>> (29 - 16)) + | ((in[16 + inpos]) << 16); + out[15 + outpos] = ((in[16 + inpos] & 536870911) >>> (29 - 13)) + | ((in[17 + inpos]) << 13); + out[16 + outpos] = ((in[17 + inpos] & 536870911) >>> (29 - 10)) + | ((in[18 + inpos]) << 10); + out[17 + outpos] = ((in[18 + inpos] & 536870911) >>> (29 - 7)) + | ((in[19 + inpos]) << 7); + out[18 + outpos] = ((in[19 + inpos] & 536870911) >>> (29 - 4)) + | ((in[20 + inpos]) << 4); + out[19 + outpos] = ((in[20 + inpos] & 536870911) >>> (29 - 1)) + | ((in[21 + inpos] & 536870911) << 1) + | ((in[22 + inpos]) << 30); + out[20 + outpos] = ((in[22 + inpos] & 536870911) >>> (29 - 27)) + | ((in[23 + inpos]) << 27); + out[21 + outpos] = ((in[23 + inpos] & 536870911) >>> (29 - 24)) + | ((in[24 + inpos]) << 24); + out[22 + outpos] = ((in[24 + inpos] & 536870911) >>> (29 - 21)) + | ((in[25 + inpos]) << 21); + out[23 + outpos] = ((in[25 + inpos] & 536870911) >>> (29 - 18)) + | ((in[26 + inpos]) << 18); + out[24 + outpos] = ((in[26 + inpos] & 536870911) >>> (29 - 15)) + | ((in[27 + inpos]) << 15); + out[25 + outpos] = ((in[27 + inpos] & 536870911) >>> (29 - 12)) + | ((in[28 + inpos]) << 12); + out[26 + outpos] = ((in[28 + inpos] & 536870911) >>> (29 - 9)) + | ((in[29 + inpos]) << 9); + out[27 + outpos] = ((in[29 + inpos] & 536870911) >>> (29 - 6)) + | ((in[30 + inpos]) << 6); + out[28 + outpos] = ((in[30 + inpos] & 536870911) >>> (29 - 3)) + | ((in[31 + inpos]) << 3); + } + protected static void fastpack3(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = (in[0 + inpos] & 7) + | ((in[1 + inpos] & 7) << 3) + | ((in[2 + inpos] & 7) << 6) + | ((in[3 + inpos] & 7) << 9) + | ((in[4 + inpos] & 7) << 12) + | ((in[5 + inpos] & 7) << 15) + | ((in[6 + inpos] & 7) << 18) + | ((in[7 + inpos] & 7) << 21) + | ((in[8 + inpos] & 7) << 24) + | ((in[9 + inpos] & 7) << 27) + | ((in[10 + inpos]) << 30); + out[1 + outpos] = ((in[10 + inpos] & 7) >>> (3 - 1)) + | ((in[11 + inpos] & 7) << 1) + | ((in[12 + inpos] & 7) << 4) + | ((in[13 + inpos] & 7) << 7) + | ((in[14 + inpos] & 7) << 10) + | ((in[15 + inpos] & 7) << 13) + | ((in[16 + inpos] & 7) << 16) + | ((in[17 + inpos] & 7) << 19) + | ((in[18 + inpos] & 7) << 22) + | ((in[19 + inpos] & 7) << 25) + | ((in[20 + inpos] & 7) << 28) + | ((in[21 + inpos]) << 31); + out[2 + outpos] = ((in[21 + inpos] & 7) >>> (3 - 2)) + | ((in[22 + inpos] & 7) << 2) + | ((in[23 + inpos] & 7) << 5) + | ((in[24 + inpos] & 7) << 8) + | ((in[25 + inpos] & 7) << 11) + | ((in[26 + inpos] & 7) << 14) + | ((in[27 + inpos] & 7) << 17) + | ((in[28 + inpos] & 7) << 20) + | ((in[29 + inpos] & 7) << 23) + | ((in[30 + inpos] & 7) << 26) + | ((in[31 + inpos]) << 29); + } - protected static void fastunpack2(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = ((in[0 + inpos] >>> 0) & 3) - ; - out[1 + outpos] = ((in[0 + inpos] >>> 2) & 3) - ; - out[2 + outpos] = ((in[0 + inpos] >>> 4) & 3) - ; - out[3 + outpos] = ((in[0 + inpos] >>> 6) & 3) - ; - out[4 + outpos] = ((in[0 + inpos] >>> 8) & 3) - ; - out[5 + outpos] = ((in[0 + inpos] >>> 10) & 3) - ; - out[6 + outpos] = ((in[0 + inpos] >>> 12) & 3) - ; - out[7 + outpos] = ((in[0 + inpos] >>> 14) & 3) - ; - out[8 + outpos] = ((in[0 + inpos] >>> 16) & 3) - ; - out[9 + outpos] = ((in[0 + inpos] >>> 18) & 3) - ; - out[10 + outpos] = ((in[0 + inpos] >>> 20) & 3) - ; - out[11 + outpos] = ((in[0 + inpos] >>> 22) & 3) - ; - out[12 + outpos] = ((in[0 + inpos] >>> 24) & 3) - ; - out[13 + outpos] = ((in[0 + inpos] >>> 26) & 3) - ; - out[14 + outpos] = ((in[0 + inpos] >>> 28) & 3) - ; - out[15 + outpos] = (in[0 + inpos] >>> 30) - ; - out[16 + outpos] = ((in[1 + inpos] >>> 0) & 3) - ; - out[17 + outpos] = ((in[1 + inpos] >>> 2) & 3) - ; - out[18 + outpos] = ((in[1 + inpos] >>> 4) & 3) - ; - out[19 + outpos] = ((in[1 + inpos] >>> 6) & 3) - ; - out[20 + outpos] = ((in[1 + inpos] >>> 8) & 3) - ; - out[21 + outpos] = ((in[1 + inpos] >>> 10) & 3) - ; - out[22 + outpos] = ((in[1 + inpos] >>> 12) & 3) - ; - out[23 + outpos] = ((in[1 + inpos] >>> 14) & 3) - ; - out[24 + outpos] = ((in[1 + inpos] >>> 16) & 3) - ; - out[25 + outpos] = ((in[1 + inpos] >>> 18) & 3) - ; - out[26 + outpos] = ((in[1 + inpos] >>> 20) & 3) - ; - out[27 + outpos] = ((in[1 + inpos] >>> 22) & 3) - ; - out[28 + outpos] = ((in[1 + inpos] >>> 24) & 3) - ; - out[29 + outpos] = ((in[1 + inpos] >>> 26) & 3) - ; - out[30 + outpos] = ((in[1 + inpos] >>> 28) & 3) - ; - out[31 + outpos] = (in[1 + inpos] >>> 30) - ; - } + protected static void fastpack30(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = (in[0 + inpos] & 1073741823) + | ((in[1 + inpos]) << 30); + out[1 + outpos] = ((in[1 + inpos] & 1073741823) >>> (30 - 28)) + | ((in[2 + inpos]) << 28); + out[2 + outpos] = ((in[2 + inpos] & 1073741823) >>> (30 - 26)) + | ((in[3 + inpos]) << 26); + out[3 + outpos] = ((in[3 + inpos] & 1073741823) >>> (30 - 24)) + | ((in[4 + inpos]) << 24); + out[4 + outpos] = ((in[4 + inpos] & 1073741823) >>> (30 - 22)) + | ((in[5 + inpos]) << 22); + out[5 + outpos] = ((in[5 + inpos] & 1073741823) >>> (30 - 20)) + | ((in[6 + inpos]) << 20); + out[6 + outpos] = ((in[6 + inpos] & 1073741823) >>> (30 - 18)) + | ((in[7 + inpos]) << 18); + out[7 + outpos] = ((in[7 + inpos] & 1073741823) >>> (30 - 16)) + | ((in[8 + inpos]) << 16); + out[8 + outpos] = ((in[8 + inpos] & 1073741823) >>> (30 - 14)) + | ((in[9 + inpos]) << 14); + out[9 + outpos] = ((in[9 + inpos] & 1073741823) >>> (30 - 12)) + | ((in[10 + inpos]) << 12); + out[10 + outpos] = ((in[10 + inpos] & 1073741823) >>> (30 - 10)) + | ((in[11 + inpos]) << 10); + out[11 + outpos] = ((in[11 + inpos] & 1073741823) >>> (30 - 8)) + | ((in[12 + inpos]) << 8); + out[12 + outpos] = ((in[12 + inpos] & 1073741823) >>> (30 - 6)) + | ((in[13 + inpos]) << 6); + out[13 + outpos] = ((in[13 + inpos] & 1073741823) >>> (30 - 4)) + | ((in[14 + inpos]) << 4); + out[14 + outpos] = ((in[14 + inpos] & 1073741823) >>> (30 - 2)) + | ((in[15 + inpos]) << 2); + out[15 + outpos] = (in[16 + inpos] & 1073741823) + | ((in[17 + inpos]) << 30); + out[16 + outpos] = ((in[17 + inpos] & 1073741823) >>> (30 - 28)) + | ((in[18 + inpos]) << 28); + out[17 + outpos] = ((in[18 + inpos] & 1073741823) >>> (30 - 26)) + | ((in[19 + inpos]) << 26); + out[18 + outpos] = ((in[19 + inpos] & 1073741823) >>> (30 - 24)) + | ((in[20 + inpos]) << 24); + out[19 + outpos] = ((in[20 + inpos] & 1073741823) >>> (30 - 22)) + | ((in[21 + inpos]) << 22); + out[20 + outpos] = ((in[21 + inpos] & 1073741823) >>> (30 - 20)) + | ((in[22 + inpos]) << 20); + out[21 + outpos] = ((in[22 + inpos] & 1073741823) >>> (30 - 18)) + | ((in[23 + inpos]) << 18); + out[22 + outpos] = ((in[23 + inpos] & 1073741823) >>> (30 - 16)) + | ((in[24 + inpos]) << 16); + out[23 + outpos] = ((in[24 + inpos] & 1073741823) >>> (30 - 14)) + | ((in[25 + inpos]) << 14); + out[24 + outpos] = ((in[25 + inpos] & 1073741823) >>> (30 - 12)) + | ((in[26 + inpos]) << 12); + out[25 + outpos] = ((in[26 + inpos] & 1073741823) >>> (30 - 10)) + | ((in[27 + inpos]) << 10); + out[26 + outpos] = ((in[27 + inpos] & 1073741823) >>> (30 - 8)) + | ((in[28 + inpos]) << 8); + out[27 + outpos] = ((in[28 + inpos] & 1073741823) >>> (30 - 6)) + | ((in[29 + inpos]) << 6); + out[28 + outpos] = ((in[29 + inpos] & 1073741823) >>> (30 - 4)) + | ((in[30 + inpos]) << 4); + out[29 + outpos] = ((in[30 + inpos] & 1073741823) >>> (30 - 2)) + | ((in[31 + inpos]) << 2); + } + protected static void fastpack31(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = (in[0 + inpos] & 2147483647) + | ((in[1 + inpos]) << 31); + out[1 + outpos] = ((in[1 + inpos] & 2147483647) >>> (31 - 30)) + | ((in[2 + inpos]) << 30); + out[2 + outpos] = ((in[2 + inpos] & 2147483647) >>> (31 - 29)) + | ((in[3 + inpos]) << 29); + out[3 + outpos] = ((in[3 + inpos] & 2147483647) >>> (31 - 28)) + | ((in[4 + inpos]) << 28); + out[4 + outpos] = ((in[4 + inpos] & 2147483647) >>> (31 - 27)) + | ((in[5 + inpos]) << 27); + out[5 + outpos] = ((in[5 + inpos] & 2147483647) >>> (31 - 26)) + | ((in[6 + inpos]) << 26); + out[6 + outpos] = ((in[6 + inpos] & 2147483647) >>> (31 - 25)) + | ((in[7 + inpos]) << 25); + out[7 + outpos] = ((in[7 + inpos] & 2147483647) >>> (31 - 24)) + | ((in[8 + inpos]) << 24); + out[8 + outpos] = ((in[8 + inpos] & 2147483647) >>> (31 - 23)) + | ((in[9 + inpos]) << 23); + out[9 + outpos] = ((in[9 + inpos] & 2147483647) >>> (31 - 22)) + | ((in[10 + inpos]) << 22); + out[10 + outpos] = ((in[10 + inpos] & 2147483647) >>> (31 - 21)) + | ((in[11 + inpos]) << 21); + out[11 + outpos] = ((in[11 + inpos] & 2147483647) >>> (31 - 20)) + | ((in[12 + inpos]) << 20); + out[12 + outpos] = ((in[12 + inpos] & 2147483647) >>> (31 - 19)) + | ((in[13 + inpos]) << 19); + out[13 + outpos] = ((in[13 + inpos] & 2147483647) >>> (31 - 18)) + | ((in[14 + inpos]) << 18); + out[14 + outpos] = ((in[14 + inpos] & 2147483647) >>> (31 - 17)) + | ((in[15 + inpos]) << 17); + out[15 + outpos] = ((in[15 + inpos] & 2147483647) >>> (31 - 16)) + | ((in[16 + inpos]) << 16); + out[16 + outpos] = ((in[16 + inpos] & 2147483647) >>> (31 - 15)) + | ((in[17 + inpos]) << 15); + out[17 + outpos] = ((in[17 + inpos] & 2147483647) >>> (31 - 14)) + | ((in[18 + inpos]) << 14); + out[18 + outpos] = ((in[18 + inpos] & 2147483647) >>> (31 - 13)) + | ((in[19 + inpos]) << 13); + out[19 + outpos] = ((in[19 + inpos] & 2147483647) >>> (31 - 12)) + | ((in[20 + inpos]) << 12); + out[20 + outpos] = ((in[20 + inpos] & 2147483647) >>> (31 - 11)) + | ((in[21 + inpos]) << 11); + out[21 + outpos] = ((in[21 + inpos] & 2147483647) >>> (31 - 10)) + | ((in[22 + inpos]) << 10); + out[22 + outpos] = ((in[22 + inpos] & 2147483647) >>> (31 - 9)) + | ((in[23 + inpos]) << 9); + out[23 + outpos] = ((in[23 + inpos] & 2147483647) >>> (31 - 8)) + | ((in[24 + inpos]) << 8); + out[24 + outpos] = ((in[24 + inpos] & 2147483647) >>> (31 - 7)) + | ((in[25 + inpos]) << 7); + out[25 + outpos] = ((in[25 + inpos] & 2147483647) >>> (31 - 6)) + | ((in[26 + inpos]) << 6); + out[26 + outpos] = ((in[26 + inpos] & 2147483647) >>> (31 - 5)) + | ((in[27 + inpos]) << 5); + out[27 + outpos] = ((in[27 + inpos] & 2147483647) >>> (31 - 4)) + | ((in[28 + inpos]) << 4); + out[28 + outpos] = ((in[28 + inpos] & 2147483647) >>> (31 - 3)) + | ((in[29 + inpos]) << 3); + out[29 + outpos] = ((in[29 + inpos] & 2147483647) >>> (31 - 2)) + | ((in[30 + inpos]) << 2); + out[30 + outpos] = ((in[30 + inpos] & 2147483647) >>> (31 - 1)) + | ((in[31 + inpos]) << 1); + } - protected static void fastunpack3(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = ((in[0 + inpos] >>> 0) & 7) - ; - out[1 + outpos] = ((in[0 + inpos] >>> 3) & 7) - ; - out[2 + outpos] = ((in[0 + inpos] >>> 6) & 7) - ; - out[3 + outpos] = ((in[0 + inpos] >>> 9) & 7) - ; - out[4 + outpos] = ((in[0 + inpos] >>> 12) & 7) - ; - out[5 + outpos] = ((in[0 + inpos] >>> 15) & 7) - ; - out[6 + outpos] = ((in[0 + inpos] >>> 18) & 7) - ; - out[7 + outpos] = ((in[0 + inpos] >>> 21) & 7) - ; - out[8 + outpos] = ((in[0 + inpos] >>> 24) & 7) - ; - out[9 + outpos] = ((in[0 + inpos] >>> 27) & 7) - ; - out[10 + outpos] = (in[0 + inpos] >>> 30) - | ((in[1 + inpos] & 1) << (3 - 1)) - ; - out[11 + outpos] = ((in[1 + inpos] >>> 1) & 7) - ; - out[12 + outpos] = ((in[1 + inpos] >>> 4) & 7) - ; - out[13 + outpos] = ((in[1 + inpos] >>> 7) & 7) - ; - out[14 + outpos] = ((in[1 + inpos] >>> 10) & 7) - ; - out[15 + outpos] = ((in[1 + inpos] >>> 13) & 7) - ; - out[16 + outpos] = ((in[1 + inpos] >>> 16) & 7) - ; - out[17 + outpos] = ((in[1 + inpos] >>> 19) & 7) - ; - out[18 + outpos] = ((in[1 + inpos] >>> 22) & 7) - ; - out[19 + outpos] = ((in[1 + inpos] >>> 25) & 7) - ; - out[20 + outpos] = ((in[1 + inpos] >>> 28) & 7) - ; - out[21 + outpos] = (in[1 + inpos] >>> 31) - | ((in[2 + inpos] & 3) << (3 - 2)) - ; - out[22 + outpos] = ((in[2 + inpos] >>> 2) & 7) - ; - out[23 + outpos] = ((in[2 + inpos] >>> 5) & 7) - ; - out[24 + outpos] = ((in[2 + inpos] >>> 8) & 7) - ; - out[25 + outpos] = ((in[2 + inpos] >>> 11) & 7) - ; - out[26 + outpos] = ((in[2 + inpos] >>> 14) & 7) - ; - out[27 + outpos] = ((in[2 + inpos] >>> 17) & 7) - ; - out[28 + outpos] = ((in[2 + inpos] >>> 20) & 7) - ; - out[29 + outpos] = ((in[2 + inpos] >>> 23) & 7) - ; - out[30 + outpos] = ((in[2 + inpos] >>> 26) & 7) - ; - out[31 + outpos] = (in[2 + inpos] >>> 29) - ; - } + protected static void fastpack32(final int[] in, int inpos, + final int[] out, int outpos) { + System.arraycopy(in, inpos, out, outpos, 32); + } + protected static void fastpack4(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = (in[0 + inpos] & 15) + | ((in[1 + inpos] & 15) << 4) + | ((in[2 + inpos] & 15) << 8) + | ((in[3 + inpos] & 15) << 12) + | ((in[4 + inpos] & 15) << 16) + | ((in[5 + inpos] & 15) << 20) + | ((in[6 + inpos] & 15) << 24) + | ((in[7 + inpos]) << 28); + out[1 + outpos] = (in[8 + inpos] & 15) + | ((in[9 + inpos] & 15) << 4) + | ((in[10 + inpos] & 15) << 8) + | ((in[11 + inpos] & 15) << 12) + | ((in[12 + inpos] & 15) << 16) + | ((in[13 + inpos] & 15) << 20) + | ((in[14 + inpos] & 15) << 24) + | ((in[15 + inpos]) << 28); + out[2 + outpos] = (in[16 + inpos] & 15) + | ((in[17 + inpos] & 15) << 4) + | ((in[18 + inpos] & 15) << 8) + | ((in[19 + inpos] & 15) << 12) + | ((in[20 + inpos] & 15) << 16) + | ((in[21 + inpos] & 15) << 20) + | ((in[22 + inpos] & 15) << 24) + | ((in[23 + inpos]) << 28); + out[3 + outpos] = (in[24 + inpos] & 15) + | ((in[25 + inpos] & 15) << 4) + | ((in[26 + inpos] & 15) << 8) + | ((in[27 + inpos] & 15) << 12) + | ((in[28 + inpos] & 15) << 16) + | ((in[29 + inpos] & 15) << 20) + | ((in[30 + inpos] & 15) << 24) + | ((in[31 + inpos]) << 28); + } - protected static void fastunpack4(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = ((in[0 + inpos] >>> 0) & 15) - ; - out[1 + outpos] = ((in[0 + inpos] >>> 4) & 15) - ; - out[2 + outpos] = ((in[0 + inpos] >>> 8) & 15) - ; - out[3 + outpos] = ((in[0 + inpos] >>> 12) & 15) - ; - out[4 + outpos] = ((in[0 + inpos] >>> 16) & 15) - ; - out[5 + outpos] = ((in[0 + inpos] >>> 20) & 15) - ; - out[6 + outpos] = ((in[0 + inpos] >>> 24) & 15) - ; - out[7 + outpos] = (in[0 + inpos] >>> 28) - ; - out[8 + outpos] = ((in[1 + inpos] >>> 0) & 15) - ; - out[9 + outpos] = ((in[1 + inpos] >>> 4) & 15) - ; - out[10 + outpos] = ((in[1 + inpos] >>> 8) & 15) - ; - out[11 + outpos] = ((in[1 + inpos] >>> 12) & 15) - ; - out[12 + outpos] = ((in[1 + inpos] >>> 16) & 15) - ; - out[13 + outpos] = ((in[1 + inpos] >>> 20) & 15) - ; - out[14 + outpos] = ((in[1 + inpos] >>> 24) & 15) - ; - out[15 + outpos] = (in[1 + inpos] >>> 28) - ; - out[16 + outpos] = ((in[2 + inpos] >>> 0) & 15) - ; - out[17 + outpos] = ((in[2 + inpos] >>> 4) & 15) - ; - out[18 + outpos] = ((in[2 + inpos] >>> 8) & 15) - ; - out[19 + outpos] = ((in[2 + inpos] >>> 12) & 15) - ; - out[20 + outpos] = ((in[2 + inpos] >>> 16) & 15) - ; - out[21 + outpos] = ((in[2 + inpos] >>> 20) & 15) - ; - out[22 + outpos] = ((in[2 + inpos] >>> 24) & 15) - ; - out[23 + outpos] = (in[2 + inpos] >>> 28) - ; - out[24 + outpos] = ((in[3 + inpos] >>> 0) & 15) - ; - out[25 + outpos] = ((in[3 + inpos] >>> 4) & 15) - ; - out[26 + outpos] = ((in[3 + inpos] >>> 8) & 15) - ; - out[27 + outpos] = ((in[3 + inpos] >>> 12) & 15) - ; - out[28 + outpos] = ((in[3 + inpos] >>> 16) & 15) - ; - out[29 + outpos] = ((in[3 + inpos] >>> 20) & 15) - ; - out[30 + outpos] = ((in[3 + inpos] >>> 24) & 15) - ; - out[31 + outpos] = (in[3 + inpos] >>> 28) - ; - } + protected static void fastpack5(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = (in[0 + inpos] & 31) + | ((in[1 + inpos] & 31) << 5) + | ((in[2 + inpos] & 31) << 10) + | ((in[3 + inpos] & 31) << 15) + | ((in[4 + inpos] & 31) << 20) + | ((in[5 + inpos] & 31) << 25) + | ((in[6 + inpos]) << 30); + out[1 + outpos] = ((in[6 + inpos] & 31) >>> (5 - 3)) + | ((in[7 + inpos] & 31) << 3) + | ((in[8 + inpos] & 31) << 8) + | ((in[9 + inpos] & 31) << 13) + | ((in[10 + inpos] & 31) << 18) + | ((in[11 + inpos] & 31) << 23) + | ((in[12 + inpos]) << 28); + out[2 + outpos] = ((in[12 + inpos] & 31) >>> (5 - 1)) + | ((in[13 + inpos] & 31) << 1) + | ((in[14 + inpos] & 31) << 6) + | ((in[15 + inpos] & 31) << 11) + | ((in[16 + inpos] & 31) << 16) + | ((in[17 + inpos] & 31) << 21) + | ((in[18 + inpos] & 31) << 26) + | ((in[19 + inpos]) << 31); + out[3 + outpos] = ((in[19 + inpos] & 31) >>> (5 - 4)) + | ((in[20 + inpos] & 31) << 4) + | ((in[21 + inpos] & 31) << 9) + | ((in[22 + inpos] & 31) << 14) + | ((in[23 + inpos] & 31) << 19) + | ((in[24 + inpos] & 31) << 24) + | ((in[25 + inpos]) << 29); + out[4 + outpos] = ((in[25 + inpos] & 31) >>> (5 - 2)) + | ((in[26 + inpos] & 31) << 2) + | ((in[27 + inpos] & 31) << 7) + | ((in[28 + inpos] & 31) << 12) + | ((in[29 + inpos] & 31) << 17) + | ((in[30 + inpos] & 31) << 22) + | ((in[31 + inpos]) << 27); + } + protected static void fastpack6(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = (in[0 + inpos] & 63) + | ((in[1 + inpos] & 63) << 6) + | ((in[2 + inpos] & 63) << 12) + | ((in[3 + inpos] & 63) << 18) + | ((in[4 + inpos] & 63) << 24) + | ((in[5 + inpos]) << 30); + out[1 + outpos] = ((in[5 + inpos] & 63) >>> (6 - 4)) + | ((in[6 + inpos] & 63) << 4) + | ((in[7 + inpos] & 63) << 10) + | ((in[8 + inpos] & 63) << 16) + | ((in[9 + inpos] & 63) << 22) + | ((in[10 + inpos]) << 28); + out[2 + outpos] = ((in[10 + inpos] & 63) >>> (6 - 2)) + | ((in[11 + inpos] & 63) << 2) + | ((in[12 + inpos] & 63) << 8) + | ((in[13 + inpos] & 63) << 14) + | ((in[14 + inpos] & 63) << 20) + | ((in[15 + inpos]) << 26); + out[3 + outpos] = (in[16 + inpos] & 63) + | ((in[17 + inpos] & 63) << 6) + | ((in[18 + inpos] & 63) << 12) + | ((in[19 + inpos] & 63) << 18) + | ((in[20 + inpos] & 63) << 24) + | ((in[21 + inpos]) << 30); + out[4 + outpos] = ((in[21 + inpos] & 63) >>> (6 - 4)) + | ((in[22 + inpos] & 63) << 4) + | ((in[23 + inpos] & 63) << 10) + | ((in[24 + inpos] & 63) << 16) + | ((in[25 + inpos] & 63) << 22) + | ((in[26 + inpos]) << 28); + out[5 + outpos] = ((in[26 + inpos] & 63) >>> (6 - 2)) + | ((in[27 + inpos] & 63) << 2) + | ((in[28 + inpos] & 63) << 8) + | ((in[29 + inpos] & 63) << 14) + | ((in[30 + inpos] & 63) << 20) + | ((in[31 + inpos]) << 26); + } - protected static void fastunpack5(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = ((in[0 + inpos] >>> 0) & 31) - ; - out[1 + outpos] = ((in[0 + inpos] >>> 5) & 31) - ; - out[2 + outpos] = ((in[0 + inpos] >>> 10) & 31) - ; - out[3 + outpos] = ((in[0 + inpos] >>> 15) & 31) - ; - out[4 + outpos] = ((in[0 + inpos] >>> 20) & 31) - ; - out[5 + outpos] = ((in[0 + inpos] >>> 25) & 31) - ; - out[6 + outpos] = (in[0 + inpos] >>> 30) - | ((in[1 + inpos] & 7) << (5 - 3)) - ; - out[7 + outpos] = ((in[1 + inpos] >>> 3) & 31) - ; - out[8 + outpos] = ((in[1 + inpos] >>> 8) & 31) - ; - out[9 + outpos] = ((in[1 + inpos] >>> 13) & 31) - ; - out[10 + outpos] = ((in[1 + inpos] >>> 18) & 31) - ; - out[11 + outpos] = ((in[1 + inpos] >>> 23) & 31) - ; - out[12 + outpos] = (in[1 + inpos] >>> 28) - | ((in[2 + inpos] & 1) << (5 - 1)) - ; - out[13 + outpos] = ((in[2 + inpos] >>> 1) & 31) - ; - out[14 + outpos] = ((in[2 + inpos] >>> 6) & 31) - ; - out[15 + outpos] = ((in[2 + inpos] >>> 11) & 31) - ; - out[16 + outpos] = ((in[2 + inpos] >>> 16) & 31) - ; - out[17 + outpos] = ((in[2 + inpos] >>> 21) & 31) - ; - out[18 + outpos] = ((in[2 + inpos] >>> 26) & 31) - ; - out[19 + outpos] = (in[2 + inpos] >>> 31) - | ((in[3 + inpos] & 15) << (5 - 4)) - ; - out[20 + outpos] = ((in[3 + inpos] >>> 4) & 31) - ; - out[21 + outpos] = ((in[3 + inpos] >>> 9) & 31) - ; - out[22 + outpos] = ((in[3 + inpos] >>> 14) & 31) - ; - out[23 + outpos] = ((in[3 + inpos] >>> 19) & 31) - ; - out[24 + outpos] = ((in[3 + inpos] >>> 24) & 31) - ; - out[25 + outpos] = (in[3 + inpos] >>> 29) - | ((in[4 + inpos] & 3) << (5 - 2)) - ; - out[26 + outpos] = ((in[4 + inpos] >>> 2) & 31) - ; - out[27 + outpos] = ((in[4 + inpos] >>> 7) & 31) - ; - out[28 + outpos] = ((in[4 + inpos] >>> 12) & 31) - ; - out[29 + outpos] = ((in[4 + inpos] >>> 17) & 31) - ; - out[30 + outpos] = ((in[4 + inpos] >>> 22) & 31) - ; - out[31 + outpos] = (in[4 + inpos] >>> 27) - ; - } + protected static void fastpack7(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = (in[0 + inpos] & 127) + | ((in[1 + inpos] & 127) << 7) + | ((in[2 + inpos] & 127) << 14) + | ((in[3 + inpos] & 127) << 21) + | ((in[4 + inpos]) << 28); + out[1 + outpos] = ((in[4 + inpos] & 127) >>> (7 - 3)) + | ((in[5 + inpos] & 127) << 3) + | ((in[6 + inpos] & 127) << 10) + | ((in[7 + inpos] & 127) << 17) + | ((in[8 + inpos] & 127) << 24) + | ((in[9 + inpos]) << 31); + out[2 + outpos] = ((in[9 + inpos] & 127) >>> (7 - 6)) + | ((in[10 + inpos] & 127) << 6) + | ((in[11 + inpos] & 127) << 13) + | ((in[12 + inpos] & 127) << 20) + | ((in[13 + inpos]) << 27); + out[3 + outpos] = ((in[13 + inpos] & 127) >>> (7 - 2)) + | ((in[14 + inpos] & 127) << 2) + | ((in[15 + inpos] & 127) << 9) + | ((in[16 + inpos] & 127) << 16) + | ((in[17 + inpos] & 127) << 23) + | ((in[18 + inpos]) << 30); + out[4 + outpos] = ((in[18 + inpos] & 127) >>> (7 - 5)) + | ((in[19 + inpos] & 127) << 5) + | ((in[20 + inpos] & 127) << 12) + | ((in[21 + inpos] & 127) << 19) + | ((in[22 + inpos]) << 26); + out[5 + outpos] = ((in[22 + inpos] & 127) >>> (7 - 1)) + | ((in[23 + inpos] & 127) << 1) + | ((in[24 + inpos] & 127) << 8) + | ((in[25 + inpos] & 127) << 15) + | ((in[26 + inpos] & 127) << 22) + | ((in[27 + inpos]) << 29); + out[6 + outpos] = ((in[27 + inpos] & 127) >>> (7 - 4)) + | ((in[28 + inpos] & 127) << 4) + | ((in[29 + inpos] & 127) << 11) + | ((in[30 + inpos] & 127) << 18) + | ((in[31 + inpos]) << 25); + } + protected static void fastpack8(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = (in[0 + inpos] & 255) + | ((in[1 + inpos] & 255) << 8) + | ((in[2 + inpos] & 255) << 16) + | ((in[3 + inpos]) << 24); + out[1 + outpos] = (in[4 + inpos] & 255) + | ((in[5 + inpos] & 255) << 8) + | ((in[6 + inpos] & 255) << 16) + | ((in[7 + inpos]) << 24); + out[2 + outpos] = (in[8 + inpos] & 255) + | ((in[9 + inpos] & 255) << 8) + | ((in[10 + inpos] & 255) << 16) + | ((in[11 + inpos]) << 24); + out[3 + outpos] = (in[12 + inpos] & 255) + | ((in[13 + inpos] & 255) << 8) + | ((in[14 + inpos] & 255) << 16) + | ((in[15 + inpos]) << 24); + out[4 + outpos] = (in[16 + inpos] & 255) + | ((in[17 + inpos] & 255) << 8) + | ((in[18 + inpos] & 255) << 16) + | ((in[19 + inpos]) << 24); + out[5 + outpos] = (in[20 + inpos] & 255) + | ((in[21 + inpos] & 255) << 8) + | ((in[22 + inpos] & 255) << 16) + | ((in[23 + inpos]) << 24); + out[6 + outpos] = (in[24 + inpos] & 255) + | ((in[25 + inpos] & 255) << 8) + | ((in[26 + inpos] & 255) << 16) + | ((in[27 + inpos]) << 24); + out[7 + outpos] = (in[28 + inpos] & 255) + | ((in[29 + inpos] & 255) << 8) + | ((in[30 + inpos] & 255) << 16) + | ((in[31 + inpos]) << 24); + } - protected static void fastunpack6(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = ((in[0 + inpos] >>> 0) & 63) - ; - out[1 + outpos] = ((in[0 + inpos] >>> 6) & 63) - ; - out[2 + outpos] = ((in[0 + inpos] >>> 12) & 63) - ; - out[3 + outpos] = ((in[0 + inpos] >>> 18) & 63) - ; - out[4 + outpos] = ((in[0 + inpos] >>> 24) & 63) - ; - out[5 + outpos] = (in[0 + inpos] >>> 30) - | ((in[1 + inpos] & 15) << (6 - 4)) - ; - out[6 + outpos] = ((in[1 + inpos] >>> 4) & 63) - ; - out[7 + outpos] = ((in[1 + inpos] >>> 10) & 63) - ; - out[8 + outpos] = ((in[1 + inpos] >>> 16) & 63) - ; - out[9 + outpos] = ((in[1 + inpos] >>> 22) & 63) - ; - out[10 + outpos] = (in[1 + inpos] >>> 28) - | ((in[2 + inpos] & 3) << (6 - 2)) - ; - out[11 + outpos] = ((in[2 + inpos] >>> 2) & 63) - ; - out[12 + outpos] = ((in[2 + inpos] >>> 8) & 63) - ; - out[13 + outpos] = ((in[2 + inpos] >>> 14) & 63) - ; - out[14 + outpos] = ((in[2 + inpos] >>> 20) & 63) - ; - out[15 + outpos] = (in[2 + inpos] >>> 26) - ; - out[16 + outpos] = ((in[3 + inpos] >>> 0) & 63) - ; - out[17 + outpos] = ((in[3 + inpos] >>> 6) & 63) - ; - out[18 + outpos] = ((in[3 + inpos] >>> 12) & 63) - ; - out[19 + outpos] = ((in[3 + inpos] >>> 18) & 63) - ; - out[20 + outpos] = ((in[3 + inpos] >>> 24) & 63) - ; - out[21 + outpos] = (in[3 + inpos] >>> 30) - | ((in[4 + inpos] & 15) << (6 - 4)) - ; - out[22 + outpos] = ((in[4 + inpos] >>> 4) & 63) - ; - out[23 + outpos] = ((in[4 + inpos] >>> 10) & 63) - ; - out[24 + outpos] = ((in[4 + inpos] >>> 16) & 63) - ; - out[25 + outpos] = ((in[4 + inpos] >>> 22) & 63) - ; - out[26 + outpos] = (in[4 + inpos] >>> 28) - | ((in[5 + inpos] & 3) << (6 - 2)) - ; - out[27 + outpos] = ((in[5 + inpos] >>> 2) & 63) - ; - out[28 + outpos] = ((in[5 + inpos] >>> 8) & 63) - ; - out[29 + outpos] = ((in[5 + inpos] >>> 14) & 63) - ; - out[30 + outpos] = ((in[5 + inpos] >>> 20) & 63) - ; - out[31 + outpos] = (in[5 + inpos] >>> 26) - ; - } + protected static void fastpack9(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = (in[0 + inpos] & 511) + | ((in[1 + inpos] & 511) << 9) + | ((in[2 + inpos] & 511) << 18) + | ((in[3 + inpos]) << 27); + out[1 + outpos] = ((in[3 + inpos] & 511) >>> (9 - 4)) + | ((in[4 + inpos] & 511) << 4) + | ((in[5 + inpos] & 511) << 13) + | ((in[6 + inpos] & 511) << 22) + | ((in[7 + inpos]) << 31); + out[2 + outpos] = ((in[7 + inpos] & 511) >>> (9 - 8)) + | ((in[8 + inpos] & 511) << 8) + | ((in[9 + inpos] & 511) << 17) + | ((in[10 + inpos]) << 26); + out[3 + outpos] = ((in[10 + inpos] & 511) >>> (9 - 3)) + | ((in[11 + inpos] & 511) << 3) + | ((in[12 + inpos] & 511) << 12) + | ((in[13 + inpos] & 511) << 21) + | ((in[14 + inpos]) << 30); + out[4 + outpos] = ((in[14 + inpos] & 511) >>> (9 - 7)) + | ((in[15 + inpos] & 511) << 7) + | ((in[16 + inpos] & 511) << 16) + | ((in[17 + inpos]) << 25); + out[5 + outpos] = ((in[17 + inpos] & 511) >>> (9 - 2)) + | ((in[18 + inpos] & 511) << 2) + | ((in[19 + inpos] & 511) << 11) + | ((in[20 + inpos] & 511) << 20) + | ((in[21 + inpos]) << 29); + out[6 + outpos] = ((in[21 + inpos] & 511) >>> (9 - 6)) + | ((in[22 + inpos] & 511) << 6) + | ((in[23 + inpos] & 511) << 15) + | ((in[24 + inpos]) << 24); + out[7 + outpos] = ((in[24 + inpos] & 511) >>> (9 - 1)) + | ((in[25 + inpos] & 511) << 1) + | ((in[26 + inpos] & 511) << 10) + | ((in[27 + inpos] & 511) << 19) + | ((in[28 + inpos]) << 28); + out[8 + outpos] = ((in[28 + inpos] & 511) >>> (9 - 5)) + | ((in[29 + inpos] & 511) << 5) + | ((in[30 + inpos] & 511) << 14) + | ((in[31 + inpos]) << 23); + } + /** + * Pack without mask 32 integers + * + * @param in + * source array + * @param inpos + * position in source array + * @param out + * output array + * @param outpos + * position in output array + * @param bit + * number of bits to use per integer + */ + public static void fastpackwithoutmask(final int[] in, final int inpos, + final int[] out, final int outpos, final int bit) { + switch (bit) { + case 0: + fastpackwithoutmask0(in, inpos, out, outpos); + break; + case 1: + fastpackwithoutmask1(in, inpos, out, outpos); + break; + case 2: + fastpackwithoutmask2(in, inpos, out, outpos); + break; + case 3: + fastpackwithoutmask3(in, inpos, out, outpos); + break; + case 4: + fastpackwithoutmask4(in, inpos, out, outpos); + break; + case 5: + fastpackwithoutmask5(in, inpos, out, outpos); + break; + case 6: + fastpackwithoutmask6(in, inpos, out, outpos); + break; + case 7: + fastpackwithoutmask7(in, inpos, out, outpos); + break; + case 8: + fastpackwithoutmask8(in, inpos, out, outpos); + break; + case 9: + fastpackwithoutmask9(in, inpos, out, outpos); + break; + case 10: + fastpackwithoutmask10(in, inpos, out, outpos); + break; + case 11: + fastpackwithoutmask11(in, inpos, out, outpos); + break; + case 12: + fastpackwithoutmask12(in, inpos, out, outpos); + break; + case 13: + fastpackwithoutmask13(in, inpos, out, outpos); + break; + case 14: + fastpackwithoutmask14(in, inpos, out, outpos); + break; + case 15: + fastpackwithoutmask15(in, inpos, out, outpos); + break; + case 16: + fastpackwithoutmask16(in, inpos, out, outpos); + break; + case 17: + fastpackwithoutmask17(in, inpos, out, outpos); + break; + case 18: + fastpackwithoutmask18(in, inpos, out, outpos); + break; + case 19: + fastpackwithoutmask19(in, inpos, out, outpos); + break; + case 20: + fastpackwithoutmask20(in, inpos, out, outpos); + break; + case 21: + fastpackwithoutmask21(in, inpos, out, outpos); + break; + case 22: + fastpackwithoutmask22(in, inpos, out, outpos); + break; + case 23: + fastpackwithoutmask23(in, inpos, out, outpos); + break; + case 24: + fastpackwithoutmask24(in, inpos, out, outpos); + break; + case 25: + fastpackwithoutmask25(in, inpos, out, outpos); + break; + case 26: + fastpackwithoutmask26(in, inpos, out, outpos); + break; + case 27: + fastpackwithoutmask27(in, inpos, out, outpos); + break; + case 28: + fastpackwithoutmask28(in, inpos, out, outpos); + break; + case 29: + fastpackwithoutmask29(in, inpos, out, outpos); + break; + case 30: + fastpackwithoutmask30(in, inpos, out, outpos); + break; + case 31: + fastpackwithoutmask31(in, inpos, out, outpos); + break; + case 32: + fastpackwithoutmask32(in, inpos, out, outpos); + break; + default: + throw new IllegalArgumentException( + "Unsupported bit width."); + } + } - protected static void fastunpack7(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = ((in[0 + inpos] >>> 0) & 127) - ; - out[1 + outpos] = ((in[0 + inpos] >>> 7) & 127) - ; - out[2 + outpos] = ((in[0 + inpos] >>> 14) & 127) - ; - out[3 + outpos] = ((in[0 + inpos] >>> 21) & 127) - ; - out[4 + outpos] = (in[0 + inpos] >>> 28) - | ((in[1 + inpos] & 7) << (7 - 3)) - ; - out[5 + outpos] = ((in[1 + inpos] >>> 3) & 127) - ; - out[6 + outpos] = ((in[1 + inpos] >>> 10) & 127) - ; - out[7 + outpos] = ((in[1 + inpos] >>> 17) & 127) - ; - out[8 + outpos] = ((in[1 + inpos] >>> 24) & 127) - ; - out[9 + outpos] = (in[1 + inpos] >>> 31) - | ((in[2 + inpos] & 63) << (7 - 6)) - ; - out[10 + outpos] = ((in[2 + inpos] >>> 6) & 127) - ; - out[11 + outpos] = ((in[2 + inpos] >>> 13) & 127) - ; - out[12 + outpos] = ((in[2 + inpos] >>> 20) & 127) - ; - out[13 + outpos] = (in[2 + inpos] >>> 27) - | ((in[3 + inpos] & 3) << (7 - 2)) - ; - out[14 + outpos] = ((in[3 + inpos] >>> 2) & 127) - ; - out[15 + outpos] = ((in[3 + inpos] >>> 9) & 127) - ; - out[16 + outpos] = ((in[3 + inpos] >>> 16) & 127) - ; - out[17 + outpos] = ((in[3 + inpos] >>> 23) & 127) - ; - out[18 + outpos] = (in[3 + inpos] >>> 30) - | ((in[4 + inpos] & 31) << (7 - 5)) - ; - out[19 + outpos] = ((in[4 + inpos] >>> 5) & 127) - ; - out[20 + outpos] = ((in[4 + inpos] >>> 12) & 127) - ; - out[21 + outpos] = ((in[4 + inpos] >>> 19) & 127) - ; - out[22 + outpos] = (in[4 + inpos] >>> 26) - | ((in[5 + inpos] & 1) << (7 - 1)) - ; - out[23 + outpos] = ((in[5 + inpos] >>> 1) & 127) - ; - out[24 + outpos] = ((in[5 + inpos] >>> 8) & 127) - ; - out[25 + outpos] = ((in[5 + inpos] >>> 15) & 127) - ; - out[26 + outpos] = ((in[5 + inpos] >>> 22) & 127) - ; - out[27 + outpos] = (in[5 + inpos] >>> 29) - | ((in[6 + inpos] & 15) << (7 - 4)) - ; - out[28 + outpos] = ((in[6 + inpos] >>> 4) & 127) - ; - out[29 + outpos] = ((in[6 + inpos] >>> 11) & 127) - ; - out[30 + outpos] = ((in[6 + inpos] >>> 18) & 127) - ; - out[31 + outpos] = (in[6 + inpos] >>> 25) - ; - } + protected static void fastpackwithoutmask0(final int[] in, int inpos, + final int[] out, int outpos) { + // nothing + } + protected static void fastpackwithoutmask1(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = in[0 + inpos] | ((in[1 + inpos]) << 1) + | ((in[2 + inpos]) << 2) | ((in[3 + inpos]) << 3) + | ((in[4 + inpos]) << 4) | ((in[5 + inpos]) << 5) + | ((in[6 + inpos]) << 6) | ((in[7 + inpos]) << 7) + | ((in[8 + inpos]) << 8) | ((in[9 + inpos]) << 9) + | ((in[10 + inpos]) << 10) | ((in[11 + inpos]) << 11) + | ((in[12 + inpos]) << 12) | ((in[13 + inpos]) << 13) + | ((in[14 + inpos]) << 14) | ((in[15 + inpos]) << 15) + | ((in[16 + inpos]) << 16) | ((in[17 + inpos]) << 17) + | ((in[18 + inpos]) << 18) | ((in[19 + inpos]) << 19) + | ((in[20 + inpos]) << 20) | ((in[21 + inpos]) << 21) + | ((in[22 + inpos]) << 22) | ((in[23 + inpos]) << 23) + | ((in[24 + inpos]) << 24) | ((in[25 + inpos]) << 25) + | ((in[26 + inpos]) << 26) | ((in[27 + inpos]) << 27) + | ((in[28 + inpos]) << 28) | ((in[29 + inpos]) << 29) + | ((in[30 + inpos]) << 30) | ((in[31 + inpos]) << 31); + } - protected static void fastunpack8(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = ((in[0 + inpos] >>> 0) & 255) - ; - out[1 + outpos] = ((in[0 + inpos] >>> 8) & 255) - ; - out[2 + outpos] = ((in[0 + inpos] >>> 16) & 255) - ; - out[3 + outpos] = (in[0 + inpos] >>> 24) - ; - out[4 + outpos] = ((in[1 + inpos] >>> 0) & 255) - ; - out[5 + outpos] = ((in[1 + inpos] >>> 8) & 255) - ; - out[6 + outpos] = ((in[1 + inpos] >>> 16) & 255) - ; - out[7 + outpos] = (in[1 + inpos] >>> 24) - ; - out[8 + outpos] = ((in[2 + inpos] >>> 0) & 255) - ; - out[9 + outpos] = ((in[2 + inpos] >>> 8) & 255) - ; - out[10 + outpos] = ((in[2 + inpos] >>> 16) & 255) - ; - out[11 + outpos] = (in[2 + inpos] >>> 24) - ; - out[12 + outpos] = ((in[3 + inpos] >>> 0) & 255) - ; - out[13 + outpos] = ((in[3 + inpos] >>> 8) & 255) - ; - out[14 + outpos] = ((in[3 + inpos] >>> 16) & 255) - ; - out[15 + outpos] = (in[3 + inpos] >>> 24) - ; - out[16 + outpos] = ((in[4 + inpos] >>> 0) & 255) - ; - out[17 + outpos] = ((in[4 + inpos] >>> 8) & 255) - ; - out[18 + outpos] = ((in[4 + inpos] >>> 16) & 255) - ; - out[19 + outpos] = (in[4 + inpos] >>> 24) - ; - out[20 + outpos] = ((in[5 + inpos] >>> 0) & 255) - ; - out[21 + outpos] = ((in[5 + inpos] >>> 8) & 255) - ; - out[22 + outpos] = ((in[5 + inpos] >>> 16) & 255) - ; - out[23 + outpos] = (in[5 + inpos] >>> 24) - ; - out[24 + outpos] = ((in[6 + inpos] >>> 0) & 255) - ; - out[25 + outpos] = ((in[6 + inpos] >>> 8) & 255) - ; - out[26 + outpos] = ((in[6 + inpos] >>> 16) & 255) - ; - out[27 + outpos] = (in[6 + inpos] >>> 24) - ; - out[28 + outpos] = ((in[7 + inpos] >>> 0) & 255) - ; - out[29 + outpos] = ((in[7 + inpos] >>> 8) & 255) - ; - out[30 + outpos] = ((in[7 + inpos] >>> 16) & 255) - ; - out[31 + outpos] = (in[7 + inpos] >>> 24) - ; - } + protected static void fastpackwithoutmask10(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = in[0 + inpos] | ((in[1 + inpos]) << 10) + | ((in[2 + inpos]) << 20) | ((in[3 + inpos]) << 30); + out[1 + outpos] = ((in[3 + inpos]) >>> (10 - 8)) + | ((in[4 + inpos]) << 8) | ((in[5 + inpos]) << 18) + | ((in[6 + inpos]) << 28); + out[2 + outpos] = ((in[6 + inpos]) >>> (10 - 6)) + | ((in[7 + inpos]) << 6) | ((in[8 + inpos]) << 16) + | ((in[9 + inpos]) << 26); + out[3 + outpos] = ((in[9 + inpos]) >>> (10 - 4)) + | ((in[10 + inpos]) << 4) | ((in[11 + inpos]) << 14) + | ((in[12 + inpos]) << 24); + out[4 + outpos] = ((in[12 + inpos]) >>> (10 - 2)) + | ((in[13 + inpos]) << 2) | ((in[14 + inpos]) << 12) + | ((in[15 + inpos]) << 22); + out[5 + outpos] = in[16 + inpos] | ((in[17 + inpos]) << 10) + | ((in[18 + inpos]) << 20) | ((in[19 + inpos]) << 30); + out[6 + outpos] = ((in[19 + inpos]) >>> (10 - 8)) + | ((in[20 + inpos]) << 8) | ((in[21 + inpos]) << 18) + | ((in[22 + inpos]) << 28); + out[7 + outpos] = ((in[22 + inpos]) >>> (10 - 6)) + | ((in[23 + inpos]) << 6) | ((in[24 + inpos]) << 16) + | ((in[25 + inpos]) << 26); + out[8 + outpos] = ((in[25 + inpos]) >>> (10 - 4)) + | ((in[26 + inpos]) << 4) | ((in[27 + inpos]) << 14) + | ((in[28 + inpos]) << 24); + out[9 + outpos] = ((in[28 + inpos]) >>> (10 - 2)) + | ((in[29 + inpos]) << 2) | ((in[30 + inpos]) << 12) + | ((in[31 + inpos]) << 22); + } + protected static void fastpackwithoutmask11(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = in[0 + inpos] | ((in[1 + inpos]) << 11) + | ((in[2 + inpos]) << 22); + out[1 + outpos] = ((in[2 + inpos]) >>> (11 - 1)) + | ((in[3 + inpos]) << 1) | ((in[4 + inpos]) << 12) + | ((in[5 + inpos]) << 23); + out[2 + outpos] = ((in[5 + inpos]) >>> (11 - 2)) + | ((in[6 + inpos]) << 2) | ((in[7 + inpos]) << 13) + | ((in[8 + inpos]) << 24); + out[3 + outpos] = ((in[8 + inpos]) >>> (11 - 3)) + | ((in[9 + inpos]) << 3) | ((in[10 + inpos]) << 14) + | ((in[11 + inpos]) << 25); + out[4 + outpos] = ((in[11 + inpos]) >>> (11 - 4)) + | ((in[12 + inpos]) << 4) | ((in[13 + inpos]) << 15) + | ((in[14 + inpos]) << 26); + out[5 + outpos] = ((in[14 + inpos]) >>> (11 - 5)) + | ((in[15 + inpos]) << 5) | ((in[16 + inpos]) << 16) + | ((in[17 + inpos]) << 27); + out[6 + outpos] = ((in[17 + inpos]) >>> (11 - 6)) + | ((in[18 + inpos]) << 6) | ((in[19 + inpos]) << 17) + | ((in[20 + inpos]) << 28); + out[7 + outpos] = ((in[20 + inpos]) >>> (11 - 7)) + | ((in[21 + inpos]) << 7) | ((in[22 + inpos]) << 18) + | ((in[23 + inpos]) << 29); + out[8 + outpos] = ((in[23 + inpos]) >>> (11 - 8)) + | ((in[24 + inpos]) << 8) | ((in[25 + inpos]) << 19) + | ((in[26 + inpos]) << 30); + out[9 + outpos] = ((in[26 + inpos]) >>> (11 - 9)) + | ((in[27 + inpos]) << 9) | ((in[28 + inpos]) << 20) + | ((in[29 + inpos]) << 31); + out[10 + outpos] = ((in[29 + inpos]) >>> (11 - 10)) + | ((in[30 + inpos]) << 10) | ((in[31 + inpos]) << 21); + } - protected static void fastunpack9(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = ((in[0 + inpos] >>> 0) & 511) - ; - out[1 + outpos] = ((in[0 + inpos] >>> 9) & 511) - ; - out[2 + outpos] = ((in[0 + inpos] >>> 18) & 511) - ; - out[3 + outpos] = (in[0 + inpos] >>> 27) - | ((in[1 + inpos] & 15) << (9 - 4)) - ; - out[4 + outpos] = ((in[1 + inpos] >>> 4) & 511) - ; - out[5 + outpos] = ((in[1 + inpos] >>> 13) & 511) - ; - out[6 + outpos] = ((in[1 + inpos] >>> 22) & 511) - ; - out[7 + outpos] = (in[1 + inpos] >>> 31) - | ((in[2 + inpos] & 255) << (9 - 8)) - ; - out[8 + outpos] = ((in[2 + inpos] >>> 8) & 511) - ; - out[9 + outpos] = ((in[2 + inpos] >>> 17) & 511) - ; - out[10 + outpos] = (in[2 + inpos] >>> 26) - | ((in[3 + inpos] & 7) << (9 - 3)) - ; - out[11 + outpos] = ((in[3 + inpos] >>> 3) & 511) - ; - out[12 + outpos] = ((in[3 + inpos] >>> 12) & 511) - ; - out[13 + outpos] = ((in[3 + inpos] >>> 21) & 511) - ; - out[14 + outpos] = (in[3 + inpos] >>> 30) - | ((in[4 + inpos] & 127) << (9 - 7)) - ; - out[15 + outpos] = ((in[4 + inpos] >>> 7) & 511) - ; - out[16 + outpos] = ((in[4 + inpos] >>> 16) & 511) - ; - out[17 + outpos] = (in[4 + inpos] >>> 25) - | ((in[5 + inpos] & 3) << (9 - 2)) - ; - out[18 + outpos] = ((in[5 + inpos] >>> 2) & 511) - ; - out[19 + outpos] = ((in[5 + inpos] >>> 11) & 511) - ; - out[20 + outpos] = ((in[5 + inpos] >>> 20) & 511) - ; - out[21 + outpos] = (in[5 + inpos] >>> 29) - | ((in[6 + inpos] & 63) << (9 - 6)) - ; - out[22 + outpos] = ((in[6 + inpos] >>> 6) & 511) - ; - out[23 + outpos] = ((in[6 + inpos] >>> 15) & 511) - ; - out[24 + outpos] = (in[6 + inpos] >>> 24) - | ((in[7 + inpos] & 1) << (9 - 1)) - ; - out[25 + outpos] = ((in[7 + inpos] >>> 1) & 511) - ; - out[26 + outpos] = ((in[7 + inpos] >>> 10) & 511) - ; - out[27 + outpos] = ((in[7 + inpos] >>> 19) & 511) - ; - out[28 + outpos] = (in[7 + inpos] >>> 28) - | ((in[8 + inpos] & 31) << (9 - 5)) - ; - out[29 + outpos] = ((in[8 + inpos] >>> 5) & 511) - ; - out[30 + outpos] = ((in[8 + inpos] >>> 14) & 511) - ; - out[31 + outpos] = (in[8 + inpos] >>> 23) - ; - } + protected static void fastpackwithoutmask12(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = in[0 + inpos] | ((in[1 + inpos]) << 12) + | ((in[2 + inpos]) << 24); + out[1 + outpos] = ((in[2 + inpos]) >>> (12 - 4)) + | ((in[3 + inpos]) << 4) | ((in[4 + inpos]) << 16) + | ((in[5 + inpos]) << 28); + out[2 + outpos] = ((in[5 + inpos]) >>> (12 - 8)) + | ((in[6 + inpos]) << 8) | ((in[7 + inpos]) << 20); + out[3 + outpos] = in[8 + inpos] | ((in[9 + inpos]) << 12) + | ((in[10 + inpos]) << 24); + out[4 + outpos] = ((in[10 + inpos]) >>> (12 - 4)) + | ((in[11 + inpos]) << 4) | ((in[12 + inpos]) << 16) + | ((in[13 + inpos]) << 28); + out[5 + outpos] = ((in[13 + inpos]) >>> (12 - 8)) + | ((in[14 + inpos]) << 8) | ((in[15 + inpos]) << 20); + out[6 + outpos] = in[16 + inpos] | ((in[17 + inpos]) << 12) + | ((in[18 + inpos]) << 24); + out[7 + outpos] = ((in[18 + inpos]) >>> (12 - 4)) + | ((in[19 + inpos]) << 4) | ((in[20 + inpos]) << 16) + | ((in[21 + inpos]) << 28); + out[8 + outpos] = ((in[21 + inpos]) >>> (12 - 8)) + | ((in[22 + inpos]) << 8) | ((in[23 + inpos]) << 20); + out[9 + outpos] = in[24 + inpos] | ((in[25 + inpos]) << 12) + | ((in[26 + inpos]) << 24); + out[10 + outpos] = ((in[26 + inpos]) >>> (12 - 4)) + | ((in[27 + inpos]) << 4) | ((in[28 + inpos]) << 16) + | ((in[29 + inpos]) << 28); + out[11 + outpos] = ((in[29 + inpos]) >>> (12 - 8)) + | ((in[30 + inpos]) << 8) | ((in[31 + inpos]) << 20); + } + protected static void fastpackwithoutmask13(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = in[0 + inpos] | ((in[1 + inpos]) << 13) + | ((in[2 + inpos]) << 26); + out[1 + outpos] = ((in[2 + inpos]) >>> (13 - 7)) + | ((in[3 + inpos]) << 7) | ((in[4 + inpos]) << 20); + out[2 + outpos] = ((in[4 + inpos]) >>> (13 - 1)) + | ((in[5 + inpos]) << 1) | ((in[6 + inpos]) << 14) + | ((in[7 + inpos]) << 27); + out[3 + outpos] = ((in[7 + inpos]) >>> (13 - 8)) + | ((in[8 + inpos]) << 8) | ((in[9 + inpos]) << 21); + out[4 + outpos] = ((in[9 + inpos]) >>> (13 - 2)) + | ((in[10 + inpos]) << 2) | ((in[11 + inpos]) << 15) + | ((in[12 + inpos]) << 28); + out[5 + outpos] = ((in[12 + inpos]) >>> (13 - 9)) + | ((in[13 + inpos]) << 9) | ((in[14 + inpos]) << 22); + out[6 + outpos] = ((in[14 + inpos]) >>> (13 - 3)) + | ((in[15 + inpos]) << 3) | ((in[16 + inpos]) << 16) + | ((in[17 + inpos]) << 29); + out[7 + outpos] = ((in[17 + inpos]) >>> (13 - 10)) + | ((in[18 + inpos]) << 10) | ((in[19 + inpos]) << 23); + out[8 + outpos] = ((in[19 + inpos]) >>> (13 - 4)) + | ((in[20 + inpos]) << 4) | ((in[21 + inpos]) << 17) + | ((in[22 + inpos]) << 30); + out[9 + outpos] = ((in[22 + inpos]) >>> (13 - 11)) + | ((in[23 + inpos]) << 11) | ((in[24 + inpos]) << 24); + out[10 + outpos] = ((in[24 + inpos]) >>> (13 - 5)) + | ((in[25 + inpos]) << 5) | ((in[26 + inpos]) << 18) + | ((in[27 + inpos]) << 31); + out[11 + outpos] = ((in[27 + inpos]) >>> (13 - 12)) + | ((in[28 + inpos]) << 12) | ((in[29 + inpos]) << 25); + out[12 + outpos] = ((in[29 + inpos]) >>> (13 - 6)) + | ((in[30 + inpos]) << 6) | ((in[31 + inpos]) << 19); + } - protected static void fastunpack10(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = ((in[0 + inpos] >>> 0) & 1023) - ; - out[1 + outpos] = ((in[0 + inpos] >>> 10) & 1023) - ; - out[2 + outpos] = ((in[0 + inpos] >>> 20) & 1023) - ; - out[3 + outpos] = (in[0 + inpos] >>> 30) - | ((in[1 + inpos] & 255) << (10 - 8)) - ; - out[4 + outpos] = ((in[1 + inpos] >>> 8) & 1023) - ; - out[5 + outpos] = ((in[1 + inpos] >>> 18) & 1023) - ; - out[6 + outpos] = (in[1 + inpos] >>> 28) - | ((in[2 + inpos] & 63) << (10 - 6)) - ; - out[7 + outpos] = ((in[2 + inpos] >>> 6) & 1023) - ; - out[8 + outpos] = ((in[2 + inpos] >>> 16) & 1023) - ; - out[9 + outpos] = (in[2 + inpos] >>> 26) - | ((in[3 + inpos] & 15) << (10 - 4)) - ; - out[10 + outpos] = ((in[3 + inpos] >>> 4) & 1023) - ; - out[11 + outpos] = ((in[3 + inpos] >>> 14) & 1023) - ; - out[12 + outpos] = (in[3 + inpos] >>> 24) - | ((in[4 + inpos] & 3) << (10 - 2)) - ; - out[13 + outpos] = ((in[4 + inpos] >>> 2) & 1023) - ; - out[14 + outpos] = ((in[4 + inpos] >>> 12) & 1023) - ; - out[15 + outpos] = (in[4 + inpos] >>> 22) - ; - out[16 + outpos] = ((in[5 + inpos] >>> 0) & 1023) - ; - out[17 + outpos] = ((in[5 + inpos] >>> 10) & 1023) - ; - out[18 + outpos] = ((in[5 + inpos] >>> 20) & 1023) - ; - out[19 + outpos] = (in[5 + inpos] >>> 30) - | ((in[6 + inpos] & 255) << (10 - 8)) - ; - out[20 + outpos] = ((in[6 + inpos] >>> 8) & 1023) - ; - out[21 + outpos] = ((in[6 + inpos] >>> 18) & 1023) - ; - out[22 + outpos] = (in[6 + inpos] >>> 28) - | ((in[7 + inpos] & 63) << (10 - 6)) - ; - out[23 + outpos] = ((in[7 + inpos] >>> 6) & 1023) - ; - out[24 + outpos] = ((in[7 + inpos] >>> 16) & 1023) - ; - out[25 + outpos] = (in[7 + inpos] >>> 26) - | ((in[8 + inpos] & 15) << (10 - 4)) - ; - out[26 + outpos] = ((in[8 + inpos] >>> 4) & 1023) - ; - out[27 + outpos] = ((in[8 + inpos] >>> 14) & 1023) - ; - out[28 + outpos] = (in[8 + inpos] >>> 24) - | ((in[9 + inpos] & 3) << (10 - 2)) - ; - out[29 + outpos] = ((in[9 + inpos] >>> 2) & 1023) - ; - out[30 + outpos] = ((in[9 + inpos] >>> 12) & 1023) - ; - out[31 + outpos] = (in[9 + inpos] >>> 22) - ; - } + protected static void fastpackwithoutmask14(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = in[0 + inpos] | ((in[1 + inpos]) << 14) + | ((in[2 + inpos]) << 28); + out[1 + outpos] = ((in[2 + inpos]) >>> (14 - 10)) + | ((in[3 + inpos]) << 10) | ((in[4 + inpos]) << 24); + out[2 + outpos] = ((in[4 + inpos]) >>> (14 - 6)) + | ((in[5 + inpos]) << 6) | ((in[6 + inpos]) << 20); + out[3 + outpos] = ((in[6 + inpos]) >>> (14 - 2)) + | ((in[7 + inpos]) << 2) | ((in[8 + inpos]) << 16) + | ((in[9 + inpos]) << 30); + out[4 + outpos] = ((in[9 + inpos]) >>> (14 - 12)) + | ((in[10 + inpos]) << 12) | ((in[11 + inpos]) << 26); + out[5 + outpos] = ((in[11 + inpos]) >>> (14 - 8)) + | ((in[12 + inpos]) << 8) | ((in[13 + inpos]) << 22); + out[6 + outpos] = ((in[13 + inpos]) >>> (14 - 4)) + | ((in[14 + inpos]) << 4) | ((in[15 + inpos]) << 18); + out[7 + outpos] = in[16 + inpos] | ((in[17 + inpos]) << 14) + | ((in[18 + inpos]) << 28); + out[8 + outpos] = ((in[18 + inpos]) >>> (14 - 10)) + | ((in[19 + inpos]) << 10) | ((in[20 + inpos]) << 24); + out[9 + outpos] = ((in[20 + inpos]) >>> (14 - 6)) + | ((in[21 + inpos]) << 6) | ((in[22 + inpos]) << 20); + out[10 + outpos] = ((in[22 + inpos]) >>> (14 - 2)) + | ((in[23 + inpos]) << 2) | ((in[24 + inpos]) << 16) + | ((in[25 + inpos]) << 30); + out[11 + outpos] = ((in[25 + inpos]) >>> (14 - 12)) + | ((in[26 + inpos]) << 12) | ((in[27 + inpos]) << 26); + out[12 + outpos] = ((in[27 + inpos]) >>> (14 - 8)) + | ((in[28 + inpos]) << 8) | ((in[29 + inpos]) << 22); + out[13 + outpos] = ((in[29 + inpos]) >>> (14 - 4)) + | ((in[30 + inpos]) << 4) | ((in[31 + inpos]) << 18); + } + protected static void fastpackwithoutmask15(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = in[0 + inpos] | ((in[1 + inpos]) << 15) + | ((in[2 + inpos]) << 30); + out[1 + outpos] = ((in[2 + inpos]) >>> (15 - 13)) + | ((in[3 + inpos]) << 13) | ((in[4 + inpos]) << 28); + out[2 + outpos] = ((in[4 + inpos]) >>> (15 - 11)) + | ((in[5 + inpos]) << 11) | ((in[6 + inpos]) << 26); + out[3 + outpos] = ((in[6 + inpos]) >>> (15 - 9)) + | ((in[7 + inpos]) << 9) | ((in[8 + inpos]) << 24); + out[4 + outpos] = ((in[8 + inpos]) >>> (15 - 7)) + | ((in[9 + inpos]) << 7) | ((in[10 + inpos]) << 22); + out[5 + outpos] = ((in[10 + inpos]) >>> (15 - 5)) + | ((in[11 + inpos]) << 5) | ((in[12 + inpos]) << 20); + out[6 + outpos] = ((in[12 + inpos]) >>> (15 - 3)) + | ((in[13 + inpos]) << 3) | ((in[14 + inpos]) << 18); + out[7 + outpos] = ((in[14 + inpos]) >>> (15 - 1)) + | ((in[15 + inpos]) << 1) | ((in[16 + inpos]) << 16) + | ((in[17 + inpos]) << 31); + out[8 + outpos] = ((in[17 + inpos]) >>> (15 - 14)) + | ((in[18 + inpos]) << 14) | ((in[19 + inpos]) << 29); + out[9 + outpos] = ((in[19 + inpos]) >>> (15 - 12)) + | ((in[20 + inpos]) << 12) | ((in[21 + inpos]) << 27); + out[10 + outpos] = ((in[21 + inpos]) >>> (15 - 10)) + | ((in[22 + inpos]) << 10) | ((in[23 + inpos]) << 25); + out[11 + outpos] = ((in[23 + inpos]) >>> (15 - 8)) + | ((in[24 + inpos]) << 8) | ((in[25 + inpos]) << 23); + out[12 + outpos] = ((in[25 + inpos]) >>> (15 - 6)) + | ((in[26 + inpos]) << 6) | ((in[27 + inpos]) << 21); + out[13 + outpos] = ((in[27 + inpos]) >>> (15 - 4)) + | ((in[28 + inpos]) << 4) | ((in[29 + inpos]) << 19); + out[14 + outpos] = ((in[29 + inpos]) >>> (15 - 2)) + | ((in[30 + inpos]) << 2) | ((in[31 + inpos]) << 17); + } - protected static void fastunpack11(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = ((in[0 + inpos] >>> 0) & 2047) - ; - out[1 + outpos] = ((in[0 + inpos] >>> 11) & 2047) - ; - out[2 + outpos] = (in[0 + inpos] >>> 22) - | ((in[1 + inpos] & 1) << (11 - 1)) - ; - out[3 + outpos] = ((in[1 + inpos] >>> 1) & 2047) - ; - out[4 + outpos] = ((in[1 + inpos] >>> 12) & 2047) - ; - out[5 + outpos] = (in[1 + inpos] >>> 23) - | ((in[2 + inpos] & 3) << (11 - 2)) - ; - out[6 + outpos] = ((in[2 + inpos] >>> 2) & 2047) - ; - out[7 + outpos] = ((in[2 + inpos] >>> 13) & 2047) - ; - out[8 + outpos] = (in[2 + inpos] >>> 24) - | ((in[3 + inpos] & 7) << (11 - 3)) - ; - out[9 + outpos] = ((in[3 + inpos] >>> 3) & 2047) - ; - out[10 + outpos] = ((in[3 + inpos] >>> 14) & 2047) - ; - out[11 + outpos] = (in[3 + inpos] >>> 25) - | ((in[4 + inpos] & 15) << (11 - 4)) - ; - out[12 + outpos] = ((in[4 + inpos] >>> 4) & 2047) - ; - out[13 + outpos] = ((in[4 + inpos] >>> 15) & 2047) - ; - out[14 + outpos] = (in[4 + inpos] >>> 26) - | ((in[5 + inpos] & 31) << (11 - 5)) - ; - out[15 + outpos] = ((in[5 + inpos] >>> 5) & 2047) - ; - out[16 + outpos] = ((in[5 + inpos] >>> 16) & 2047) - ; - out[17 + outpos] = (in[5 + inpos] >>> 27) - | ((in[6 + inpos] & 63) << (11 - 6)) - ; - out[18 + outpos] = ((in[6 + inpos] >>> 6) & 2047) - ; - out[19 + outpos] = ((in[6 + inpos] >>> 17) & 2047) - ; - out[20 + outpos] = (in[6 + inpos] >>> 28) - | ((in[7 + inpos] & 127) << (11 - 7)) - ; - out[21 + outpos] = ((in[7 + inpos] >>> 7) & 2047) - ; - out[22 + outpos] = ((in[7 + inpos] >>> 18) & 2047) - ; - out[23 + outpos] = (in[7 + inpos] >>> 29) - | ((in[8 + inpos] & 255) << (11 - 8)) - ; - out[24 + outpos] = ((in[8 + inpos] >>> 8) & 2047) - ; - out[25 + outpos] = ((in[8 + inpos] >>> 19) & 2047) - ; - out[26 + outpos] = (in[8 + inpos] >>> 30) - | ((in[9 + inpos] & 511) << (11 - 9)) - ; - out[27 + outpos] = ((in[9 + inpos] >>> 9) & 2047) - ; - out[28 + outpos] = ((in[9 + inpos] >>> 20) & 2047) - ; - out[29 + outpos] = (in[9 + inpos] >>> 31) - | ((in[10 + inpos] & 1023) << (11 - 10)) - ; - out[30 + outpos] = ((in[10 + inpos] >>> 10) & 2047) - ; - out[31 + outpos] = (in[10 + inpos] >>> 21) - ; - } + protected static void fastpackwithoutmask16(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = in[0 + inpos] | ((in[1 + inpos]) << 16); + out[1 + outpos] = in[2 + inpos] | ((in[3 + inpos]) << 16); + out[2 + outpos] = in[4 + inpos] | ((in[5 + inpos]) << 16); + out[3 + outpos] = in[6 + inpos] | ((in[7 + inpos]) << 16); + out[4 + outpos] = in[8 + inpos] | ((in[9 + inpos]) << 16); + out[5 + outpos] = in[10 + inpos] | ((in[11 + inpos]) << 16); + out[6 + outpos] = in[12 + inpos] | ((in[13 + inpos]) << 16); + out[7 + outpos] = in[14 + inpos] | ((in[15 + inpos]) << 16); + out[8 + outpos] = in[16 + inpos] | ((in[17 + inpos]) << 16); + out[9 + outpos] = in[18 + inpos] | ((in[19 + inpos]) << 16); + out[10 + outpos] = in[20 + inpos] | ((in[21 + inpos]) << 16); + out[11 + outpos] = in[22 + inpos] | ((in[23 + inpos]) << 16); + out[12 + outpos] = in[24 + inpos] | ((in[25 + inpos]) << 16); + out[13 + outpos] = in[26 + inpos] | ((in[27 + inpos]) << 16); + out[14 + outpos] = in[28 + inpos] | ((in[29 + inpos]) << 16); + out[15 + outpos] = in[30 + inpos] | ((in[31 + inpos]) << 16); + } + protected static void fastpackwithoutmask17(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = in[0 + inpos] | ((in[1 + inpos]) << 17); + out[1 + outpos] = ((in[1 + inpos]) >>> (17 - 2)) + | ((in[2 + inpos]) << 2) | ((in[3 + inpos]) << 19); + out[2 + outpos] = ((in[3 + inpos]) >>> (17 - 4)) + | ((in[4 + inpos]) << 4) | ((in[5 + inpos]) << 21); + out[3 + outpos] = ((in[5 + inpos]) >>> (17 - 6)) + | ((in[6 + inpos]) << 6) | ((in[7 + inpos]) << 23); + out[4 + outpos] = ((in[7 + inpos]) >>> (17 - 8)) + | ((in[8 + inpos]) << 8) | ((in[9 + inpos]) << 25); + out[5 + outpos] = ((in[9 + inpos]) >>> (17 - 10)) + | ((in[10 + inpos]) << 10) | ((in[11 + inpos]) << 27); + out[6 + outpos] = ((in[11 + inpos]) >>> (17 - 12)) + | ((in[12 + inpos]) << 12) | ((in[13 + inpos]) << 29); + out[7 + outpos] = ((in[13 + inpos]) >>> (17 - 14)) + | ((in[14 + inpos]) << 14) | ((in[15 + inpos]) << 31); + out[8 + outpos] = ((in[15 + inpos]) >>> (17 - 16)) + | ((in[16 + inpos]) << 16); + out[9 + outpos] = ((in[16 + inpos]) >>> (17 - 1)) + | ((in[17 + inpos]) << 1) | ((in[18 + inpos]) << 18); + out[10 + outpos] = ((in[18 + inpos]) >>> (17 - 3)) + | ((in[19 + inpos]) << 3) | ((in[20 + inpos]) << 20); + out[11 + outpos] = ((in[20 + inpos]) >>> (17 - 5)) + | ((in[21 + inpos]) << 5) | ((in[22 + inpos]) << 22); + out[12 + outpos] = ((in[22 + inpos]) >>> (17 - 7)) + | ((in[23 + inpos]) << 7) | ((in[24 + inpos]) << 24); + out[13 + outpos] = ((in[24 + inpos]) >>> (17 - 9)) + | ((in[25 + inpos]) << 9) | ((in[26 + inpos]) << 26); + out[14 + outpos] = ((in[26 + inpos]) >>> (17 - 11)) + | ((in[27 + inpos]) << 11) | ((in[28 + inpos]) << 28); + out[15 + outpos] = ((in[28 + inpos]) >>> (17 - 13)) + | ((in[29 + inpos]) << 13) | ((in[30 + inpos]) << 30); + out[16 + outpos] = ((in[30 + inpos]) >>> (17 - 15)) + | ((in[31 + inpos]) << 15); + } - protected static void fastunpack12(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = ((in[0 + inpos] >>> 0) & 4095) - ; - out[1 + outpos] = ((in[0 + inpos] >>> 12) & 4095) - ; - out[2 + outpos] = (in[0 + inpos] >>> 24) - | ((in[1 + inpos] & 15) << (12 - 4)) - ; - out[3 + outpos] = ((in[1 + inpos] >>> 4) & 4095) - ; - out[4 + outpos] = ((in[1 + inpos] >>> 16) & 4095) - ; - out[5 + outpos] = (in[1 + inpos] >>> 28) - | ((in[2 + inpos] & 255) << (12 - 8)) - ; - out[6 + outpos] = ((in[2 + inpos] >>> 8) & 4095) - ; - out[7 + outpos] = (in[2 + inpos] >>> 20) - ; - out[8 + outpos] = ((in[3 + inpos] >>> 0) & 4095) - ; - out[9 + outpos] = ((in[3 + inpos] >>> 12) & 4095) - ; - out[10 + outpos] = (in[3 + inpos] >>> 24) - | ((in[4 + inpos] & 15) << (12 - 4)) - ; - out[11 + outpos] = ((in[4 + inpos] >>> 4) & 4095) - ; - out[12 + outpos] = ((in[4 + inpos] >>> 16) & 4095) - ; - out[13 + outpos] = (in[4 + inpos] >>> 28) - | ((in[5 + inpos] & 255) << (12 - 8)) - ; - out[14 + outpos] = ((in[5 + inpos] >>> 8) & 4095) - ; - out[15 + outpos] = (in[5 + inpos] >>> 20) - ; - out[16 + outpos] = ((in[6 + inpos] >>> 0) & 4095) - ; - out[17 + outpos] = ((in[6 + inpos] >>> 12) & 4095) - ; - out[18 + outpos] = (in[6 + inpos] >>> 24) - | ((in[7 + inpos] & 15) << (12 - 4)) - ; - out[19 + outpos] = ((in[7 + inpos] >>> 4) & 4095) - ; - out[20 + outpos] = ((in[7 + inpos] >>> 16) & 4095) - ; - out[21 + outpos] = (in[7 + inpos] >>> 28) - | ((in[8 + inpos] & 255) << (12 - 8)) - ; - out[22 + outpos] = ((in[8 + inpos] >>> 8) & 4095) - ; - out[23 + outpos] = (in[8 + inpos] >>> 20) - ; - out[24 + outpos] = ((in[9 + inpos] >>> 0) & 4095) - ; - out[25 + outpos] = ((in[9 + inpos] >>> 12) & 4095) - ; - out[26 + outpos] = (in[9 + inpos] >>> 24) - | ((in[10 + inpos] & 15) << (12 - 4)) - ; - out[27 + outpos] = ((in[10 + inpos] >>> 4) & 4095) - ; - out[28 + outpos] = ((in[10 + inpos] >>> 16) & 4095) - ; - out[29 + outpos] = (in[10 + inpos] >>> 28) - | ((in[11 + inpos] & 255) << (12 - 8)) - ; - out[30 + outpos] = ((in[11 + inpos] >>> 8) & 4095) - ; - out[31 + outpos] = (in[11 + inpos] >>> 20) - ; - } + protected static void fastpackwithoutmask18(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = in[0 + inpos] | ((in[1 + inpos]) << 18); + out[1 + outpos] = ((in[1 + inpos]) >>> (18 - 4)) + | ((in[2 + inpos]) << 4) | ((in[3 + inpos]) << 22); + out[2 + outpos] = ((in[3 + inpos]) >>> (18 - 8)) + | ((in[4 + inpos]) << 8) | ((in[5 + inpos]) << 26); + out[3 + outpos] = ((in[5 + inpos]) >>> (18 - 12)) + | ((in[6 + inpos]) << 12) | ((in[7 + inpos]) << 30); + out[4 + outpos] = ((in[7 + inpos]) >>> (18 - 16)) + | ((in[8 + inpos]) << 16); + out[5 + outpos] = ((in[8 + inpos]) >>> (18 - 2)) + | ((in[9 + inpos]) << 2) | ((in[10 + inpos]) << 20); + out[6 + outpos] = ((in[10 + inpos]) >>> (18 - 6)) + | ((in[11 + inpos]) << 6) | ((in[12 + inpos]) << 24); + out[7 + outpos] = ((in[12 + inpos]) >>> (18 - 10)) + | ((in[13 + inpos]) << 10) | ((in[14 + inpos]) << 28); + out[8 + outpos] = ((in[14 + inpos]) >>> (18 - 14)) + | ((in[15 + inpos]) << 14); + out[9 + outpos] = in[16 + inpos] | ((in[17 + inpos]) << 18); + out[10 + outpos] = ((in[17 + inpos]) >>> (18 - 4)) + | ((in[18 + inpos]) << 4) | ((in[19 + inpos]) << 22); + out[11 + outpos] = ((in[19 + inpos]) >>> (18 - 8)) + | ((in[20 + inpos]) << 8) | ((in[21 + inpos]) << 26); + out[12 + outpos] = ((in[21 + inpos]) >>> (18 - 12)) + | ((in[22 + inpos]) << 12) | ((in[23 + inpos]) << 30); + out[13 + outpos] = ((in[23 + inpos]) >>> (18 - 16)) + | ((in[24 + inpos]) << 16); + out[14 + outpos] = ((in[24 + inpos]) >>> (18 - 2)) + | ((in[25 + inpos]) << 2) | ((in[26 + inpos]) << 20); + out[15 + outpos] = ((in[26 + inpos]) >>> (18 - 6)) + | ((in[27 + inpos]) << 6) | ((in[28 + inpos]) << 24); + out[16 + outpos] = ((in[28 + inpos]) >>> (18 - 10)) + | ((in[29 + inpos]) << 10) | ((in[30 + inpos]) << 28); + out[17 + outpos] = ((in[30 + inpos]) >>> (18 - 14)) + | ((in[31 + inpos]) << 14); + } + protected static void fastpackwithoutmask19(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = in[0 + inpos] | ((in[1 + inpos]) << 19); + out[1 + outpos] = ((in[1 + inpos]) >>> (19 - 6)) + | ((in[2 + inpos]) << 6) | ((in[3 + inpos]) << 25); + out[2 + outpos] = ((in[3 + inpos]) >>> (19 - 12)) + | ((in[4 + inpos]) << 12) | ((in[5 + inpos]) << 31); + out[3 + outpos] = ((in[5 + inpos]) >>> (19 - 18)) + | ((in[6 + inpos]) << 18); + out[4 + outpos] = ((in[6 + inpos]) >>> (19 - 5)) + | ((in[7 + inpos]) << 5) | ((in[8 + inpos]) << 24); + out[5 + outpos] = ((in[8 + inpos]) >>> (19 - 11)) + | ((in[9 + inpos]) << 11) | ((in[10 + inpos]) << 30); + out[6 + outpos] = ((in[10 + inpos]) >>> (19 - 17)) + | ((in[11 + inpos]) << 17); + out[7 + outpos] = ((in[11 + inpos]) >>> (19 - 4)) + | ((in[12 + inpos]) << 4) | ((in[13 + inpos]) << 23); + out[8 + outpos] = ((in[13 + inpos]) >>> (19 - 10)) + | ((in[14 + inpos]) << 10) | ((in[15 + inpos]) << 29); + out[9 + outpos] = ((in[15 + inpos]) >>> (19 - 16)) + | ((in[16 + inpos]) << 16); + out[10 + outpos] = ((in[16 + inpos]) >>> (19 - 3)) + | ((in[17 + inpos]) << 3) | ((in[18 + inpos]) << 22); + out[11 + outpos] = ((in[18 + inpos]) >>> (19 - 9)) + | ((in[19 + inpos]) << 9) | ((in[20 + inpos]) << 28); + out[12 + outpos] = ((in[20 + inpos]) >>> (19 - 15)) + | ((in[21 + inpos]) << 15); + out[13 + outpos] = ((in[21 + inpos]) >>> (19 - 2)) + | ((in[22 + inpos]) << 2) | ((in[23 + inpos]) << 21); + out[14 + outpos] = ((in[23 + inpos]) >>> (19 - 8)) + | ((in[24 + inpos]) << 8) | ((in[25 + inpos]) << 27); + out[15 + outpos] = ((in[25 + inpos]) >>> (19 - 14)) + | ((in[26 + inpos]) << 14); + out[16 + outpos] = ((in[26 + inpos]) >>> (19 - 1)) + | ((in[27 + inpos]) << 1) | ((in[28 + inpos]) << 20); + out[17 + outpos] = ((in[28 + inpos]) >>> (19 - 7)) + | ((in[29 + inpos]) << 7) | ((in[30 + inpos]) << 26); + out[18 + outpos] = ((in[30 + inpos]) >>> (19 - 13)) + | ((in[31 + inpos]) << 13); + } - protected static void fastunpack13(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = ((in[0 + inpos] >>> 0) & 8191) - ; - out[1 + outpos] = ((in[0 + inpos] >>> 13) & 8191) - ; - out[2 + outpos] = (in[0 + inpos] >>> 26) - | ((in[1 + inpos] & 127) << (13 - 7)) - ; - out[3 + outpos] = ((in[1 + inpos] >>> 7) & 8191) - ; - out[4 + outpos] = (in[1 + inpos] >>> 20) - | ((in[2 + inpos] & 1) << (13 - 1)) - ; - out[5 + outpos] = ((in[2 + inpos] >>> 1) & 8191) - ; - out[6 + outpos] = ((in[2 + inpos] >>> 14) & 8191) - ; - out[7 + outpos] = (in[2 + inpos] >>> 27) - | ((in[3 + inpos] & 255) << (13 - 8)) - ; - out[8 + outpos] = ((in[3 + inpos] >>> 8) & 8191) - ; - out[9 + outpos] = (in[3 + inpos] >>> 21) - | ((in[4 + inpos] & 3) << (13 - 2)) - ; - out[10 + outpos] = ((in[4 + inpos] >>> 2) & 8191) - ; - out[11 + outpos] = ((in[4 + inpos] >>> 15) & 8191) - ; - out[12 + outpos] = (in[4 + inpos] >>> 28) - | ((in[5 + inpos] & 511) << (13 - 9)) - ; - out[13 + outpos] = ((in[5 + inpos] >>> 9) & 8191) - ; - out[14 + outpos] = (in[5 + inpos] >>> 22) - | ((in[6 + inpos] & 7) << (13 - 3)) - ; - out[15 + outpos] = ((in[6 + inpos] >>> 3) & 8191) - ; - out[16 + outpos] = ((in[6 + inpos] >>> 16) & 8191) - ; - out[17 + outpos] = (in[6 + inpos] >>> 29) - | ((in[7 + inpos] & 1023) << (13 - 10)) - ; - out[18 + outpos] = ((in[7 + inpos] >>> 10) & 8191) - ; - out[19 + outpos] = (in[7 + inpos] >>> 23) - | ((in[8 + inpos] & 15) << (13 - 4)) - ; - out[20 + outpos] = ((in[8 + inpos] >>> 4) & 8191) - ; - out[21 + outpos] = ((in[8 + inpos] >>> 17) & 8191) - ; - out[22 + outpos] = (in[8 + inpos] >>> 30) - | ((in[9 + inpos] & 2047) << (13 - 11)) - ; - out[23 + outpos] = ((in[9 + inpos] >>> 11) & 8191) - ; - out[24 + outpos] = (in[9 + inpos] >>> 24) - | ((in[10 + inpos] & 31) << (13 - 5)) - ; - out[25 + outpos] = ((in[10 + inpos] >>> 5) & 8191) - ; - out[26 + outpos] = ((in[10 + inpos] >>> 18) & 8191) - ; - out[27 + outpos] = (in[10 + inpos] >>> 31) - | ((in[11 + inpos] & 4095) << (13 - 12)) - ; - out[28 + outpos] = ((in[11 + inpos] >>> 12) & 8191) - ; - out[29 + outpos] = (in[11 + inpos] >>> 25) - | ((in[12 + inpos] & 63) << (13 - 6)) - ; - out[30 + outpos] = ((in[12 + inpos] >>> 6) & 8191) - ; - out[31 + outpos] = (in[12 + inpos] >>> 19) - ; - } + protected static void fastpackwithoutmask2(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = in[0 + inpos] | ((in[1 + inpos]) << 2) + | ((in[2 + inpos]) << 4) | ((in[3 + inpos]) << 6) + | ((in[4 + inpos]) << 8) | ((in[5 + inpos]) << 10) + | ((in[6 + inpos]) << 12) | ((in[7 + inpos]) << 14) + | ((in[8 + inpos]) << 16) | ((in[9 + inpos]) << 18) + | ((in[10 + inpos]) << 20) | ((in[11 + inpos]) << 22) + | ((in[12 + inpos]) << 24) | ((in[13 + inpos]) << 26) + | ((in[14 + inpos]) << 28) | ((in[15 + inpos]) << 30); + out[1 + outpos] = in[16 + inpos] | ((in[17 + inpos]) << 2) + | ((in[18 + inpos]) << 4) | ((in[19 + inpos]) << 6) + | ((in[20 + inpos]) << 8) | ((in[21 + inpos]) << 10) + | ((in[22 + inpos]) << 12) | ((in[23 + inpos]) << 14) + | ((in[24 + inpos]) << 16) | ((in[25 + inpos]) << 18) + | ((in[26 + inpos]) << 20) | ((in[27 + inpos]) << 22) + | ((in[28 + inpos]) << 24) | ((in[29 + inpos]) << 26) + | ((in[30 + inpos]) << 28) | ((in[31 + inpos]) << 30); + } + protected static void fastpackwithoutmask20(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = in[0 + inpos] | ((in[1 + inpos]) << 20); + out[1 + outpos] = ((in[1 + inpos]) >>> (20 - 8)) + | ((in[2 + inpos]) << 8) | ((in[3 + inpos]) << 28); + out[2 + outpos] = ((in[3 + inpos]) >>> (20 - 16)) + | ((in[4 + inpos]) << 16); + out[3 + outpos] = ((in[4 + inpos]) >>> (20 - 4)) + | ((in[5 + inpos]) << 4) | ((in[6 + inpos]) << 24); + out[4 + outpos] = ((in[6 + inpos]) >>> (20 - 12)) + | ((in[7 + inpos]) << 12); + out[5 + outpos] = in[8 + inpos] | ((in[9 + inpos]) << 20); + out[6 + outpos] = ((in[9 + inpos]) >>> (20 - 8)) + | ((in[10 + inpos]) << 8) | ((in[11 + inpos]) << 28); + out[7 + outpos] = ((in[11 + inpos]) >>> (20 - 16)) + | ((in[12 + inpos]) << 16); + out[8 + outpos] = ((in[12 + inpos]) >>> (20 - 4)) + | ((in[13 + inpos]) << 4) | ((in[14 + inpos]) << 24); + out[9 + outpos] = ((in[14 + inpos]) >>> (20 - 12)) + | ((in[15 + inpos]) << 12); + out[10 + outpos] = in[16 + inpos] | ((in[17 + inpos]) << 20); + out[11 + outpos] = ((in[17 + inpos]) >>> (20 - 8)) + | ((in[18 + inpos]) << 8) | ((in[19 + inpos]) << 28); + out[12 + outpos] = ((in[19 + inpos]) >>> (20 - 16)) + | ((in[20 + inpos]) << 16); + out[13 + outpos] = ((in[20 + inpos]) >>> (20 - 4)) + | ((in[21 + inpos]) << 4) | ((in[22 + inpos]) << 24); + out[14 + outpos] = ((in[22 + inpos]) >>> (20 - 12)) + | ((in[23 + inpos]) << 12); + out[15 + outpos] = in[24 + inpos] | ((in[25 + inpos]) << 20); + out[16 + outpos] = ((in[25 + inpos]) >>> (20 - 8)) + | ((in[26 + inpos]) << 8) | ((in[27 + inpos]) << 28); + out[17 + outpos] = ((in[27 + inpos]) >>> (20 - 16)) + | ((in[28 + inpos]) << 16); + out[18 + outpos] = ((in[28 + inpos]) >>> (20 - 4)) + | ((in[29 + inpos]) << 4) | ((in[30 + inpos]) << 24); + out[19 + outpos] = ((in[30 + inpos]) >>> (20 - 12)) + | ((in[31 + inpos]) << 12); + } - protected static void fastunpack14(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = ((in[0 + inpos] >>> 0) & 16383) - ; - out[1 + outpos] = ((in[0 + inpos] >>> 14) & 16383) - ; - out[2 + outpos] = (in[0 + inpos] >>> 28) - | ((in[1 + inpos] & 1023) << (14 - 10)) - ; - out[3 + outpos] = ((in[1 + inpos] >>> 10) & 16383) - ; - out[4 + outpos] = (in[1 + inpos] >>> 24) - | ((in[2 + inpos] & 63) << (14 - 6)) - ; - out[5 + outpos] = ((in[2 + inpos] >>> 6) & 16383) - ; - out[6 + outpos] = (in[2 + inpos] >>> 20) - | ((in[3 + inpos] & 3) << (14 - 2)) - ; - out[7 + outpos] = ((in[3 + inpos] >>> 2) & 16383) - ; - out[8 + outpos] = ((in[3 + inpos] >>> 16) & 16383) - ; - out[9 + outpos] = (in[3 + inpos] >>> 30) - | ((in[4 + inpos] & 4095) << (14 - 12)) - ; - out[10 + outpos] = ((in[4 + inpos] >>> 12) & 16383) - ; - out[11 + outpos] = (in[4 + inpos] >>> 26) - | ((in[5 + inpos] & 255) << (14 - 8)) - ; - out[12 + outpos] = ((in[5 + inpos] >>> 8) & 16383) - ; - out[13 + outpos] = (in[5 + inpos] >>> 22) - | ((in[6 + inpos] & 15) << (14 - 4)) - ; - out[14 + outpos] = ((in[6 + inpos] >>> 4) & 16383) - ; - out[15 + outpos] = (in[6 + inpos] >>> 18) - ; - out[16 + outpos] = ((in[7 + inpos] >>> 0) & 16383) - ; - out[17 + outpos] = ((in[7 + inpos] >>> 14) & 16383) - ; - out[18 + outpos] = (in[7 + inpos] >>> 28) - | ((in[8 + inpos] & 1023) << (14 - 10)) - ; - out[19 + outpos] = ((in[8 + inpos] >>> 10) & 16383) - ; - out[20 + outpos] = (in[8 + inpos] >>> 24) - | ((in[9 + inpos] & 63) << (14 - 6)) - ; - out[21 + outpos] = ((in[9 + inpos] >>> 6) & 16383) - ; - out[22 + outpos] = (in[9 + inpos] >>> 20) - | ((in[10 + inpos] & 3) << (14 - 2)) - ; - out[23 + outpos] = ((in[10 + inpos] >>> 2) & 16383) - ; - out[24 + outpos] = ((in[10 + inpos] >>> 16) & 16383) - ; - out[25 + outpos] = (in[10 + inpos] >>> 30) - | ((in[11 + inpos] & 4095) << (14 - 12)) - ; - out[26 + outpos] = ((in[11 + inpos] >>> 12) & 16383) - ; - out[27 + outpos] = (in[11 + inpos] >>> 26) - | ((in[12 + inpos] & 255) << (14 - 8)) - ; - out[28 + outpos] = ((in[12 + inpos] >>> 8) & 16383) - ; - out[29 + outpos] = (in[12 + inpos] >>> 22) - | ((in[13 + inpos] & 15) << (14 - 4)) - ; - out[30 + outpos] = ((in[13 + inpos] >>> 4) & 16383) - ; - out[31 + outpos] = (in[13 + inpos] >>> 18) - ; - } + protected static void fastpackwithoutmask21(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = in[0 + inpos] | ((in[1 + inpos]) << 21); + out[1 + outpos] = ((in[1 + inpos]) >>> (21 - 10)) + | ((in[2 + inpos]) << 10) | ((in[3 + inpos]) << 31); + out[2 + outpos] = ((in[3 + inpos]) >>> (21 - 20)) + | ((in[4 + inpos]) << 20); + out[3 + outpos] = ((in[4 + inpos]) >>> (21 - 9)) + | ((in[5 + inpos]) << 9) | ((in[6 + inpos]) << 30); + out[4 + outpos] = ((in[6 + inpos]) >>> (21 - 19)) + | ((in[7 + inpos]) << 19); + out[5 + outpos] = ((in[7 + inpos]) >>> (21 - 8)) + | ((in[8 + inpos]) << 8) | ((in[9 + inpos]) << 29); + out[6 + outpos] = ((in[9 + inpos]) >>> (21 - 18)) + | ((in[10 + inpos]) << 18); + out[7 + outpos] = ((in[10 + inpos]) >>> (21 - 7)) + | ((in[11 + inpos]) << 7) | ((in[12 + inpos]) << 28); + out[8 + outpos] = ((in[12 + inpos]) >>> (21 - 17)) + | ((in[13 + inpos]) << 17); + out[9 + outpos] = ((in[13 + inpos]) >>> (21 - 6)) + | ((in[14 + inpos]) << 6) | ((in[15 + inpos]) << 27); + out[10 + outpos] = ((in[15 + inpos]) >>> (21 - 16)) + | ((in[16 + inpos]) << 16); + out[11 + outpos] = ((in[16 + inpos]) >>> (21 - 5)) + | ((in[17 + inpos]) << 5) | ((in[18 + inpos]) << 26); + out[12 + outpos] = ((in[18 + inpos]) >>> (21 - 15)) + | ((in[19 + inpos]) << 15); + out[13 + outpos] = ((in[19 + inpos]) >>> (21 - 4)) + | ((in[20 + inpos]) << 4) | ((in[21 + inpos]) << 25); + out[14 + outpos] = ((in[21 + inpos]) >>> (21 - 14)) + | ((in[22 + inpos]) << 14); + out[15 + outpos] = ((in[22 + inpos]) >>> (21 - 3)) + | ((in[23 + inpos]) << 3) | ((in[24 + inpos]) << 24); + out[16 + outpos] = ((in[24 + inpos]) >>> (21 - 13)) + | ((in[25 + inpos]) << 13); + out[17 + outpos] = ((in[25 + inpos]) >>> (21 - 2)) + | ((in[26 + inpos]) << 2) | ((in[27 + inpos]) << 23); + out[18 + outpos] = ((in[27 + inpos]) >>> (21 - 12)) + | ((in[28 + inpos]) << 12); + out[19 + outpos] = ((in[28 + inpos]) >>> (21 - 1)) + | ((in[29 + inpos]) << 1) | ((in[30 + inpos]) << 22); + out[20 + outpos] = ((in[30 + inpos]) >>> (21 - 11)) + | ((in[31 + inpos]) << 11); + } + protected static void fastpackwithoutmask22(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = in[0 + inpos] | ((in[1 + inpos]) << 22); + out[1 + outpos] = ((in[1 + inpos]) >>> (22 - 12)) + | ((in[2 + inpos]) << 12); + out[2 + outpos] = ((in[2 + inpos]) >>> (22 - 2)) + | ((in[3 + inpos]) << 2) | ((in[4 + inpos]) << 24); + out[3 + outpos] = ((in[4 + inpos]) >>> (22 - 14)) + | ((in[5 + inpos]) << 14); + out[4 + outpos] = ((in[5 + inpos]) >>> (22 - 4)) + | ((in[6 + inpos]) << 4) | ((in[7 + inpos]) << 26); + out[5 + outpos] = ((in[7 + inpos]) >>> (22 - 16)) + | ((in[8 + inpos]) << 16); + out[6 + outpos] = ((in[8 + inpos]) >>> (22 - 6)) + | ((in[9 + inpos]) << 6) | ((in[10 + inpos]) << 28); + out[7 + outpos] = ((in[10 + inpos]) >>> (22 - 18)) + | ((in[11 + inpos]) << 18); + out[8 + outpos] = ((in[11 + inpos]) >>> (22 - 8)) + | ((in[12 + inpos]) << 8) | ((in[13 + inpos]) << 30); + out[9 + outpos] = ((in[13 + inpos]) >>> (22 - 20)) + | ((in[14 + inpos]) << 20); + out[10 + outpos] = ((in[14 + inpos]) >>> (22 - 10)) + | ((in[15 + inpos]) << 10); + out[11 + outpos] = in[16 + inpos] | ((in[17 + inpos]) << 22); + out[12 + outpos] = ((in[17 + inpos]) >>> (22 - 12)) + | ((in[18 + inpos]) << 12); + out[13 + outpos] = ((in[18 + inpos]) >>> (22 - 2)) + | ((in[19 + inpos]) << 2) | ((in[20 + inpos]) << 24); + out[14 + outpos] = ((in[20 + inpos]) >>> (22 - 14)) + | ((in[21 + inpos]) << 14); + out[15 + outpos] = ((in[21 + inpos]) >>> (22 - 4)) + | ((in[22 + inpos]) << 4) | ((in[23 + inpos]) << 26); + out[16 + outpos] = ((in[23 + inpos]) >>> (22 - 16)) + | ((in[24 + inpos]) << 16); + out[17 + outpos] = ((in[24 + inpos]) >>> (22 - 6)) + | ((in[25 + inpos]) << 6) | ((in[26 + inpos]) << 28); + out[18 + outpos] = ((in[26 + inpos]) >>> (22 - 18)) + | ((in[27 + inpos]) << 18); + out[19 + outpos] = ((in[27 + inpos]) >>> (22 - 8)) + | ((in[28 + inpos]) << 8) | ((in[29 + inpos]) << 30); + out[20 + outpos] = ((in[29 + inpos]) >>> (22 - 20)) + | ((in[30 + inpos]) << 20); + out[21 + outpos] = ((in[30 + inpos]) >>> (22 - 10)) + | ((in[31 + inpos]) << 10); + } - protected static void fastunpack15(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = ((in[0 + inpos] >>> 0) & 32767) - ; - out[1 + outpos] = ((in[0 + inpos] >>> 15) & 32767) - ; - out[2 + outpos] = (in[0 + inpos] >>> 30) - | ((in[1 + inpos] & 8191) << (15 - 13)) - ; - out[3 + outpos] = ((in[1 + inpos] >>> 13) & 32767) - ; - out[4 + outpos] = (in[1 + inpos] >>> 28) - | ((in[2 + inpos] & 2047) << (15 - 11)) - ; - out[5 + outpos] = ((in[2 + inpos] >>> 11) & 32767) - ; - out[6 + outpos] = (in[2 + inpos] >>> 26) - | ((in[3 + inpos] & 511) << (15 - 9)) - ; - out[7 + outpos] = ((in[3 + inpos] >>> 9) & 32767) - ; - out[8 + outpos] = (in[3 + inpos] >>> 24) - | ((in[4 + inpos] & 127) << (15 - 7)) - ; - out[9 + outpos] = ((in[4 + inpos] >>> 7) & 32767) - ; - out[10 + outpos] = (in[4 + inpos] >>> 22) - | ((in[5 + inpos] & 31) << (15 - 5)) - ; - out[11 + outpos] = ((in[5 + inpos] >>> 5) & 32767) - ; - out[12 + outpos] = (in[5 + inpos] >>> 20) - | ((in[6 + inpos] & 7) << (15 - 3)) - ; - out[13 + outpos] = ((in[6 + inpos] >>> 3) & 32767) - ; - out[14 + outpos] = (in[6 + inpos] >>> 18) - | ((in[7 + inpos] & 1) << (15 - 1)) - ; - out[15 + outpos] = ((in[7 + inpos] >>> 1) & 32767) - ; - out[16 + outpos] = ((in[7 + inpos] >>> 16) & 32767) - ; - out[17 + outpos] = (in[7 + inpos] >>> 31) - | ((in[8 + inpos] & 16383) << (15 - 14)) - ; - out[18 + outpos] = ((in[8 + inpos] >>> 14) & 32767) - ; - out[19 + outpos] = (in[8 + inpos] >>> 29) - | ((in[9 + inpos] & 4095) << (15 - 12)) - ; - out[20 + outpos] = ((in[9 + inpos] >>> 12) & 32767) - ; - out[21 + outpos] = (in[9 + inpos] >>> 27) - | ((in[10 + inpos] & 1023) << (15 - 10)) - ; - out[22 + outpos] = ((in[10 + inpos] >>> 10) & 32767) - ; - out[23 + outpos] = (in[10 + inpos] >>> 25) - | ((in[11 + inpos] & 255) << (15 - 8)) - ; - out[24 + outpos] = ((in[11 + inpos] >>> 8) & 32767) - ; - out[25 + outpos] = (in[11 + inpos] >>> 23) - | ((in[12 + inpos] & 63) << (15 - 6)) - ; - out[26 + outpos] = ((in[12 + inpos] >>> 6) & 32767) - ; - out[27 + outpos] = (in[12 + inpos] >>> 21) - | ((in[13 + inpos] & 15) << (15 - 4)) - ; - out[28 + outpos] = ((in[13 + inpos] >>> 4) & 32767) - ; - out[29 + outpos] = (in[13 + inpos] >>> 19) - | ((in[14 + inpos] & 3) << (15 - 2)) - ; - out[30 + outpos] = ((in[14 + inpos] >>> 2) & 32767) - ; - out[31 + outpos] = (in[14 + inpos] >>> 17) - ; - } + protected static void fastpackwithoutmask23(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = in[0 + inpos] | ((in[1 + inpos]) << 23); + out[1 + outpos] = ((in[1 + inpos]) >>> (23 - 14)) + | ((in[2 + inpos]) << 14); + out[2 + outpos] = ((in[2 + inpos]) >>> (23 - 5)) + | ((in[3 + inpos]) << 5) | ((in[4 + inpos]) << 28); + out[3 + outpos] = ((in[4 + inpos]) >>> (23 - 19)) + | ((in[5 + inpos]) << 19); + out[4 + outpos] = ((in[5 + inpos]) >>> (23 - 10)) + | ((in[6 + inpos]) << 10); + out[5 + outpos] = ((in[6 + inpos]) >>> (23 - 1)) + | ((in[7 + inpos]) << 1) | ((in[8 + inpos]) << 24); + out[6 + outpos] = ((in[8 + inpos]) >>> (23 - 15)) + | ((in[9 + inpos]) << 15); + out[7 + outpos] = ((in[9 + inpos]) >>> (23 - 6)) + | ((in[10 + inpos]) << 6) | ((in[11 + inpos]) << 29); + out[8 + outpos] = ((in[11 + inpos]) >>> (23 - 20)) + | ((in[12 + inpos]) << 20); + out[9 + outpos] = ((in[12 + inpos]) >>> (23 - 11)) + | ((in[13 + inpos]) << 11); + out[10 + outpos] = ((in[13 + inpos]) >>> (23 - 2)) + | ((in[14 + inpos]) << 2) | ((in[15 + inpos]) << 25); + out[11 + outpos] = ((in[15 + inpos]) >>> (23 - 16)) + | ((in[16 + inpos]) << 16); + out[12 + outpos] = ((in[16 + inpos]) >>> (23 - 7)) + | ((in[17 + inpos]) << 7) | ((in[18 + inpos]) << 30); + out[13 + outpos] = ((in[18 + inpos]) >>> (23 - 21)) + | ((in[19 + inpos]) << 21); + out[14 + outpos] = ((in[19 + inpos]) >>> (23 - 12)) + | ((in[20 + inpos]) << 12); + out[15 + outpos] = ((in[20 + inpos]) >>> (23 - 3)) + | ((in[21 + inpos]) << 3) | ((in[22 + inpos]) << 26); + out[16 + outpos] = ((in[22 + inpos]) >>> (23 - 17)) + | ((in[23 + inpos]) << 17); + out[17 + outpos] = ((in[23 + inpos]) >>> (23 - 8)) + | ((in[24 + inpos]) << 8) | ((in[25 + inpos]) << 31); + out[18 + outpos] = ((in[25 + inpos]) >>> (23 - 22)) + | ((in[26 + inpos]) << 22); + out[19 + outpos] = ((in[26 + inpos]) >>> (23 - 13)) + | ((in[27 + inpos]) << 13); + out[20 + outpos] = ((in[27 + inpos]) >>> (23 - 4)) + | ((in[28 + inpos]) << 4) | ((in[29 + inpos]) << 27); + out[21 + outpos] = ((in[29 + inpos]) >>> (23 - 18)) + | ((in[30 + inpos]) << 18); + out[22 + outpos] = ((in[30 + inpos]) >>> (23 - 9)) + | ((in[31 + inpos]) << 9); + } + protected static void fastpackwithoutmask24(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = in[0 + inpos] | ((in[1 + inpos]) << 24); + out[1 + outpos] = ((in[1 + inpos]) >>> (24 - 16)) + | ((in[2 + inpos]) << 16); + out[2 + outpos] = ((in[2 + inpos]) >>> (24 - 8)) + | ((in[3 + inpos]) << 8); + out[3 + outpos] = in[4 + inpos] | ((in[5 + inpos]) << 24); + out[4 + outpos] = ((in[5 + inpos]) >>> (24 - 16)) + | ((in[6 + inpos]) << 16); + out[5 + outpos] = ((in[6 + inpos]) >>> (24 - 8)) + | ((in[7 + inpos]) << 8); + out[6 + outpos] = in[8 + inpos] | ((in[9 + inpos]) << 24); + out[7 + outpos] = ((in[9 + inpos]) >>> (24 - 16)) + | ((in[10 + inpos]) << 16); + out[8 + outpos] = ((in[10 + inpos]) >>> (24 - 8)) + | ((in[11 + inpos]) << 8); + out[9 + outpos] = in[12 + inpos] | ((in[13 + inpos]) << 24); + out[10 + outpos] = ((in[13 + inpos]) >>> (24 - 16)) + | ((in[14 + inpos]) << 16); + out[11 + outpos] = ((in[14 + inpos]) >>> (24 - 8)) + | ((in[15 + inpos]) << 8); + out[12 + outpos] = in[16 + inpos] | ((in[17 + inpos]) << 24); + out[13 + outpos] = ((in[17 + inpos]) >>> (24 - 16)) + | ((in[18 + inpos]) << 16); + out[14 + outpos] = ((in[18 + inpos]) >>> (24 - 8)) + | ((in[19 + inpos]) << 8); + out[15 + outpos] = in[20 + inpos] | ((in[21 + inpos]) << 24); + out[16 + outpos] = ((in[21 + inpos]) >>> (24 - 16)) + | ((in[22 + inpos]) << 16); + out[17 + outpos] = ((in[22 + inpos]) >>> (24 - 8)) + | ((in[23 + inpos]) << 8); + out[18 + outpos] = in[24 + inpos] | ((in[25 + inpos]) << 24); + out[19 + outpos] = ((in[25 + inpos]) >>> (24 - 16)) + | ((in[26 + inpos]) << 16); + out[20 + outpos] = ((in[26 + inpos]) >>> (24 - 8)) + | ((in[27 + inpos]) << 8); + out[21 + outpos] = in[28 + inpos] | ((in[29 + inpos]) << 24); + out[22 + outpos] = ((in[29 + inpos]) >>> (24 - 16)) + | ((in[30 + inpos]) << 16); + out[23 + outpos] = ((in[30 + inpos]) >>> (24 - 8)) + | ((in[31 + inpos]) << 8); + } - protected static void fastunpack16(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = ((in[0 + inpos] >>> 0) & 65535) - ; - out[1 + outpos] = (in[0 + inpos] >>> 16) - ; - out[2 + outpos] = ((in[1 + inpos] >>> 0) & 65535) - ; - out[3 + outpos] = (in[1 + inpos] >>> 16) - ; - out[4 + outpos] = ((in[2 + inpos] >>> 0) & 65535) - ; - out[5 + outpos] = (in[2 + inpos] >>> 16) - ; - out[6 + outpos] = ((in[3 + inpos] >>> 0) & 65535) - ; - out[7 + outpos] = (in[3 + inpos] >>> 16) - ; - out[8 + outpos] = ((in[4 + inpos] >>> 0) & 65535) - ; - out[9 + outpos] = (in[4 + inpos] >>> 16) - ; - out[10 + outpos] = ((in[5 + inpos] >>> 0) & 65535) - ; - out[11 + outpos] = (in[5 + inpos] >>> 16) - ; - out[12 + outpos] = ((in[6 + inpos] >>> 0) & 65535) - ; - out[13 + outpos] = (in[6 + inpos] >>> 16) - ; - out[14 + outpos] = ((in[7 + inpos] >>> 0) & 65535) - ; - out[15 + outpos] = (in[7 + inpos] >>> 16) - ; - out[16 + outpos] = ((in[8 + inpos] >>> 0) & 65535) - ; - out[17 + outpos] = (in[8 + inpos] >>> 16) - ; - out[18 + outpos] = ((in[9 + inpos] >>> 0) & 65535) - ; - out[19 + outpos] = (in[9 + inpos] >>> 16) - ; - out[20 + outpos] = ((in[10 + inpos] >>> 0) & 65535) - ; - out[21 + outpos] = (in[10 + inpos] >>> 16) - ; - out[22 + outpos] = ((in[11 + inpos] >>> 0) & 65535) - ; - out[23 + outpos] = (in[11 + inpos] >>> 16) - ; - out[24 + outpos] = ((in[12 + inpos] >>> 0) & 65535) - ; - out[25 + outpos] = (in[12 + inpos] >>> 16) - ; - out[26 + outpos] = ((in[13 + inpos] >>> 0) & 65535) - ; - out[27 + outpos] = (in[13 + inpos] >>> 16) - ; - out[28 + outpos] = ((in[14 + inpos] >>> 0) & 65535) - ; - out[29 + outpos] = (in[14 + inpos] >>> 16) - ; - out[30 + outpos] = ((in[15 + inpos] >>> 0) & 65535) - ; - out[31 + outpos] = (in[15 + inpos] >>> 16) - ; - } + protected static void fastpackwithoutmask25(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = in[0 + inpos] | ((in[1 + inpos]) << 25); + out[1 + outpos] = ((in[1 + inpos]) >>> (25 - 18)) + | ((in[2 + inpos]) << 18); + out[2 + outpos] = ((in[2 + inpos]) >>> (25 - 11)) + | ((in[3 + inpos]) << 11); + out[3 + outpos] = ((in[3 + inpos]) >>> (25 - 4)) + | ((in[4 + inpos]) << 4) | ((in[5 + inpos]) << 29); + out[4 + outpos] = ((in[5 + inpos]) >>> (25 - 22)) + | ((in[6 + inpos]) << 22); + out[5 + outpos] = ((in[6 + inpos]) >>> (25 - 15)) + | ((in[7 + inpos]) << 15); + out[6 + outpos] = ((in[7 + inpos]) >>> (25 - 8)) + | ((in[8 + inpos]) << 8); + out[7 + outpos] = ((in[8 + inpos]) >>> (25 - 1)) + | ((in[9 + inpos]) << 1) | ((in[10 + inpos]) << 26); + out[8 + outpos] = ((in[10 + inpos]) >>> (25 - 19)) + | ((in[11 + inpos]) << 19); + out[9 + outpos] = ((in[11 + inpos]) >>> (25 - 12)) + | ((in[12 + inpos]) << 12); + out[10 + outpos] = ((in[12 + inpos]) >>> (25 - 5)) + | ((in[13 + inpos]) << 5) | ((in[14 + inpos]) << 30); + out[11 + outpos] = ((in[14 + inpos]) >>> (25 - 23)) + | ((in[15 + inpos]) << 23); + out[12 + outpos] = ((in[15 + inpos]) >>> (25 - 16)) + | ((in[16 + inpos]) << 16); + out[13 + outpos] = ((in[16 + inpos]) >>> (25 - 9)) + | ((in[17 + inpos]) << 9); + out[14 + outpos] = ((in[17 + inpos]) >>> (25 - 2)) + | ((in[18 + inpos]) << 2) | ((in[19 + inpos]) << 27); + out[15 + outpos] = ((in[19 + inpos]) >>> (25 - 20)) + | ((in[20 + inpos]) << 20); + out[16 + outpos] = ((in[20 + inpos]) >>> (25 - 13)) + | ((in[21 + inpos]) << 13); + out[17 + outpos] = ((in[21 + inpos]) >>> (25 - 6)) + | ((in[22 + inpos]) << 6) | ((in[23 + inpos]) << 31); + out[18 + outpos] = ((in[23 + inpos]) >>> (25 - 24)) + | ((in[24 + inpos]) << 24); + out[19 + outpos] = ((in[24 + inpos]) >>> (25 - 17)) + | ((in[25 + inpos]) << 17); + out[20 + outpos] = ((in[25 + inpos]) >>> (25 - 10)) + | ((in[26 + inpos]) << 10); + out[21 + outpos] = ((in[26 + inpos]) >>> (25 - 3)) + | ((in[27 + inpos]) << 3) | ((in[28 + inpos]) << 28); + out[22 + outpos] = ((in[28 + inpos]) >>> (25 - 21)) + | ((in[29 + inpos]) << 21); + out[23 + outpos] = ((in[29 + inpos]) >>> (25 - 14)) + | ((in[30 + inpos]) << 14); + out[24 + outpos] = ((in[30 + inpos]) >>> (25 - 7)) + | ((in[31 + inpos]) << 7); + } + protected static void fastpackwithoutmask26(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = in[0 + inpos] | ((in[1 + inpos]) << 26); + out[1 + outpos] = ((in[1 + inpos]) >>> (26 - 20)) + | ((in[2 + inpos]) << 20); + out[2 + outpos] = ((in[2 + inpos]) >>> (26 - 14)) + | ((in[3 + inpos]) << 14); + out[3 + outpos] = ((in[3 + inpos]) >>> (26 - 8)) + | ((in[4 + inpos]) << 8); + out[4 + outpos] = ((in[4 + inpos]) >>> (26 - 2)) + | ((in[5 + inpos]) << 2) | ((in[6 + inpos]) << 28); + out[5 + outpos] = ((in[6 + inpos]) >>> (26 - 22)) + | ((in[7 + inpos]) << 22); + out[6 + outpos] = ((in[7 + inpos]) >>> (26 - 16)) + | ((in[8 + inpos]) << 16); + out[7 + outpos] = ((in[8 + inpos]) >>> (26 - 10)) + | ((in[9 + inpos]) << 10); + out[8 + outpos] = ((in[9 + inpos]) >>> (26 - 4)) + | ((in[10 + inpos]) << 4) | ((in[11 + inpos]) << 30); + out[9 + outpos] = ((in[11 + inpos]) >>> (26 - 24)) + | ((in[12 + inpos]) << 24); + out[10 + outpos] = ((in[12 + inpos]) >>> (26 - 18)) + | ((in[13 + inpos]) << 18); + out[11 + outpos] = ((in[13 + inpos]) >>> (26 - 12)) + | ((in[14 + inpos]) << 12); + out[12 + outpos] = ((in[14 + inpos]) >>> (26 - 6)) + | ((in[15 + inpos]) << 6); + out[13 + outpos] = in[16 + inpos] | ((in[17 + inpos]) << 26); + out[14 + outpos] = ((in[17 + inpos]) >>> (26 - 20)) + | ((in[18 + inpos]) << 20); + out[15 + outpos] = ((in[18 + inpos]) >>> (26 - 14)) + | ((in[19 + inpos]) << 14); + out[16 + outpos] = ((in[19 + inpos]) >>> (26 - 8)) + | ((in[20 + inpos]) << 8); + out[17 + outpos] = ((in[20 + inpos]) >>> (26 - 2)) + | ((in[21 + inpos]) << 2) | ((in[22 + inpos]) << 28); + out[18 + outpos] = ((in[22 + inpos]) >>> (26 - 22)) + | ((in[23 + inpos]) << 22); + out[19 + outpos] = ((in[23 + inpos]) >>> (26 - 16)) + | ((in[24 + inpos]) << 16); + out[20 + outpos] = ((in[24 + inpos]) >>> (26 - 10)) + | ((in[25 + inpos]) << 10); + out[21 + outpos] = ((in[25 + inpos]) >>> (26 - 4)) + | ((in[26 + inpos]) << 4) | ((in[27 + inpos]) << 30); + out[22 + outpos] = ((in[27 + inpos]) >>> (26 - 24)) + | ((in[28 + inpos]) << 24); + out[23 + outpos] = ((in[28 + inpos]) >>> (26 - 18)) + | ((in[29 + inpos]) << 18); + out[24 + outpos] = ((in[29 + inpos]) >>> (26 - 12)) + | ((in[30 + inpos]) << 12); + out[25 + outpos] = ((in[30 + inpos]) >>> (26 - 6)) + | ((in[31 + inpos]) << 6); + } - protected static void fastunpack17(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = ((in[0 + inpos] >>> 0) & 131071) - ; - out[1 + outpos] = (in[0 + inpos] >>> 17) - | ((in[1 + inpos] & 3) << (17 - 2)) - ; - out[2 + outpos] = ((in[1 + inpos] >>> 2) & 131071) - ; - out[3 + outpos] = (in[1 + inpos] >>> 19) - | ((in[2 + inpos] & 15) << (17 - 4)) - ; - out[4 + outpos] = ((in[2 + inpos] >>> 4) & 131071) - ; - out[5 + outpos] = (in[2 + inpos] >>> 21) - | ((in[3 + inpos] & 63) << (17 - 6)) - ; - out[6 + outpos] = ((in[3 + inpos] >>> 6) & 131071) - ; - out[7 + outpos] = (in[3 + inpos] >>> 23) - | ((in[4 + inpos] & 255) << (17 - 8)) - ; - out[8 + outpos] = ((in[4 + inpos] >>> 8) & 131071) - ; - out[9 + outpos] = (in[4 + inpos] >>> 25) - | ((in[5 + inpos] & 1023) << (17 - 10)) - ; - out[10 + outpos] = ((in[5 + inpos] >>> 10) & 131071) - ; - out[11 + outpos] = (in[5 + inpos] >>> 27) - | ((in[6 + inpos] & 4095) << (17 - 12)) - ; - out[12 + outpos] = ((in[6 + inpos] >>> 12) & 131071) - ; - out[13 + outpos] = (in[6 + inpos] >>> 29) - | ((in[7 + inpos] & 16383) << (17 - 14)) - ; - out[14 + outpos] = ((in[7 + inpos] >>> 14) & 131071) - ; - out[15 + outpos] = (in[7 + inpos] >>> 31) - | ((in[8 + inpos] & 65535) << (17 - 16)) - ; - out[16 + outpos] = (in[8 + inpos] >>> 16) - | ((in[9 + inpos] & 1) << (17 - 1)) - ; - out[17 + outpos] = ((in[9 + inpos] >>> 1) & 131071) - ; - out[18 + outpos] = (in[9 + inpos] >>> 18) - | ((in[10 + inpos] & 7) << (17 - 3)) - ; - out[19 + outpos] = ((in[10 + inpos] >>> 3) & 131071) - ; - out[20 + outpos] = (in[10 + inpos] >>> 20) - | ((in[11 + inpos] & 31) << (17 - 5)) - ; - out[21 + outpos] = ((in[11 + inpos] >>> 5) & 131071) - ; - out[22 + outpos] = (in[11 + inpos] >>> 22) - | ((in[12 + inpos] & 127) << (17 - 7)) - ; - out[23 + outpos] = ((in[12 + inpos] >>> 7) & 131071) - ; - out[24 + outpos] = (in[12 + inpos] >>> 24) - | ((in[13 + inpos] & 511) << (17 - 9)) - ; - out[25 + outpos] = ((in[13 + inpos] >>> 9) & 131071) - ; - out[26 + outpos] = (in[13 + inpos] >>> 26) - | ((in[14 + inpos] & 2047) << (17 - 11)) - ; - out[27 + outpos] = ((in[14 + inpos] >>> 11) & 131071) - ; - out[28 + outpos] = (in[14 + inpos] >>> 28) - | ((in[15 + inpos] & 8191) << (17 - 13)) - ; - out[29 + outpos] = ((in[15 + inpos] >>> 13) & 131071) - ; - out[30 + outpos] = (in[15 + inpos] >>> 30) - | ((in[16 + inpos] & 32767) << (17 - 15)) - ; - out[31 + outpos] = (in[16 + inpos] >>> 15) - ; - } + protected static void fastpackwithoutmask27(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = in[0 + inpos] | ((in[1 + inpos]) << 27); + out[1 + outpos] = ((in[1 + inpos]) >>> (27 - 22)) + | ((in[2 + inpos]) << 22); + out[2 + outpos] = ((in[2 + inpos]) >>> (27 - 17)) + | ((in[3 + inpos]) << 17); + out[3 + outpos] = ((in[3 + inpos]) >>> (27 - 12)) + | ((in[4 + inpos]) << 12); + out[4 + outpos] = ((in[4 + inpos]) >>> (27 - 7)) + | ((in[5 + inpos]) << 7); + out[5 + outpos] = ((in[5 + inpos]) >>> (27 - 2)) + | ((in[6 + inpos]) << 2) | ((in[7 + inpos]) << 29); + out[6 + outpos] = ((in[7 + inpos]) >>> (27 - 24)) + | ((in[8 + inpos]) << 24); + out[7 + outpos] = ((in[8 + inpos]) >>> (27 - 19)) + | ((in[9 + inpos]) << 19); + out[8 + outpos] = ((in[9 + inpos]) >>> (27 - 14)) + | ((in[10 + inpos]) << 14); + out[9 + outpos] = ((in[10 + inpos]) >>> (27 - 9)) + | ((in[11 + inpos]) << 9); + out[10 + outpos] = ((in[11 + inpos]) >>> (27 - 4)) + | ((in[12 + inpos]) << 4) | ((in[13 + inpos]) << 31); + out[11 + outpos] = ((in[13 + inpos]) >>> (27 - 26)) + | ((in[14 + inpos]) << 26); + out[12 + outpos] = ((in[14 + inpos]) >>> (27 - 21)) + | ((in[15 + inpos]) << 21); + out[13 + outpos] = ((in[15 + inpos]) >>> (27 - 16)) + | ((in[16 + inpos]) << 16); + out[14 + outpos] = ((in[16 + inpos]) >>> (27 - 11)) + | ((in[17 + inpos]) << 11); + out[15 + outpos] = ((in[17 + inpos]) >>> (27 - 6)) + | ((in[18 + inpos]) << 6); + out[16 + outpos] = ((in[18 + inpos]) >>> (27 - 1)) + | ((in[19 + inpos]) << 1) | ((in[20 + inpos]) << 28); + out[17 + outpos] = ((in[20 + inpos]) >>> (27 - 23)) + | ((in[21 + inpos]) << 23); + out[18 + outpos] = ((in[21 + inpos]) >>> (27 - 18)) + | ((in[22 + inpos]) << 18); + out[19 + outpos] = ((in[22 + inpos]) >>> (27 - 13)) + | ((in[23 + inpos]) << 13); + out[20 + outpos] = ((in[23 + inpos]) >>> (27 - 8)) + | ((in[24 + inpos]) << 8); + out[21 + outpos] = ((in[24 + inpos]) >>> (27 - 3)) + | ((in[25 + inpos]) << 3) | ((in[26 + inpos]) << 30); + out[22 + outpos] = ((in[26 + inpos]) >>> (27 - 25)) + | ((in[27 + inpos]) << 25); + out[23 + outpos] = ((in[27 + inpos]) >>> (27 - 20)) + | ((in[28 + inpos]) << 20); + out[24 + outpos] = ((in[28 + inpos]) >>> (27 - 15)) + | ((in[29 + inpos]) << 15); + out[25 + outpos] = ((in[29 + inpos]) >>> (27 - 10)) + | ((in[30 + inpos]) << 10); + out[26 + outpos] = ((in[30 + inpos]) >>> (27 - 5)) + | ((in[31 + inpos]) << 5); + } + protected static void fastpackwithoutmask28(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = in[0 + inpos] | ((in[1 + inpos]) << 28); + out[1 + outpos] = ((in[1 + inpos]) >>> (28 - 24)) + | ((in[2 + inpos]) << 24); + out[2 + outpos] = ((in[2 + inpos]) >>> (28 - 20)) + | ((in[3 + inpos]) << 20); + out[3 + outpos] = ((in[3 + inpos]) >>> (28 - 16)) + | ((in[4 + inpos]) << 16); + out[4 + outpos] = ((in[4 + inpos]) >>> (28 - 12)) + | ((in[5 + inpos]) << 12); + out[5 + outpos] = ((in[5 + inpos]) >>> (28 - 8)) + | ((in[6 + inpos]) << 8); + out[6 + outpos] = ((in[6 + inpos]) >>> (28 - 4)) + | ((in[7 + inpos]) << 4); + out[7 + outpos] = in[8 + inpos] | ((in[9 + inpos]) << 28); + out[8 + outpos] = ((in[9 + inpos]) >>> (28 - 24)) + | ((in[10 + inpos]) << 24); + out[9 + outpos] = ((in[10 + inpos]) >>> (28 - 20)) + | ((in[11 + inpos]) << 20); + out[10 + outpos] = ((in[11 + inpos]) >>> (28 - 16)) + | ((in[12 + inpos]) << 16); + out[11 + outpos] = ((in[12 + inpos]) >>> (28 - 12)) + | ((in[13 + inpos]) << 12); + out[12 + outpos] = ((in[13 + inpos]) >>> (28 - 8)) + | ((in[14 + inpos]) << 8); + out[13 + outpos] = ((in[14 + inpos]) >>> (28 - 4)) + | ((in[15 + inpos]) << 4); + out[14 + outpos] = in[16 + inpos] | ((in[17 + inpos]) << 28); + out[15 + outpos] = ((in[17 + inpos]) >>> (28 - 24)) + | ((in[18 + inpos]) << 24); + out[16 + outpos] = ((in[18 + inpos]) >>> (28 - 20)) + | ((in[19 + inpos]) << 20); + out[17 + outpos] = ((in[19 + inpos]) >>> (28 - 16)) + | ((in[20 + inpos]) << 16); + out[18 + outpos] = ((in[20 + inpos]) >>> (28 - 12)) + | ((in[21 + inpos]) << 12); + out[19 + outpos] = ((in[21 + inpos]) >>> (28 - 8)) + | ((in[22 + inpos]) << 8); + out[20 + outpos] = ((in[22 + inpos]) >>> (28 - 4)) + | ((in[23 + inpos]) << 4); + out[21 + outpos] = in[24 + inpos] | ((in[25 + inpos]) << 28); + out[22 + outpos] = ((in[25 + inpos]) >>> (28 - 24)) + | ((in[26 + inpos]) << 24); + out[23 + outpos] = ((in[26 + inpos]) >>> (28 - 20)) + | ((in[27 + inpos]) << 20); + out[24 + outpos] = ((in[27 + inpos]) >>> (28 - 16)) + | ((in[28 + inpos]) << 16); + out[25 + outpos] = ((in[28 + inpos]) >>> (28 - 12)) + | ((in[29 + inpos]) << 12); + out[26 + outpos] = ((in[29 + inpos]) >>> (28 - 8)) + | ((in[30 + inpos]) << 8); + out[27 + outpos] = ((in[30 + inpos]) >>> (28 - 4)) + | ((in[31 + inpos]) << 4); + } - protected static void fastunpack18(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = ((in[0 + inpos] >>> 0) & 262143) - ; - out[1 + outpos] = (in[0 + inpos] >>> 18) - | ((in[1 + inpos] & 15) << (18 - 4)) - ; - out[2 + outpos] = ((in[1 + inpos] >>> 4) & 262143) - ; - out[3 + outpos] = (in[1 + inpos] >>> 22) - | ((in[2 + inpos] & 255) << (18 - 8)) - ; - out[4 + outpos] = ((in[2 + inpos] >>> 8) & 262143) - ; - out[5 + outpos] = (in[2 + inpos] >>> 26) - | ((in[3 + inpos] & 4095) << (18 - 12)) - ; - out[6 + outpos] = ((in[3 + inpos] >>> 12) & 262143) - ; - out[7 + outpos] = (in[3 + inpos] >>> 30) - | ((in[4 + inpos] & 65535) << (18 - 16)) - ; - out[8 + outpos] = (in[4 + inpos] >>> 16) - | ((in[5 + inpos] & 3) << (18 - 2)) - ; - out[9 + outpos] = ((in[5 + inpos] >>> 2) & 262143) - ; - out[10 + outpos] = (in[5 + inpos] >>> 20) - | ((in[6 + inpos] & 63) << (18 - 6)) - ; - out[11 + outpos] = ((in[6 + inpos] >>> 6) & 262143) - ; - out[12 + outpos] = (in[6 + inpos] >>> 24) - | ((in[7 + inpos] & 1023) << (18 - 10)) - ; - out[13 + outpos] = ((in[7 + inpos] >>> 10) & 262143) - ; - out[14 + outpos] = (in[7 + inpos] >>> 28) - | ((in[8 + inpos] & 16383) << (18 - 14)) - ; - out[15 + outpos] = (in[8 + inpos] >>> 14) - ; - out[16 + outpos] = ((in[9 + inpos] >>> 0) & 262143) - ; - out[17 + outpos] = (in[9 + inpos] >>> 18) - | ((in[10 + inpos] & 15) << (18 - 4)) - ; - out[18 + outpos] = ((in[10 + inpos] >>> 4) & 262143) - ; - out[19 + outpos] = (in[10 + inpos] >>> 22) - | ((in[11 + inpos] & 255) << (18 - 8)) - ; - out[20 + outpos] = ((in[11 + inpos] >>> 8) & 262143) - ; - out[21 + outpos] = (in[11 + inpos] >>> 26) - | ((in[12 + inpos] & 4095) << (18 - 12)) - ; - out[22 + outpos] = ((in[12 + inpos] >>> 12) & 262143) - ; - out[23 + outpos] = (in[12 + inpos] >>> 30) - | ((in[13 + inpos] & 65535) << (18 - 16)) - ; - out[24 + outpos] = (in[13 + inpos] >>> 16) - | ((in[14 + inpos] & 3) << (18 - 2)) - ; - out[25 + outpos] = ((in[14 + inpos] >>> 2) & 262143) - ; - out[26 + outpos] = (in[14 + inpos] >>> 20) - | ((in[15 + inpos] & 63) << (18 - 6)) - ; - out[27 + outpos] = ((in[15 + inpos] >>> 6) & 262143) - ; - out[28 + outpos] = (in[15 + inpos] >>> 24) - | ((in[16 + inpos] & 1023) << (18 - 10)) - ; - out[29 + outpos] = ((in[16 + inpos] >>> 10) & 262143) - ; - out[30 + outpos] = (in[16 + inpos] >>> 28) - | ((in[17 + inpos] & 16383) << (18 - 14)) - ; - out[31 + outpos] = (in[17 + inpos] >>> 14) - ; - } + protected static void fastpackwithoutmask29(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = in[0 + inpos] | ((in[1 + inpos]) << 29); + out[1 + outpos] = ((in[1 + inpos]) >>> (29 - 26)) + | ((in[2 + inpos]) << 26); + out[2 + outpos] = ((in[2 + inpos]) >>> (29 - 23)) + | ((in[3 + inpos]) << 23); + out[3 + outpos] = ((in[3 + inpos]) >>> (29 - 20)) + | ((in[4 + inpos]) << 20); + out[4 + outpos] = ((in[4 + inpos]) >>> (29 - 17)) + | ((in[5 + inpos]) << 17); + out[5 + outpos] = ((in[5 + inpos]) >>> (29 - 14)) + | ((in[6 + inpos]) << 14); + out[6 + outpos] = ((in[6 + inpos]) >>> (29 - 11)) + | ((in[7 + inpos]) << 11); + out[7 + outpos] = ((in[7 + inpos]) >>> (29 - 8)) + | ((in[8 + inpos]) << 8); + out[8 + outpos] = ((in[8 + inpos]) >>> (29 - 5)) + | ((in[9 + inpos]) << 5); + out[9 + outpos] = ((in[9 + inpos]) >>> (29 - 2)) + | ((in[10 + inpos]) << 2) | ((in[11 + inpos]) << 31); + out[10 + outpos] = ((in[11 + inpos]) >>> (29 - 28)) + | ((in[12 + inpos]) << 28); + out[11 + outpos] = ((in[12 + inpos]) >>> (29 - 25)) + | ((in[13 + inpos]) << 25); + out[12 + outpos] = ((in[13 + inpos]) >>> (29 - 22)) + | ((in[14 + inpos]) << 22); + out[13 + outpos] = ((in[14 + inpos]) >>> (29 - 19)) + | ((in[15 + inpos]) << 19); + out[14 + outpos] = ((in[15 + inpos]) >>> (29 - 16)) + | ((in[16 + inpos]) << 16); + out[15 + outpos] = ((in[16 + inpos]) >>> (29 - 13)) + | ((in[17 + inpos]) << 13); + out[16 + outpos] = ((in[17 + inpos]) >>> (29 - 10)) + | ((in[18 + inpos]) << 10); + out[17 + outpos] = ((in[18 + inpos]) >>> (29 - 7)) + | ((in[19 + inpos]) << 7); + out[18 + outpos] = ((in[19 + inpos]) >>> (29 - 4)) + | ((in[20 + inpos]) << 4); + out[19 + outpos] = ((in[20 + inpos]) >>> (29 - 1)) + | ((in[21 + inpos]) << 1) | ((in[22 + inpos]) << 30); + out[20 + outpos] = ((in[22 + inpos]) >>> (29 - 27)) + | ((in[23 + inpos]) << 27); + out[21 + outpos] = ((in[23 + inpos]) >>> (29 - 24)) + | ((in[24 + inpos]) << 24); + out[22 + outpos] = ((in[24 + inpos]) >>> (29 - 21)) + | ((in[25 + inpos]) << 21); + out[23 + outpos] = ((in[25 + inpos]) >>> (29 - 18)) + | ((in[26 + inpos]) << 18); + out[24 + outpos] = ((in[26 + inpos]) >>> (29 - 15)) + | ((in[27 + inpos]) << 15); + out[25 + outpos] = ((in[27 + inpos]) >>> (29 - 12)) + | ((in[28 + inpos]) << 12); + out[26 + outpos] = ((in[28 + inpos]) >>> (29 - 9)) + | ((in[29 + inpos]) << 9); + out[27 + outpos] = ((in[29 + inpos]) >>> (29 - 6)) + | ((in[30 + inpos]) << 6); + out[28 + outpos] = ((in[30 + inpos]) >>> (29 - 3)) + | ((in[31 + inpos]) << 3); + } + protected static void fastpackwithoutmask3(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = in[0 + inpos] | ((in[1 + inpos]) << 3) + | ((in[2 + inpos]) << 6) | ((in[3 + inpos]) << 9) + | ((in[4 + inpos]) << 12) | ((in[5 + inpos]) << 15) + | ((in[6 + inpos]) << 18) | ((in[7 + inpos]) << 21) + | ((in[8 + inpos]) << 24) | ((in[9 + inpos]) << 27) + | ((in[10 + inpos]) << 30); + out[1 + outpos] = ((in[10 + inpos]) >>> (3 - 1)) + | ((in[11 + inpos]) << 1) | ((in[12 + inpos]) << 4) + | ((in[13 + inpos]) << 7) | ((in[14 + inpos]) << 10) + | ((in[15 + inpos]) << 13) | ((in[16 + inpos]) << 16) + | ((in[17 + inpos]) << 19) | ((in[18 + inpos]) << 22) + | ((in[19 + inpos]) << 25) | ((in[20 + inpos]) << 28) + | ((in[21 + inpos]) << 31); + out[2 + outpos] = ((in[21 + inpos]) >>> (3 - 2)) + | ((in[22 + inpos]) << 2) | ((in[23 + inpos]) << 5) + | ((in[24 + inpos]) << 8) | ((in[25 + inpos]) << 11) + | ((in[26 + inpos]) << 14) | ((in[27 + inpos]) << 17) + | ((in[28 + inpos]) << 20) | ((in[29 + inpos]) << 23) + | ((in[30 + inpos]) << 26) | ((in[31 + inpos]) << 29); + } - protected static void fastunpack19(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = ((in[0 + inpos] >>> 0) & 524287) - ; - out[1 + outpos] = (in[0 + inpos] >>> 19) - | ((in[1 + inpos] & 63) << (19 - 6)) - ; - out[2 + outpos] = ((in[1 + inpos] >>> 6) & 524287) - ; - out[3 + outpos] = (in[1 + inpos] >>> 25) - | ((in[2 + inpos] & 4095) << (19 - 12)) - ; - out[4 + outpos] = ((in[2 + inpos] >>> 12) & 524287) - ; - out[5 + outpos] = (in[2 + inpos] >>> 31) - | ((in[3 + inpos] & 262143) << (19 - 18)) - ; - out[6 + outpos] = (in[3 + inpos] >>> 18) - | ((in[4 + inpos] & 31) << (19 - 5)) - ; - out[7 + outpos] = ((in[4 + inpos] >>> 5) & 524287) - ; - out[8 + outpos] = (in[4 + inpos] >>> 24) - | ((in[5 + inpos] & 2047) << (19 - 11)) - ; - out[9 + outpos] = ((in[5 + inpos] >>> 11) & 524287) - ; - out[10 + outpos] = (in[5 + inpos] >>> 30) - | ((in[6 + inpos] & 131071) << (19 - 17)) - ; - out[11 + outpos] = (in[6 + inpos] >>> 17) - | ((in[7 + inpos] & 15) << (19 - 4)) - ; - out[12 + outpos] = ((in[7 + inpos] >>> 4) & 524287) - ; - out[13 + outpos] = (in[7 + inpos] >>> 23) - | ((in[8 + inpos] & 1023) << (19 - 10)) - ; - out[14 + outpos] = ((in[8 + inpos] >>> 10) & 524287) - ; - out[15 + outpos] = (in[8 + inpos] >>> 29) - | ((in[9 + inpos] & 65535) << (19 - 16)) - ; - out[16 + outpos] = (in[9 + inpos] >>> 16) - | ((in[10 + inpos] & 7) << (19 - 3)) - ; - out[17 + outpos] = ((in[10 + inpos] >>> 3) & 524287) - ; - out[18 + outpos] = (in[10 + inpos] >>> 22) - | ((in[11 + inpos] & 511) << (19 - 9)) - ; - out[19 + outpos] = ((in[11 + inpos] >>> 9) & 524287) - ; - out[20 + outpos] = (in[11 + inpos] >>> 28) - | ((in[12 + inpos] & 32767) << (19 - 15)) - ; - out[21 + outpos] = (in[12 + inpos] >>> 15) - | ((in[13 + inpos] & 3) << (19 - 2)) - ; - out[22 + outpos] = ((in[13 + inpos] >>> 2) & 524287) - ; - out[23 + outpos] = (in[13 + inpos] >>> 21) - | ((in[14 + inpos] & 255) << (19 - 8)) - ; - out[24 + outpos] = ((in[14 + inpos] >>> 8) & 524287) - ; - out[25 + outpos] = (in[14 + inpos] >>> 27) - | ((in[15 + inpos] & 16383) << (19 - 14)) - ; - out[26 + outpos] = (in[15 + inpos] >>> 14) - | ((in[16 + inpos] & 1) << (19 - 1)) - ; - out[27 + outpos] = ((in[16 + inpos] >>> 1) & 524287) - ; - out[28 + outpos] = (in[16 + inpos] >>> 20) - | ((in[17 + inpos] & 127) << (19 - 7)) - ; - out[29 + outpos] = ((in[17 + inpos] >>> 7) & 524287) - ; - out[30 + outpos] = (in[17 + inpos] >>> 26) - | ((in[18 + inpos] & 8191) << (19 - 13)) - ; - out[31 + outpos] = (in[18 + inpos] >>> 13) - ; - } + protected static void fastpackwithoutmask30(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = in[0 + inpos] | ((in[1 + inpos]) << 30); + out[1 + outpos] = ((in[1 + inpos]) >>> (30 - 28)) + | ((in[2 + inpos]) << 28); + out[2 + outpos] = ((in[2 + inpos]) >>> (30 - 26)) + | ((in[3 + inpos]) << 26); + out[3 + outpos] = ((in[3 + inpos]) >>> (30 - 24)) + | ((in[4 + inpos]) << 24); + out[4 + outpos] = ((in[4 + inpos]) >>> (30 - 22)) + | ((in[5 + inpos]) << 22); + out[5 + outpos] = ((in[5 + inpos]) >>> (30 - 20)) + | ((in[6 + inpos]) << 20); + out[6 + outpos] = ((in[6 + inpos]) >>> (30 - 18)) + | ((in[7 + inpos]) << 18); + out[7 + outpos] = ((in[7 + inpos]) >>> (30 - 16)) + | ((in[8 + inpos]) << 16); + out[8 + outpos] = ((in[8 + inpos]) >>> (30 - 14)) + | ((in[9 + inpos]) << 14); + out[9 + outpos] = ((in[9 + inpos]) >>> (30 - 12)) + | ((in[10 + inpos]) << 12); + out[10 + outpos] = ((in[10 + inpos]) >>> (30 - 10)) + | ((in[11 + inpos]) << 10); + out[11 + outpos] = ((in[11 + inpos]) >>> (30 - 8)) + | ((in[12 + inpos]) << 8); + out[12 + outpos] = ((in[12 + inpos]) >>> (30 - 6)) + | ((in[13 + inpos]) << 6); + out[13 + outpos] = ((in[13 + inpos]) >>> (30 - 4)) + | ((in[14 + inpos]) << 4); + out[14 + outpos] = ((in[14 + inpos]) >>> (30 - 2)) + | ((in[15 + inpos]) << 2); + out[15 + outpos] = in[16 + inpos] | ((in[17 + inpos]) << 30); + out[16 + outpos] = ((in[17 + inpos]) >>> (30 - 28)) + | ((in[18 + inpos]) << 28); + out[17 + outpos] = ((in[18 + inpos]) >>> (30 - 26)) + | ((in[19 + inpos]) << 26); + out[18 + outpos] = ((in[19 + inpos]) >>> (30 - 24)) + | ((in[20 + inpos]) << 24); + out[19 + outpos] = ((in[20 + inpos]) >>> (30 - 22)) + | ((in[21 + inpos]) << 22); + out[20 + outpos] = ((in[21 + inpos]) >>> (30 - 20)) + | ((in[22 + inpos]) << 20); + out[21 + outpos] = ((in[22 + inpos]) >>> (30 - 18)) + | ((in[23 + inpos]) << 18); + out[22 + outpos] = ((in[23 + inpos]) >>> (30 - 16)) + | ((in[24 + inpos]) << 16); + out[23 + outpos] = ((in[24 + inpos]) >>> (30 - 14)) + | ((in[25 + inpos]) << 14); + out[24 + outpos] = ((in[25 + inpos]) >>> (30 - 12)) + | ((in[26 + inpos]) << 12); + out[25 + outpos] = ((in[26 + inpos]) >>> (30 - 10)) + | ((in[27 + inpos]) << 10); + out[26 + outpos] = ((in[27 + inpos]) >>> (30 - 8)) + | ((in[28 + inpos]) << 8); + out[27 + outpos] = ((in[28 + inpos]) >>> (30 - 6)) + | ((in[29 + inpos]) << 6); + out[28 + outpos] = ((in[29 + inpos]) >>> (30 - 4)) + | ((in[30 + inpos]) << 4); + out[29 + outpos] = ((in[30 + inpos]) >>> (30 - 2)) + | ((in[31 + inpos]) << 2); + } + protected static void fastpackwithoutmask31(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = in[0 + inpos] | ((in[1 + inpos]) << 31); + out[1 + outpos] = ((in[1 + inpos]) >>> (31 - 30)) + | ((in[2 + inpos]) << 30); + out[2 + outpos] = ((in[2 + inpos]) >>> (31 - 29)) + | ((in[3 + inpos]) << 29); + out[3 + outpos] = ((in[3 + inpos]) >>> (31 - 28)) + | ((in[4 + inpos]) << 28); + out[4 + outpos] = ((in[4 + inpos]) >>> (31 - 27)) + | ((in[5 + inpos]) << 27); + out[5 + outpos] = ((in[5 + inpos]) >>> (31 - 26)) + | ((in[6 + inpos]) << 26); + out[6 + outpos] = ((in[6 + inpos]) >>> (31 - 25)) + | ((in[7 + inpos]) << 25); + out[7 + outpos] = ((in[7 + inpos]) >>> (31 - 24)) + | ((in[8 + inpos]) << 24); + out[8 + outpos] = ((in[8 + inpos]) >>> (31 - 23)) + | ((in[9 + inpos]) << 23); + out[9 + outpos] = ((in[9 + inpos]) >>> (31 - 22)) + | ((in[10 + inpos]) << 22); + out[10 + outpos] = ((in[10 + inpos]) >>> (31 - 21)) + | ((in[11 + inpos]) << 21); + out[11 + outpos] = ((in[11 + inpos]) >>> (31 - 20)) + | ((in[12 + inpos]) << 20); + out[12 + outpos] = ((in[12 + inpos]) >>> (31 - 19)) + | ((in[13 + inpos]) << 19); + out[13 + outpos] = ((in[13 + inpos]) >>> (31 - 18)) + | ((in[14 + inpos]) << 18); + out[14 + outpos] = ((in[14 + inpos]) >>> (31 - 17)) + | ((in[15 + inpos]) << 17); + out[15 + outpos] = ((in[15 + inpos]) >>> (31 - 16)) + | ((in[16 + inpos]) << 16); + out[16 + outpos] = ((in[16 + inpos]) >>> (31 - 15)) + | ((in[17 + inpos]) << 15); + out[17 + outpos] = ((in[17 + inpos]) >>> (31 - 14)) + | ((in[18 + inpos]) << 14); + out[18 + outpos] = ((in[18 + inpos]) >>> (31 - 13)) + | ((in[19 + inpos]) << 13); + out[19 + outpos] = ((in[19 + inpos]) >>> (31 - 12)) + | ((in[20 + inpos]) << 12); + out[20 + outpos] = ((in[20 + inpos]) >>> (31 - 11)) + | ((in[21 + inpos]) << 11); + out[21 + outpos] = ((in[21 + inpos]) >>> (31 - 10)) + | ((in[22 + inpos]) << 10); + out[22 + outpos] = ((in[22 + inpos]) >>> (31 - 9)) + | ((in[23 + inpos]) << 9); + out[23 + outpos] = ((in[23 + inpos]) >>> (31 - 8)) + | ((in[24 + inpos]) << 8); + out[24 + outpos] = ((in[24 + inpos]) >>> (31 - 7)) + | ((in[25 + inpos]) << 7); + out[25 + outpos] = ((in[25 + inpos]) >>> (31 - 6)) + | ((in[26 + inpos]) << 6); + out[26 + outpos] = ((in[26 + inpos]) >>> (31 - 5)) + | ((in[27 + inpos]) << 5); + out[27 + outpos] = ((in[27 + inpos]) >>> (31 - 4)) + | ((in[28 + inpos]) << 4); + out[28 + outpos] = ((in[28 + inpos]) >>> (31 - 3)) + | ((in[29 + inpos]) << 3); + out[29 + outpos] = ((in[29 + inpos]) >>> (31 - 2)) + | ((in[30 + inpos]) << 2); + out[30 + outpos] = ((in[30 + inpos]) >>> (31 - 1)) + | ((in[31 + inpos]) << 1); + } - protected static void fastunpack20(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = ((in[0 + inpos] >>> 0) & 1048575) - ; - out[1 + outpos] = (in[0 + inpos] >>> 20) - | ((in[1 + inpos] & 255) << (20 - 8)) - ; - out[2 + outpos] = ((in[1 + inpos] >>> 8) & 1048575) - ; - out[3 + outpos] = (in[1 + inpos] >>> 28) - | ((in[2 + inpos] & 65535) << (20 - 16)) - ; - out[4 + outpos] = (in[2 + inpos] >>> 16) - | ((in[3 + inpos] & 15) << (20 - 4)) - ; - out[5 + outpos] = ((in[3 + inpos] >>> 4) & 1048575) - ; - out[6 + outpos] = (in[3 + inpos] >>> 24) - | ((in[4 + inpos] & 4095) << (20 - 12)) - ; - out[7 + outpos] = (in[4 + inpos] >>> 12) - ; - out[8 + outpos] = ((in[5 + inpos] >>> 0) & 1048575) - ; - out[9 + outpos] = (in[5 + inpos] >>> 20) - | ((in[6 + inpos] & 255) << (20 - 8)) - ; - out[10 + outpos] = ((in[6 + inpos] >>> 8) & 1048575) - ; - out[11 + outpos] = (in[6 + inpos] >>> 28) - | ((in[7 + inpos] & 65535) << (20 - 16)) - ; - out[12 + outpos] = (in[7 + inpos] >>> 16) - | ((in[8 + inpos] & 15) << (20 - 4)) - ; - out[13 + outpos] = ((in[8 + inpos] >>> 4) & 1048575) - ; - out[14 + outpos] = (in[8 + inpos] >>> 24) - | ((in[9 + inpos] & 4095) << (20 - 12)) - ; - out[15 + outpos] = (in[9 + inpos] >>> 12) - ; - out[16 + outpos] = ((in[10 + inpos] >>> 0) & 1048575) - ; - out[17 + outpos] = (in[10 + inpos] >>> 20) - | ((in[11 + inpos] & 255) << (20 - 8)) - ; - out[18 + outpos] = ((in[11 + inpos] >>> 8) & 1048575) - ; - out[19 + outpos] = (in[11 + inpos] >>> 28) - | ((in[12 + inpos] & 65535) << (20 - 16)) - ; - out[20 + outpos] = (in[12 + inpos] >>> 16) - | ((in[13 + inpos] & 15) << (20 - 4)) - ; - out[21 + outpos] = ((in[13 + inpos] >>> 4) & 1048575) - ; - out[22 + outpos] = (in[13 + inpos] >>> 24) - | ((in[14 + inpos] & 4095) << (20 - 12)) - ; - out[23 + outpos] = (in[14 + inpos] >>> 12) - ; - out[24 + outpos] = ((in[15 + inpos] >>> 0) & 1048575) - ; - out[25 + outpos] = (in[15 + inpos] >>> 20) - | ((in[16 + inpos] & 255) << (20 - 8)) - ; - out[26 + outpos] = ((in[16 + inpos] >>> 8) & 1048575) - ; - out[27 + outpos] = (in[16 + inpos] >>> 28) - | ((in[17 + inpos] & 65535) << (20 - 16)) - ; - out[28 + outpos] = (in[17 + inpos] >>> 16) - | ((in[18 + inpos] & 15) << (20 - 4)) - ; - out[29 + outpos] = ((in[18 + inpos] >>> 4) & 1048575) - ; - out[30 + outpos] = (in[18 + inpos] >>> 24) - | ((in[19 + inpos] & 4095) << (20 - 12)) - ; - out[31 + outpos] = (in[19 + inpos] >>> 12) - ; - } + protected static void fastpackwithoutmask32(final int[] in, int inpos, + final int[] out, int outpos) { + System.arraycopy(in, inpos, out, outpos, 32); + } + protected static void fastpackwithoutmask4(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = in[0 + inpos] | ((in[1 + inpos]) << 4) + | ((in[2 + inpos]) << 8) | ((in[3 + inpos]) << 12) + | ((in[4 + inpos]) << 16) | ((in[5 + inpos]) << 20) + | ((in[6 + inpos]) << 24) | ((in[7 + inpos]) << 28); + out[1 + outpos] = in[8 + inpos] | ((in[9 + inpos]) << 4) + | ((in[10 + inpos]) << 8) | ((in[11 + inpos]) << 12) + | ((in[12 + inpos]) << 16) | ((in[13 + inpos]) << 20) + | ((in[14 + inpos]) << 24) | ((in[15 + inpos]) << 28); + out[2 + outpos] = in[16 + inpos] | ((in[17 + inpos]) << 4) + | ((in[18 + inpos]) << 8) | ((in[19 + inpos]) << 12) + | ((in[20 + inpos]) << 16) | ((in[21 + inpos]) << 20) + | ((in[22 + inpos]) << 24) | ((in[23 + inpos]) << 28); + out[3 + outpos] = in[24 + inpos] | ((in[25 + inpos]) << 4) + | ((in[26 + inpos]) << 8) | ((in[27 + inpos]) << 12) + | ((in[28 + inpos]) << 16) | ((in[29 + inpos]) << 20) + | ((in[30 + inpos]) << 24) | ((in[31 + inpos]) << 28); + } - protected static void fastunpack21(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = ((in[0 + inpos] >>> 0) & 2097151) - ; - out[1 + outpos] = (in[0 + inpos] >>> 21) - | ((in[1 + inpos] & 1023) << (21 - 10)) - ; - out[2 + outpos] = ((in[1 + inpos] >>> 10) & 2097151) - ; - out[3 + outpos] = (in[1 + inpos] >>> 31) - | ((in[2 + inpos] & 1048575) << (21 - 20)) - ; - out[4 + outpos] = (in[2 + inpos] >>> 20) - | ((in[3 + inpos] & 511) << (21 - 9)) - ; - out[5 + outpos] = ((in[3 + inpos] >>> 9) & 2097151) - ; - out[6 + outpos] = (in[3 + inpos] >>> 30) - | ((in[4 + inpos] & 524287) << (21 - 19)) - ; - out[7 + outpos] = (in[4 + inpos] >>> 19) - | ((in[5 + inpos] & 255) << (21 - 8)) - ; - out[8 + outpos] = ((in[5 + inpos] >>> 8) & 2097151) - ; - out[9 + outpos] = (in[5 + inpos] >>> 29) - | ((in[6 + inpos] & 262143) << (21 - 18)) - ; - out[10 + outpos] = (in[6 + inpos] >>> 18) - | ((in[7 + inpos] & 127) << (21 - 7)) - ; - out[11 + outpos] = ((in[7 + inpos] >>> 7) & 2097151) - ; - out[12 + outpos] = (in[7 + inpos] >>> 28) - | ((in[8 + inpos] & 131071) << (21 - 17)) - ; - out[13 + outpos] = (in[8 + inpos] >>> 17) - | ((in[9 + inpos] & 63) << (21 - 6)) - ; - out[14 + outpos] = ((in[9 + inpos] >>> 6) & 2097151) - ; - out[15 + outpos] = (in[9 + inpos] >>> 27) - | ((in[10 + inpos] & 65535) << (21 - 16)) - ; - out[16 + outpos] = (in[10 + inpos] >>> 16) - | ((in[11 + inpos] & 31) << (21 - 5)) - ; - out[17 + outpos] = ((in[11 + inpos] >>> 5) & 2097151) - ; - out[18 + outpos] = (in[11 + inpos] >>> 26) - | ((in[12 + inpos] & 32767) << (21 - 15)) - ; - out[19 + outpos] = (in[12 + inpos] >>> 15) - | ((in[13 + inpos] & 15) << (21 - 4)) - ; - out[20 + outpos] = ((in[13 + inpos] >>> 4) & 2097151) - ; - out[21 + outpos] = (in[13 + inpos] >>> 25) - | ((in[14 + inpos] & 16383) << (21 - 14)) - ; - out[22 + outpos] = (in[14 + inpos] >>> 14) - | ((in[15 + inpos] & 7) << (21 - 3)) - ; - out[23 + outpos] = ((in[15 + inpos] >>> 3) & 2097151) - ; - out[24 + outpos] = (in[15 + inpos] >>> 24) - | ((in[16 + inpos] & 8191) << (21 - 13)) - ; - out[25 + outpos] = (in[16 + inpos] >>> 13) - | ((in[17 + inpos] & 3) << (21 - 2)) - ; - out[26 + outpos] = ((in[17 + inpos] >>> 2) & 2097151) - ; - out[27 + outpos] = (in[17 + inpos] >>> 23) - | ((in[18 + inpos] & 4095) << (21 - 12)) - ; - out[28 + outpos] = (in[18 + inpos] >>> 12) - | ((in[19 + inpos] & 1) << (21 - 1)) - ; - out[29 + outpos] = ((in[19 + inpos] >>> 1) & 2097151) - ; - out[30 + outpos] = (in[19 + inpos] >>> 22) - | ((in[20 + inpos] & 2047) << (21 - 11)) - ; - out[31 + outpos] = (in[20 + inpos] >>> 11) - ; - } + protected static void fastpackwithoutmask5(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = in[0 + inpos] | ((in[1 + inpos]) << 5) + | ((in[2 + inpos]) << 10) | ((in[3 + inpos]) << 15) + | ((in[4 + inpos]) << 20) | ((in[5 + inpos]) << 25) + | ((in[6 + inpos]) << 30); + out[1 + outpos] = ((in[6 + inpos]) >>> (5 - 3)) + | ((in[7 + inpos]) << 3) | ((in[8 + inpos]) << 8) + | ((in[9 + inpos]) << 13) | ((in[10 + inpos]) << 18) + | ((in[11 + inpos]) << 23) | ((in[12 + inpos]) << 28); + out[2 + outpos] = ((in[12 + inpos]) >>> (5 - 1)) + | ((in[13 + inpos]) << 1) | ((in[14 + inpos]) << 6) + | ((in[15 + inpos]) << 11) | ((in[16 + inpos]) << 16) + | ((in[17 + inpos]) << 21) | ((in[18 + inpos]) << 26) + | ((in[19 + inpos]) << 31); + out[3 + outpos] = ((in[19 + inpos]) >>> (5 - 4)) + | ((in[20 + inpos]) << 4) | ((in[21 + inpos]) << 9) + | ((in[22 + inpos]) << 14) | ((in[23 + inpos]) << 19) + | ((in[24 + inpos]) << 24) | ((in[25 + inpos]) << 29); + out[4 + outpos] = ((in[25 + inpos]) >>> (5 - 2)) + | ((in[26 + inpos]) << 2) | ((in[27 + inpos]) << 7) + | ((in[28 + inpos]) << 12) | ((in[29 + inpos]) << 17) + | ((in[30 + inpos]) << 22) | ((in[31 + inpos]) << 27); + } + protected static void fastpackwithoutmask6(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = in[0 + inpos] | ((in[1 + inpos]) << 6) + | ((in[2 + inpos]) << 12) | ((in[3 + inpos]) << 18) + | ((in[4 + inpos]) << 24) | ((in[5 + inpos]) << 30); + out[1 + outpos] = ((in[5 + inpos]) >>> (6 - 4)) + | ((in[6 + inpos]) << 4) | ((in[7 + inpos]) << 10) + | ((in[8 + inpos]) << 16) | ((in[9 + inpos]) << 22) + | ((in[10 + inpos]) << 28); + out[2 + outpos] = ((in[10 + inpos]) >>> (6 - 2)) + | ((in[11 + inpos]) << 2) | ((in[12 + inpos]) << 8) + | ((in[13 + inpos]) << 14) | ((in[14 + inpos]) << 20) + | ((in[15 + inpos]) << 26); + out[3 + outpos] = in[16 + inpos] | ((in[17 + inpos]) << 6) + | ((in[18 + inpos]) << 12) | ((in[19 + inpos]) << 18) + | ((in[20 + inpos]) << 24) | ((in[21 + inpos]) << 30); + out[4 + outpos] = ((in[21 + inpos]) >>> (6 - 4)) + | ((in[22 + inpos]) << 4) | ((in[23 + inpos]) << 10) + | ((in[24 + inpos]) << 16) | ((in[25 + inpos]) << 22) + | ((in[26 + inpos]) << 28); + out[5 + outpos] = ((in[26 + inpos]) >>> (6 - 2)) + | ((in[27 + inpos]) << 2) | ((in[28 + inpos]) << 8) + | ((in[29 + inpos]) << 14) | ((in[30 + inpos]) << 20) + | ((in[31 + inpos]) << 26); + } - protected static void fastunpack22(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = ((in[0 + inpos] >>> 0) & 4194303) - ; - out[1 + outpos] = (in[0 + inpos] >>> 22) - | ((in[1 + inpos] & 4095) << (22 - 12)) - ; - out[2 + outpos] = (in[1 + inpos] >>> 12) - | ((in[2 + inpos] & 3) << (22 - 2)) - ; - out[3 + outpos] = ((in[2 + inpos] >>> 2) & 4194303) - ; - out[4 + outpos] = (in[2 + inpos] >>> 24) - | ((in[3 + inpos] & 16383) << (22 - 14)) - ; - out[5 + outpos] = (in[3 + inpos] >>> 14) - | ((in[4 + inpos] & 15) << (22 - 4)) - ; - out[6 + outpos] = ((in[4 + inpos] >>> 4) & 4194303) - ; - out[7 + outpos] = (in[4 + inpos] >>> 26) - | ((in[5 + inpos] & 65535) << (22 - 16)) - ; - out[8 + outpos] = (in[5 + inpos] >>> 16) - | ((in[6 + inpos] & 63) << (22 - 6)) - ; - out[9 + outpos] = ((in[6 + inpos] >>> 6) & 4194303) - ; - out[10 + outpos] = (in[6 + inpos] >>> 28) - | ((in[7 + inpos] & 262143) << (22 - 18)) - ; - out[11 + outpos] = (in[7 + inpos] >>> 18) - | ((in[8 + inpos] & 255) << (22 - 8)) - ; - out[12 + outpos] = ((in[8 + inpos] >>> 8) & 4194303) - ; - out[13 + outpos] = (in[8 + inpos] >>> 30) - | ((in[9 + inpos] & 1048575) << (22 - 20)) - ; - out[14 + outpos] = (in[9 + inpos] >>> 20) - | ((in[10 + inpos] & 1023) << (22 - 10)) - ; - out[15 + outpos] = (in[10 + inpos] >>> 10) - ; - out[16 + outpos] = ((in[11 + inpos] >>> 0) & 4194303) - ; - out[17 + outpos] = (in[11 + inpos] >>> 22) - | ((in[12 + inpos] & 4095) << (22 - 12)) - ; - out[18 + outpos] = (in[12 + inpos] >>> 12) - | ((in[13 + inpos] & 3) << (22 - 2)) - ; - out[19 + outpos] = ((in[13 + inpos] >>> 2) & 4194303) - ; - out[20 + outpos] = (in[13 + inpos] >>> 24) - | ((in[14 + inpos] & 16383) << (22 - 14)) - ; - out[21 + outpos] = (in[14 + inpos] >>> 14) - | ((in[15 + inpos] & 15) << (22 - 4)) - ; - out[22 + outpos] = ((in[15 + inpos] >>> 4) & 4194303) - ; - out[23 + outpos] = (in[15 + inpos] >>> 26) - | ((in[16 + inpos] & 65535) << (22 - 16)) - ; - out[24 + outpos] = (in[16 + inpos] >>> 16) - | ((in[17 + inpos] & 63) << (22 - 6)) - ; - out[25 + outpos] = ((in[17 + inpos] >>> 6) & 4194303) - ; - out[26 + outpos] = (in[17 + inpos] >>> 28) - | ((in[18 + inpos] & 262143) << (22 - 18)) - ; - out[27 + outpos] = (in[18 + inpos] >>> 18) - | ((in[19 + inpos] & 255) << (22 - 8)) - ; - out[28 + outpos] = ((in[19 + inpos] >>> 8) & 4194303) - ; - out[29 + outpos] = (in[19 + inpos] >>> 30) - | ((in[20 + inpos] & 1048575) << (22 - 20)) - ; - out[30 + outpos] = (in[20 + inpos] >>> 20) - | ((in[21 + inpos] & 1023) << (22 - 10)) - ; - out[31 + outpos] = (in[21 + inpos] >>> 10) - ; - } + protected static void fastpackwithoutmask7(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = in[0 + inpos] | ((in[1 + inpos]) << 7) + | ((in[2 + inpos]) << 14) | ((in[3 + inpos]) << 21) + | ((in[4 + inpos]) << 28); + out[1 + outpos] = ((in[4 + inpos]) >>> (7 - 3)) + | ((in[5 + inpos]) << 3) | ((in[6 + inpos]) << 10) + | ((in[7 + inpos]) << 17) | ((in[8 + inpos]) << 24) + | ((in[9 + inpos]) << 31); + out[2 + outpos] = ((in[9 + inpos]) >>> (7 - 6)) + | ((in[10 + inpos]) << 6) | ((in[11 + inpos]) << 13) + | ((in[12 + inpos]) << 20) | ((in[13 + inpos]) << 27); + out[3 + outpos] = ((in[13 + inpos]) >>> (7 - 2)) + | ((in[14 + inpos]) << 2) | ((in[15 + inpos]) << 9) + | ((in[16 + inpos]) << 16) | ((in[17 + inpos]) << 23) + | ((in[18 + inpos]) << 30); + out[4 + outpos] = ((in[18 + inpos]) >>> (7 - 5)) + | ((in[19 + inpos]) << 5) | ((in[20 + inpos]) << 12) + | ((in[21 + inpos]) << 19) | ((in[22 + inpos]) << 26); + out[5 + outpos] = ((in[22 + inpos]) >>> (7 - 1)) + | ((in[23 + inpos]) << 1) | ((in[24 + inpos]) << 8) + | ((in[25 + inpos]) << 15) | ((in[26 + inpos]) << 22) + | ((in[27 + inpos]) << 29); + out[6 + outpos] = ((in[27 + inpos]) >>> (7 - 4)) + | ((in[28 + inpos]) << 4) | ((in[29 + inpos]) << 11) + | ((in[30 + inpos]) << 18) | ((in[31 + inpos]) << 25); + } + protected static void fastpackwithoutmask8(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = in[0 + inpos] | ((in[1 + inpos]) << 8) + | ((in[2 + inpos]) << 16) | ((in[3 + inpos]) << 24); + out[1 + outpos] = in[4 + inpos] | ((in[5 + inpos]) << 8) + | ((in[6 + inpos]) << 16) | ((in[7 + inpos]) << 24); + out[2 + outpos] = in[8 + inpos] | ((in[9 + inpos]) << 8) + | ((in[10 + inpos]) << 16) | ((in[11 + inpos]) << 24); + out[3 + outpos] = in[12 + inpos] | ((in[13 + inpos]) << 8) + | ((in[14 + inpos]) << 16) | ((in[15 + inpos]) << 24); + out[4 + outpos] = in[16 + inpos] | ((in[17 + inpos]) << 8) + | ((in[18 + inpos]) << 16) | ((in[19 + inpos]) << 24); + out[5 + outpos] = in[20 + inpos] | ((in[21 + inpos]) << 8) + | ((in[22 + inpos]) << 16) | ((in[23 + inpos]) << 24); + out[6 + outpos] = in[24 + inpos] | ((in[25 + inpos]) << 8) + | ((in[26 + inpos]) << 16) | ((in[27 + inpos]) << 24); + out[7 + outpos] = in[28 + inpos] | ((in[29 + inpos]) << 8) + | ((in[30 + inpos]) << 16) | ((in[31 + inpos]) << 24); + } - protected static void fastunpack23(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = ((in[0 + inpos] >>> 0) & 8388607) - ; - out[1 + outpos] = (in[0 + inpos] >>> 23) - | ((in[1 + inpos] & 16383) << (23 - 14)) - ; - out[2 + outpos] = (in[1 + inpos] >>> 14) - | ((in[2 + inpos] & 31) << (23 - 5)) - ; - out[3 + outpos] = ((in[2 + inpos] >>> 5) & 8388607) - ; - out[4 + outpos] = (in[2 + inpos] >>> 28) - | ((in[3 + inpos] & 524287) << (23 - 19)) - ; - out[5 + outpos] = (in[3 + inpos] >>> 19) - | ((in[4 + inpos] & 1023) << (23 - 10)) - ; - out[6 + outpos] = (in[4 + inpos] >>> 10) - | ((in[5 + inpos] & 1) << (23 - 1)) - ; - out[7 + outpos] = ((in[5 + inpos] >>> 1) & 8388607) - ; - out[8 + outpos] = (in[5 + inpos] >>> 24) - | ((in[6 + inpos] & 32767) << (23 - 15)) - ; - out[9 + outpos] = (in[6 + inpos] >>> 15) - | ((in[7 + inpos] & 63) << (23 - 6)) - ; - out[10 + outpos] = ((in[7 + inpos] >>> 6) & 8388607) - ; - out[11 + outpos] = (in[7 + inpos] >>> 29) - | ((in[8 + inpos] & 1048575) << (23 - 20)) - ; - out[12 + outpos] = (in[8 + inpos] >>> 20) - | ((in[9 + inpos] & 2047) << (23 - 11)) - ; - out[13 + outpos] = (in[9 + inpos] >>> 11) - | ((in[10 + inpos] & 3) << (23 - 2)) - ; - out[14 + outpos] = ((in[10 + inpos] >>> 2) & 8388607) - ; - out[15 + outpos] = (in[10 + inpos] >>> 25) - | ((in[11 + inpos] & 65535) << (23 - 16)) - ; - out[16 + outpos] = (in[11 + inpos] >>> 16) - | ((in[12 + inpos] & 127) << (23 - 7)) - ; - out[17 + outpos] = ((in[12 + inpos] >>> 7) & 8388607) - ; - out[18 + outpos] = (in[12 + inpos] >>> 30) - | ((in[13 + inpos] & 2097151) << (23 - 21)) - ; - out[19 + outpos] = (in[13 + inpos] >>> 21) - | ((in[14 + inpos] & 4095) << (23 - 12)) - ; - out[20 + outpos] = (in[14 + inpos] >>> 12) - | ((in[15 + inpos] & 7) << (23 - 3)) - ; - out[21 + outpos] = ((in[15 + inpos] >>> 3) & 8388607) - ; - out[22 + outpos] = (in[15 + inpos] >>> 26) - | ((in[16 + inpos] & 131071) << (23 - 17)) - ; - out[23 + outpos] = (in[16 + inpos] >>> 17) - | ((in[17 + inpos] & 255) << (23 - 8)) - ; - out[24 + outpos] = ((in[17 + inpos] >>> 8) & 8388607) - ; - out[25 + outpos] = (in[17 + inpos] >>> 31) - | ((in[18 + inpos] & 4194303) << (23 - 22)) - ; - out[26 + outpos] = (in[18 + inpos] >>> 22) - | ((in[19 + inpos] & 8191) << (23 - 13)) - ; - out[27 + outpos] = (in[19 + inpos] >>> 13) - | ((in[20 + inpos] & 15) << (23 - 4)) - ; - out[28 + outpos] = ((in[20 + inpos] >>> 4) & 8388607) - ; - out[29 + outpos] = (in[20 + inpos] >>> 27) - | ((in[21 + inpos] & 262143) << (23 - 18)) - ; - out[30 + outpos] = (in[21 + inpos] >>> 18) - | ((in[22 + inpos] & 511) << (23 - 9)) - ; - out[31 + outpos] = (in[22 + inpos] >>> 9) - ; - } + protected static void fastpackwithoutmask9(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = in[0 + inpos] | ((in[1 + inpos]) << 9) + | ((in[2 + inpos]) << 18) | ((in[3 + inpos]) << 27); + out[1 + outpos] = ((in[3 + inpos]) >>> (9 - 4)) + | ((in[4 + inpos]) << 4) | ((in[5 + inpos]) << 13) + | ((in[6 + inpos]) << 22) | ((in[7 + inpos]) << 31); + out[2 + outpos] = ((in[7 + inpos]) >>> (9 - 8)) + | ((in[8 + inpos]) << 8) | ((in[9 + inpos]) << 17) + | ((in[10 + inpos]) << 26); + out[3 + outpos] = ((in[10 + inpos]) >>> (9 - 3)) + | ((in[11 + inpos]) << 3) | ((in[12 + inpos]) << 12) + | ((in[13 + inpos]) << 21) | ((in[14 + inpos]) << 30); + out[4 + outpos] = ((in[14 + inpos]) >>> (9 - 7)) + | ((in[15 + inpos]) << 7) | ((in[16 + inpos]) << 16) + | ((in[17 + inpos]) << 25); + out[5 + outpos] = ((in[17 + inpos]) >>> (9 - 2)) + | ((in[18 + inpos]) << 2) | ((in[19 + inpos]) << 11) + | ((in[20 + inpos]) << 20) | ((in[21 + inpos]) << 29); + out[6 + outpos] = ((in[21 + inpos]) >>> (9 - 6)) + | ((in[22 + inpos]) << 6) | ((in[23 + inpos]) << 15) + | ((in[24 + inpos]) << 24); + out[7 + outpos] = ((in[24 + inpos]) >>> (9 - 1)) + | ((in[25 + inpos]) << 1) | ((in[26 + inpos]) << 10) + | ((in[27 + inpos]) << 19) | ((in[28 + inpos]) << 28); + out[8 + outpos] = ((in[28 + inpos]) >>> (9 - 5)) + | ((in[29 + inpos]) << 5) | ((in[30 + inpos]) << 14) + | ((in[31 + inpos]) << 23); + } + /** + * Unpack the 32 integers + * + * @param in + * source array + * @param inpos + * starting point in the source array + * @param out + * output array + * @param outpos + * starting point in the output array + * @param bit + * how many bits to use per integer + */ + public static void fastunpack(final int[] in, final int inpos, + final int[] out, final int outpos, final int bit) { + switch (bit) { + case 0: + fastunpack0(in, inpos, out, outpos); + break; + case 1: + fastunpack1(in, inpos, out, outpos); + break; + case 2: + fastunpack2(in, inpos, out, outpos); + break; + case 3: + fastunpack3(in, inpos, out, outpos); + break; + case 4: + fastunpack4(in, inpos, out, outpos); + break; + case 5: + fastunpack5(in, inpos, out, outpos); + break; + case 6: + fastunpack6(in, inpos, out, outpos); + break; + case 7: + fastunpack7(in, inpos, out, outpos); + break; + case 8: + fastunpack8(in, inpos, out, outpos); + break; + case 9: + fastunpack9(in, inpos, out, outpos); + break; + case 10: + fastunpack10(in, inpos, out, outpos); + break; + case 11: + fastunpack11(in, inpos, out, outpos); + break; + case 12: + fastunpack12(in, inpos, out, outpos); + break; + case 13: + fastunpack13(in, inpos, out, outpos); + break; + case 14: + fastunpack14(in, inpos, out, outpos); + break; + case 15: + fastunpack15(in, inpos, out, outpos); + break; + case 16: + fastunpack16(in, inpos, out, outpos); + break; + case 17: + fastunpack17(in, inpos, out, outpos); + break; + case 18: + fastunpack18(in, inpos, out, outpos); + break; + case 19: + fastunpack19(in, inpos, out, outpos); + break; + case 20: + fastunpack20(in, inpos, out, outpos); + break; + case 21: + fastunpack21(in, inpos, out, outpos); + break; + case 22: + fastunpack22(in, inpos, out, outpos); + break; + case 23: + fastunpack23(in, inpos, out, outpos); + break; + case 24: + fastunpack24(in, inpos, out, outpos); + break; + case 25: + fastunpack25(in, inpos, out, outpos); + break; + case 26: + fastunpack26(in, inpos, out, outpos); + break; + case 27: + fastunpack27(in, inpos, out, outpos); + break; + case 28: + fastunpack28(in, inpos, out, outpos); + break; + case 29: + fastunpack29(in, inpos, out, outpos); + break; + case 30: + fastunpack30(in, inpos, out, outpos); + break; + case 31: + fastunpack31(in, inpos, out, outpos); + break; + case 32: + fastunpack32(in, inpos, out, outpos); + break; + default: + throw new IllegalArgumentException( + "Unsupported bit width."); + } + } - protected static void fastunpack24(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = ((in[0 + inpos] >>> 0) & 16777215) - ; - out[1 + outpos] = (in[0 + inpos] >>> 24) - | ((in[1 + inpos] & 65535) << (24 - 16)) - ; - out[2 + outpos] = (in[1 + inpos] >>> 16) - | ((in[2 + inpos] & 255) << (24 - 8)) - ; - out[3 + outpos] = (in[2 + inpos] >>> 8) - ; - out[4 + outpos] = ((in[3 + inpos] >>> 0) & 16777215) - ; - out[5 + outpos] = (in[3 + inpos] >>> 24) - | ((in[4 + inpos] & 65535) << (24 - 16)) - ; - out[6 + outpos] = (in[4 + inpos] >>> 16) - | ((in[5 + inpos] & 255) << (24 - 8)) - ; - out[7 + outpos] = (in[5 + inpos] >>> 8) - ; - out[8 + outpos] = ((in[6 + inpos] >>> 0) & 16777215) - ; - out[9 + outpos] = (in[6 + inpos] >>> 24) - | ((in[7 + inpos] & 65535) << (24 - 16)) - ; - out[10 + outpos] = (in[7 + inpos] >>> 16) - | ((in[8 + inpos] & 255) << (24 - 8)) - ; - out[11 + outpos] = (in[8 + inpos] >>> 8) - ; - out[12 + outpos] = ((in[9 + inpos] >>> 0) & 16777215) - ; - out[13 + outpos] = (in[9 + inpos] >>> 24) - | ((in[10 + inpos] & 65535) << (24 - 16)) - ; - out[14 + outpos] = (in[10 + inpos] >>> 16) - | ((in[11 + inpos] & 255) << (24 - 8)) - ; - out[15 + outpos] = (in[11 + inpos] >>> 8) - ; - out[16 + outpos] = ((in[12 + inpos] >>> 0) & 16777215) - ; - out[17 + outpos] = (in[12 + inpos] >>> 24) - | ((in[13 + inpos] & 65535) << (24 - 16)) - ; - out[18 + outpos] = (in[13 + inpos] >>> 16) - | ((in[14 + inpos] & 255) << (24 - 8)) - ; - out[19 + outpos] = (in[14 + inpos] >>> 8) - ; - out[20 + outpos] = ((in[15 + inpos] >>> 0) & 16777215) - ; - out[21 + outpos] = (in[15 + inpos] >>> 24) - | ((in[16 + inpos] & 65535) << (24 - 16)) - ; - out[22 + outpos] = (in[16 + inpos] >>> 16) - | ((in[17 + inpos] & 255) << (24 - 8)) - ; - out[23 + outpos] = (in[17 + inpos] >>> 8) - ; - out[24 + outpos] = ((in[18 + inpos] >>> 0) & 16777215) - ; - out[25 + outpos] = (in[18 + inpos] >>> 24) - | ((in[19 + inpos] & 65535) << (24 - 16)) - ; - out[26 + outpos] = (in[19 + inpos] >>> 16) - | ((in[20 + inpos] & 255) << (24 - 8)) - ; - out[27 + outpos] = (in[20 + inpos] >>> 8) - ; - out[28 + outpos] = ((in[21 + inpos] >>> 0) & 16777215) - ; - out[29 + outpos] = (in[21 + inpos] >>> 24) - | ((in[22 + inpos] & 65535) << (24 - 16)) - ; - out[30 + outpos] = (in[22 + inpos] >>> 16) - | ((in[23 + inpos] & 255) << (24 - 8)) - ; - out[31 + outpos] = (in[23 + inpos] >>> 8) - ; - } + protected static void fastunpack0(final int[] in, int inpos, + final int[] out, int outpos) { + Arrays.fill(out, outpos, outpos + 32, 0); + } + protected static void fastunpack1(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = ((in[0 + inpos] >>> 0) & 1); + out[1 + outpos] = ((in[0 + inpos] >>> 1) & 1); + out[2 + outpos] = ((in[0 + inpos] >>> 2) & 1); + out[3 + outpos] = ((in[0 + inpos] >>> 3) & 1); + out[4 + outpos] = ((in[0 + inpos] >>> 4) & 1); + out[5 + outpos] = ((in[0 + inpos] >>> 5) & 1); + out[6 + outpos] = ((in[0 + inpos] >>> 6) & 1); + out[7 + outpos] = ((in[0 + inpos] >>> 7) & 1); + out[8 + outpos] = ((in[0 + inpos] >>> 8) & 1); + out[9 + outpos] = ((in[0 + inpos] >>> 9) & 1); + out[10 + outpos] = ((in[0 + inpos] >>> 10) & 1); + out[11 + outpos] = ((in[0 + inpos] >>> 11) & 1); + out[12 + outpos] = ((in[0 + inpos] >>> 12) & 1); + out[13 + outpos] = ((in[0 + inpos] >>> 13) & 1); + out[14 + outpos] = ((in[0 + inpos] >>> 14) & 1); + out[15 + outpos] = ((in[0 + inpos] >>> 15) & 1); + out[16 + outpos] = ((in[0 + inpos] >>> 16) & 1); + out[17 + outpos] = ((in[0 + inpos] >>> 17) & 1); + out[18 + outpos] = ((in[0 + inpos] >>> 18) & 1); + out[19 + outpos] = ((in[0 + inpos] >>> 19) & 1); + out[20 + outpos] = ((in[0 + inpos] >>> 20) & 1); + out[21 + outpos] = ((in[0 + inpos] >>> 21) & 1); + out[22 + outpos] = ((in[0 + inpos] >>> 22) & 1); + out[23 + outpos] = ((in[0 + inpos] >>> 23) & 1); + out[24 + outpos] = ((in[0 + inpos] >>> 24) & 1); + out[25 + outpos] = ((in[0 + inpos] >>> 25) & 1); + out[26 + outpos] = ((in[0 + inpos] >>> 26) & 1); + out[27 + outpos] = ((in[0 + inpos] >>> 27) & 1); + out[28 + outpos] = ((in[0 + inpos] >>> 28) & 1); + out[29 + outpos] = ((in[0 + inpos] >>> 29) & 1); + out[30 + outpos] = ((in[0 + inpos] >>> 30) & 1); + out[31 + outpos] = (in[0 + inpos] >>> 31); + } - protected static void fastunpack25(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = ((in[0 + inpos] >>> 0) & 33554431) - ; - out[1 + outpos] = (in[0 + inpos] >>> 25) - | ((in[1 + inpos] & 262143) << (25 - 18)) - ; - out[2 + outpos] = (in[1 + inpos] >>> 18) - | ((in[2 + inpos] & 2047) << (25 - 11)) - ; - out[3 + outpos] = (in[2 + inpos] >>> 11) - | ((in[3 + inpos] & 15) << (25 - 4)) - ; - out[4 + outpos] = ((in[3 + inpos] >>> 4) & 33554431) - ; - out[5 + outpos] = (in[3 + inpos] >>> 29) - | ((in[4 + inpos] & 4194303) << (25 - 22)) - ; - out[6 + outpos] = (in[4 + inpos] >>> 22) - | ((in[5 + inpos] & 32767) << (25 - 15)) - ; - out[7 + outpos] = (in[5 + inpos] >>> 15) - | ((in[6 + inpos] & 255) << (25 - 8)) - ; - out[8 + outpos] = (in[6 + inpos] >>> 8) - | ((in[7 + inpos] & 1) << (25 - 1)) - ; - out[9 + outpos] = ((in[7 + inpos] >>> 1) & 33554431) - ; - out[10 + outpos] = (in[7 + inpos] >>> 26) - | ((in[8 + inpos] & 524287) << (25 - 19)) - ; - out[11 + outpos] = (in[8 + inpos] >>> 19) - | ((in[9 + inpos] & 4095) << (25 - 12)) - ; - out[12 + outpos] = (in[9 + inpos] >>> 12) - | ((in[10 + inpos] & 31) << (25 - 5)) - ; - out[13 + outpos] = ((in[10 + inpos] >>> 5) & 33554431) - ; - out[14 + outpos] = (in[10 + inpos] >>> 30) - | ((in[11 + inpos] & 8388607) << (25 - 23)) - ; - out[15 + outpos] = (in[11 + inpos] >>> 23) - | ((in[12 + inpos] & 65535) << (25 - 16)) - ; - out[16 + outpos] = (in[12 + inpos] >>> 16) - | ((in[13 + inpos] & 511) << (25 - 9)) - ; - out[17 + outpos] = (in[13 + inpos] >>> 9) - | ((in[14 + inpos] & 3) << (25 - 2)) - ; - out[18 + outpos] = ((in[14 + inpos] >>> 2) & 33554431) - ; - out[19 + outpos] = (in[14 + inpos] >>> 27) - | ((in[15 + inpos] & 1048575) << (25 - 20)) - ; - out[20 + outpos] = (in[15 + inpos] >>> 20) - | ((in[16 + inpos] & 8191) << (25 - 13)) - ; - out[21 + outpos] = (in[16 + inpos] >>> 13) - | ((in[17 + inpos] & 63) << (25 - 6)) - ; - out[22 + outpos] = ((in[17 + inpos] >>> 6) & 33554431) - ; - out[23 + outpos] = (in[17 + inpos] >>> 31) - | ((in[18 + inpos] & 16777215) << (25 - 24)) - ; - out[24 + outpos] = (in[18 + inpos] >>> 24) - | ((in[19 + inpos] & 131071) << (25 - 17)) - ; - out[25 + outpos] = (in[19 + inpos] >>> 17) - | ((in[20 + inpos] & 1023) << (25 - 10)) - ; - out[26 + outpos] = (in[20 + inpos] >>> 10) - | ((in[21 + inpos] & 7) << (25 - 3)) - ; - out[27 + outpos] = ((in[21 + inpos] >>> 3) & 33554431) - ; - out[28 + outpos] = (in[21 + inpos] >>> 28) - | ((in[22 + inpos] & 2097151) << (25 - 21)) - ; - out[29 + outpos] = (in[22 + inpos] >>> 21) - | ((in[23 + inpos] & 16383) << (25 - 14)) - ; - out[30 + outpos] = (in[23 + inpos] >>> 14) - | ((in[24 + inpos] & 127) << (25 - 7)) - ; - out[31 + outpos] = (in[24 + inpos] >>> 7) - ; - } + protected static void fastunpack10(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = ((in[0 + inpos] >>> 0) & 1023); + out[1 + outpos] = ((in[0 + inpos] >>> 10) & 1023); + out[2 + outpos] = ((in[0 + inpos] >>> 20) & 1023); + out[3 + outpos] = (in[0 + inpos] >>> 30) + | ((in[1 + inpos] & 255) << (10 - 8)); + out[4 + outpos] = ((in[1 + inpos] >>> 8) & 1023); + out[5 + outpos] = ((in[1 + inpos] >>> 18) & 1023); + out[6 + outpos] = (in[1 + inpos] >>> 28) + | ((in[2 + inpos] & 63) << (10 - 6)); + out[7 + outpos] = ((in[2 + inpos] >>> 6) & 1023); + out[8 + outpos] = ((in[2 + inpos] >>> 16) & 1023); + out[9 + outpos] = (in[2 + inpos] >>> 26) + | ((in[3 + inpos] & 15) << (10 - 4)); + out[10 + outpos] = ((in[3 + inpos] >>> 4) & 1023); + out[11 + outpos] = ((in[3 + inpos] >>> 14) & 1023); + out[12 + outpos] = (in[3 + inpos] >>> 24) + | ((in[4 + inpos] & 3) << (10 - 2)); + out[13 + outpos] = ((in[4 + inpos] >>> 2) & 1023); + out[14 + outpos] = ((in[4 + inpos] >>> 12) & 1023); + out[15 + outpos] = (in[4 + inpos] >>> 22); + out[16 + outpos] = ((in[5 + inpos] >>> 0) & 1023); + out[17 + outpos] = ((in[5 + inpos] >>> 10) & 1023); + out[18 + outpos] = ((in[5 + inpos] >>> 20) & 1023); + out[19 + outpos] = (in[5 + inpos] >>> 30) + | ((in[6 + inpos] & 255) << (10 - 8)); + out[20 + outpos] = ((in[6 + inpos] >>> 8) & 1023); + out[21 + outpos] = ((in[6 + inpos] >>> 18) & 1023); + out[22 + outpos] = (in[6 + inpos] >>> 28) + | ((in[7 + inpos] & 63) << (10 - 6)); + out[23 + outpos] = ((in[7 + inpos] >>> 6) & 1023); + out[24 + outpos] = ((in[7 + inpos] >>> 16) & 1023); + out[25 + outpos] = (in[7 + inpos] >>> 26) + | ((in[8 + inpos] & 15) << (10 - 4)); + out[26 + outpos] = ((in[8 + inpos] >>> 4) & 1023); + out[27 + outpos] = ((in[8 + inpos] >>> 14) & 1023); + out[28 + outpos] = (in[8 + inpos] >>> 24) + | ((in[9 + inpos] & 3) << (10 - 2)); + out[29 + outpos] = ((in[9 + inpos] >>> 2) & 1023); + out[30 + outpos] = ((in[9 + inpos] >>> 12) & 1023); + out[31 + outpos] = (in[9 + inpos] >>> 22); + } + protected static void fastunpack11(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = ((in[0 + inpos] >>> 0) & 2047); + out[1 + outpos] = ((in[0 + inpos] >>> 11) & 2047); + out[2 + outpos] = (in[0 + inpos] >>> 22) + | ((in[1 + inpos] & 1) << (11 - 1)); + out[3 + outpos] = ((in[1 + inpos] >>> 1) & 2047); + out[4 + outpos] = ((in[1 + inpos] >>> 12) & 2047); + out[5 + outpos] = (in[1 + inpos] >>> 23) + | ((in[2 + inpos] & 3) << (11 - 2)); + out[6 + outpos] = ((in[2 + inpos] >>> 2) & 2047); + out[7 + outpos] = ((in[2 + inpos] >>> 13) & 2047); + out[8 + outpos] = (in[2 + inpos] >>> 24) + | ((in[3 + inpos] & 7) << (11 - 3)); + out[9 + outpos] = ((in[3 + inpos] >>> 3) & 2047); + out[10 + outpos] = ((in[3 + inpos] >>> 14) & 2047); + out[11 + outpos] = (in[3 + inpos] >>> 25) + | ((in[4 + inpos] & 15) << (11 - 4)); + out[12 + outpos] = ((in[4 + inpos] >>> 4) & 2047); + out[13 + outpos] = ((in[4 + inpos] >>> 15) & 2047); + out[14 + outpos] = (in[4 + inpos] >>> 26) + | ((in[5 + inpos] & 31) << (11 - 5)); + out[15 + outpos] = ((in[5 + inpos] >>> 5) & 2047); + out[16 + outpos] = ((in[5 + inpos] >>> 16) & 2047); + out[17 + outpos] = (in[5 + inpos] >>> 27) + | ((in[6 + inpos] & 63) << (11 - 6)); + out[18 + outpos] = ((in[6 + inpos] >>> 6) & 2047); + out[19 + outpos] = ((in[6 + inpos] >>> 17) & 2047); + out[20 + outpos] = (in[6 + inpos] >>> 28) + | ((in[7 + inpos] & 127) << (11 - 7)); + out[21 + outpos] = ((in[7 + inpos] >>> 7) & 2047); + out[22 + outpos] = ((in[7 + inpos] >>> 18) & 2047); + out[23 + outpos] = (in[7 + inpos] >>> 29) + | ((in[8 + inpos] & 255) << (11 - 8)); + out[24 + outpos] = ((in[8 + inpos] >>> 8) & 2047); + out[25 + outpos] = ((in[8 + inpos] >>> 19) & 2047); + out[26 + outpos] = (in[8 + inpos] >>> 30) + | ((in[9 + inpos] & 511) << (11 - 9)); + out[27 + outpos] = ((in[9 + inpos] >>> 9) & 2047); + out[28 + outpos] = ((in[9 + inpos] >>> 20) & 2047); + out[29 + outpos] = (in[9 + inpos] >>> 31) + | ((in[10 + inpos] & 1023) << (11 - 10)); + out[30 + outpos] = ((in[10 + inpos] >>> 10) & 2047); + out[31 + outpos] = (in[10 + inpos] >>> 21); + } - protected static void fastunpack26(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = ((in[0 + inpos] >>> 0) & 67108863) - ; - out[1 + outpos] = (in[0 + inpos] >>> 26) - | ((in[1 + inpos] & 1048575) << (26 - 20)) - ; - out[2 + outpos] = (in[1 + inpos] >>> 20) - | ((in[2 + inpos] & 16383) << (26 - 14)) - ; - out[3 + outpos] = (in[2 + inpos] >>> 14) - | ((in[3 + inpos] & 255) << (26 - 8)) - ; - out[4 + outpos] = (in[3 + inpos] >>> 8) - | ((in[4 + inpos] & 3) << (26 - 2)) - ; - out[5 + outpos] = ((in[4 + inpos] >>> 2) & 67108863) - ; - out[6 + outpos] = (in[4 + inpos] >>> 28) - | ((in[5 + inpos] & 4194303) << (26 - 22)) - ; - out[7 + outpos] = (in[5 + inpos] >>> 22) - | ((in[6 + inpos] & 65535) << (26 - 16)) - ; - out[8 + outpos] = (in[6 + inpos] >>> 16) - | ((in[7 + inpos] & 1023) << (26 - 10)) - ; - out[9 + outpos] = (in[7 + inpos] >>> 10) - | ((in[8 + inpos] & 15) << (26 - 4)) - ; - out[10 + outpos] = ((in[8 + inpos] >>> 4) & 67108863) - ; - out[11 + outpos] = (in[8 + inpos] >>> 30) - | ((in[9 + inpos] & 16777215) << (26 - 24)) - ; - out[12 + outpos] = (in[9 + inpos] >>> 24) - | ((in[10 + inpos] & 262143) << (26 - 18)) - ; - out[13 + outpos] = (in[10 + inpos] >>> 18) - | ((in[11 + inpos] & 4095) << (26 - 12)) - ; - out[14 + outpos] = (in[11 + inpos] >>> 12) - | ((in[12 + inpos] & 63) << (26 - 6)) - ; - out[15 + outpos] = (in[12 + inpos] >>> 6) - ; - out[16 + outpos] = ((in[13 + inpos] >>> 0) & 67108863) - ; - out[17 + outpos] = (in[13 + inpos] >>> 26) - | ((in[14 + inpos] & 1048575) << (26 - 20)) - ; - out[18 + outpos] = (in[14 + inpos] >>> 20) - | ((in[15 + inpos] & 16383) << (26 - 14)) - ; - out[19 + outpos] = (in[15 + inpos] >>> 14) - | ((in[16 + inpos] & 255) << (26 - 8)) - ; - out[20 + outpos] = (in[16 + inpos] >>> 8) - | ((in[17 + inpos] & 3) << (26 - 2)) - ; - out[21 + outpos] = ((in[17 + inpos] >>> 2) & 67108863) - ; - out[22 + outpos] = (in[17 + inpos] >>> 28) - | ((in[18 + inpos] & 4194303) << (26 - 22)) - ; - out[23 + outpos] = (in[18 + inpos] >>> 22) - | ((in[19 + inpos] & 65535) << (26 - 16)) - ; - out[24 + outpos] = (in[19 + inpos] >>> 16) - | ((in[20 + inpos] & 1023) << (26 - 10)) - ; - out[25 + outpos] = (in[20 + inpos] >>> 10) - | ((in[21 + inpos] & 15) << (26 - 4)) - ; - out[26 + outpos] = ((in[21 + inpos] >>> 4) & 67108863) - ; - out[27 + outpos] = (in[21 + inpos] >>> 30) - | ((in[22 + inpos] & 16777215) << (26 - 24)) - ; - out[28 + outpos] = (in[22 + inpos] >>> 24) - | ((in[23 + inpos] & 262143) << (26 - 18)) - ; - out[29 + outpos] = (in[23 + inpos] >>> 18) - | ((in[24 + inpos] & 4095) << (26 - 12)) - ; - out[30 + outpos] = (in[24 + inpos] >>> 12) - | ((in[25 + inpos] & 63) << (26 - 6)) - ; - out[31 + outpos] = (in[25 + inpos] >>> 6) - ; - } + protected static void fastunpack12(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = ((in[0 + inpos] >>> 0) & 4095); + out[1 + outpos] = ((in[0 + inpos] >>> 12) & 4095); + out[2 + outpos] = (in[0 + inpos] >>> 24) + | ((in[1 + inpos] & 15) << (12 - 4)); + out[3 + outpos] = ((in[1 + inpos] >>> 4) & 4095); + out[4 + outpos] = ((in[1 + inpos] >>> 16) & 4095); + out[5 + outpos] = (in[1 + inpos] >>> 28) + | ((in[2 + inpos] & 255) << (12 - 8)); + out[6 + outpos] = ((in[2 + inpos] >>> 8) & 4095); + out[7 + outpos] = (in[2 + inpos] >>> 20); + out[8 + outpos] = ((in[3 + inpos] >>> 0) & 4095); + out[9 + outpos] = ((in[3 + inpos] >>> 12) & 4095); + out[10 + outpos] = (in[3 + inpos] >>> 24) + | ((in[4 + inpos] & 15) << (12 - 4)); + out[11 + outpos] = ((in[4 + inpos] >>> 4) & 4095); + out[12 + outpos] = ((in[4 + inpos] >>> 16) & 4095); + out[13 + outpos] = (in[4 + inpos] >>> 28) + | ((in[5 + inpos] & 255) << (12 - 8)); + out[14 + outpos] = ((in[5 + inpos] >>> 8) & 4095); + out[15 + outpos] = (in[5 + inpos] >>> 20); + out[16 + outpos] = ((in[6 + inpos] >>> 0) & 4095); + out[17 + outpos] = ((in[6 + inpos] >>> 12) & 4095); + out[18 + outpos] = (in[6 + inpos] >>> 24) + | ((in[7 + inpos] & 15) << (12 - 4)); + out[19 + outpos] = ((in[7 + inpos] >>> 4) & 4095); + out[20 + outpos] = ((in[7 + inpos] >>> 16) & 4095); + out[21 + outpos] = (in[7 + inpos] >>> 28) + | ((in[8 + inpos] & 255) << (12 - 8)); + out[22 + outpos] = ((in[8 + inpos] >>> 8) & 4095); + out[23 + outpos] = (in[8 + inpos] >>> 20); + out[24 + outpos] = ((in[9 + inpos] >>> 0) & 4095); + out[25 + outpos] = ((in[9 + inpos] >>> 12) & 4095); + out[26 + outpos] = (in[9 + inpos] >>> 24) + | ((in[10 + inpos] & 15) << (12 - 4)); + out[27 + outpos] = ((in[10 + inpos] >>> 4) & 4095); + out[28 + outpos] = ((in[10 + inpos] >>> 16) & 4095); + out[29 + outpos] = (in[10 + inpos] >>> 28) + | ((in[11 + inpos] & 255) << (12 - 8)); + out[30 + outpos] = ((in[11 + inpos] >>> 8) & 4095); + out[31 + outpos] = (in[11 + inpos] >>> 20); + } + protected static void fastunpack13(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = ((in[0 + inpos] >>> 0) & 8191); + out[1 + outpos] = ((in[0 + inpos] >>> 13) & 8191); + out[2 + outpos] = (in[0 + inpos] >>> 26) + | ((in[1 + inpos] & 127) << (13 - 7)); + out[3 + outpos] = ((in[1 + inpos] >>> 7) & 8191); + out[4 + outpos] = (in[1 + inpos] >>> 20) + | ((in[2 + inpos] & 1) << (13 - 1)); + out[5 + outpos] = ((in[2 + inpos] >>> 1) & 8191); + out[6 + outpos] = ((in[2 + inpos] >>> 14) & 8191); + out[7 + outpos] = (in[2 + inpos] >>> 27) + | ((in[3 + inpos] & 255) << (13 - 8)); + out[8 + outpos] = ((in[3 + inpos] >>> 8) & 8191); + out[9 + outpos] = (in[3 + inpos] >>> 21) + | ((in[4 + inpos] & 3) << (13 - 2)); + out[10 + outpos] = ((in[4 + inpos] >>> 2) & 8191); + out[11 + outpos] = ((in[4 + inpos] >>> 15) & 8191); + out[12 + outpos] = (in[4 + inpos] >>> 28) + | ((in[5 + inpos] & 511) << (13 - 9)); + out[13 + outpos] = ((in[5 + inpos] >>> 9) & 8191); + out[14 + outpos] = (in[5 + inpos] >>> 22) + | ((in[6 + inpos] & 7) << (13 - 3)); + out[15 + outpos] = ((in[6 + inpos] >>> 3) & 8191); + out[16 + outpos] = ((in[6 + inpos] >>> 16) & 8191); + out[17 + outpos] = (in[6 + inpos] >>> 29) + | ((in[7 + inpos] & 1023) << (13 - 10)); + out[18 + outpos] = ((in[7 + inpos] >>> 10) & 8191); + out[19 + outpos] = (in[7 + inpos] >>> 23) + | ((in[8 + inpos] & 15) << (13 - 4)); + out[20 + outpos] = ((in[8 + inpos] >>> 4) & 8191); + out[21 + outpos] = ((in[8 + inpos] >>> 17) & 8191); + out[22 + outpos] = (in[8 + inpos] >>> 30) + | ((in[9 + inpos] & 2047) << (13 - 11)); + out[23 + outpos] = ((in[9 + inpos] >>> 11) & 8191); + out[24 + outpos] = (in[9 + inpos] >>> 24) + | ((in[10 + inpos] & 31) << (13 - 5)); + out[25 + outpos] = ((in[10 + inpos] >>> 5) & 8191); + out[26 + outpos] = ((in[10 + inpos] >>> 18) & 8191); + out[27 + outpos] = (in[10 + inpos] >>> 31) + | ((in[11 + inpos] & 4095) << (13 - 12)); + out[28 + outpos] = ((in[11 + inpos] >>> 12) & 8191); + out[29 + outpos] = (in[11 + inpos] >>> 25) + | ((in[12 + inpos] & 63) << (13 - 6)); + out[30 + outpos] = ((in[12 + inpos] >>> 6) & 8191); + out[31 + outpos] = (in[12 + inpos] >>> 19); + } - protected static void fastunpack27(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = ((in[0 + inpos] >>> 0) & 134217727) - ; - out[1 + outpos] = (in[0 + inpos] >>> 27) - | ((in[1 + inpos] & 4194303) << (27 - 22)) - ; - out[2 + outpos] = (in[1 + inpos] >>> 22) - | ((in[2 + inpos] & 131071) << (27 - 17)) - ; - out[3 + outpos] = (in[2 + inpos] >>> 17) - | ((in[3 + inpos] & 4095) << (27 - 12)) - ; - out[4 + outpos] = (in[3 + inpos] >>> 12) - | ((in[4 + inpos] & 127) << (27 - 7)) - ; - out[5 + outpos] = (in[4 + inpos] >>> 7) - | ((in[5 + inpos] & 3) << (27 - 2)) - ; - out[6 + outpos] = ((in[5 + inpos] >>> 2) & 134217727) - ; - out[7 + outpos] = (in[5 + inpos] >>> 29) - | ((in[6 + inpos] & 16777215) << (27 - 24)) - ; - out[8 + outpos] = (in[6 + inpos] >>> 24) - | ((in[7 + inpos] & 524287) << (27 - 19)) - ; - out[9 + outpos] = (in[7 + inpos] >>> 19) - | ((in[8 + inpos] & 16383) << (27 - 14)) - ; - out[10 + outpos] = (in[8 + inpos] >>> 14) - | ((in[9 + inpos] & 511) << (27 - 9)) - ; - out[11 + outpos] = (in[9 + inpos] >>> 9) - | ((in[10 + inpos] & 15) << (27 - 4)) - ; - out[12 + outpos] = ((in[10 + inpos] >>> 4) & 134217727) - ; - out[13 + outpos] = (in[10 + inpos] >>> 31) - | ((in[11 + inpos] & 67108863) << (27 - 26)) - ; - out[14 + outpos] = (in[11 + inpos] >>> 26) - | ((in[12 + inpos] & 2097151) << (27 - 21)) - ; - out[15 + outpos] = (in[12 + inpos] >>> 21) - | ((in[13 + inpos] & 65535) << (27 - 16)) - ; - out[16 + outpos] = (in[13 + inpos] >>> 16) - | ((in[14 + inpos] & 2047) << (27 - 11)) - ; - out[17 + outpos] = (in[14 + inpos] >>> 11) - | ((in[15 + inpos] & 63) << (27 - 6)) - ; - out[18 + outpos] = (in[15 + inpos] >>> 6) - | ((in[16 + inpos] & 1) << (27 - 1)) - ; - out[19 + outpos] = ((in[16 + inpos] >>> 1) & 134217727) - ; - out[20 + outpos] = (in[16 + inpos] >>> 28) - | ((in[17 + inpos] & 8388607) << (27 - 23)) - ; - out[21 + outpos] = (in[17 + inpos] >>> 23) - | ((in[18 + inpos] & 262143) << (27 - 18)) - ; - out[22 + outpos] = (in[18 + inpos] >>> 18) - | ((in[19 + inpos] & 8191) << (27 - 13)) - ; - out[23 + outpos] = (in[19 + inpos] >>> 13) - | ((in[20 + inpos] & 255) << (27 - 8)) - ; - out[24 + outpos] = (in[20 + inpos] >>> 8) - | ((in[21 + inpos] & 7) << (27 - 3)) - ; - out[25 + outpos] = ((in[21 + inpos] >>> 3) & 134217727) - ; - out[26 + outpos] = (in[21 + inpos] >>> 30) - | ((in[22 + inpos] & 33554431) << (27 - 25)) - ; - out[27 + outpos] = (in[22 + inpos] >>> 25) - | ((in[23 + inpos] & 1048575) << (27 - 20)) - ; - out[28 + outpos] = (in[23 + inpos] >>> 20) - | ((in[24 + inpos] & 32767) << (27 - 15)) - ; - out[29 + outpos] = (in[24 + inpos] >>> 15) - | ((in[25 + inpos] & 1023) << (27 - 10)) - ; - out[30 + outpos] = (in[25 + inpos] >>> 10) - | ((in[26 + inpos] & 31) << (27 - 5)) - ; - out[31 + outpos] = (in[26 + inpos] >>> 5) - ; - } + protected static void fastunpack14(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = ((in[0 + inpos] >>> 0) & 16383); + out[1 + outpos] = ((in[0 + inpos] >>> 14) & 16383); + out[2 + outpos] = (in[0 + inpos] >>> 28) + | ((in[1 + inpos] & 1023) << (14 - 10)); + out[3 + outpos] = ((in[1 + inpos] >>> 10) & 16383); + out[4 + outpos] = (in[1 + inpos] >>> 24) + | ((in[2 + inpos] & 63) << (14 - 6)); + out[5 + outpos] = ((in[2 + inpos] >>> 6) & 16383); + out[6 + outpos] = (in[2 + inpos] >>> 20) + | ((in[3 + inpos] & 3) << (14 - 2)); + out[7 + outpos] = ((in[3 + inpos] >>> 2) & 16383); + out[8 + outpos] = ((in[3 + inpos] >>> 16) & 16383); + out[9 + outpos] = (in[3 + inpos] >>> 30) + | ((in[4 + inpos] & 4095) << (14 - 12)); + out[10 + outpos] = ((in[4 + inpos] >>> 12) & 16383); + out[11 + outpos] = (in[4 + inpos] >>> 26) + | ((in[5 + inpos] & 255) << (14 - 8)); + out[12 + outpos] = ((in[5 + inpos] >>> 8) & 16383); + out[13 + outpos] = (in[5 + inpos] >>> 22) + | ((in[6 + inpos] & 15) << (14 - 4)); + out[14 + outpos] = ((in[6 + inpos] >>> 4) & 16383); + out[15 + outpos] = (in[6 + inpos] >>> 18); + out[16 + outpos] = ((in[7 + inpos] >>> 0) & 16383); + out[17 + outpos] = ((in[7 + inpos] >>> 14) & 16383); + out[18 + outpos] = (in[7 + inpos] >>> 28) + | ((in[8 + inpos] & 1023) << (14 - 10)); + out[19 + outpos] = ((in[8 + inpos] >>> 10) & 16383); + out[20 + outpos] = (in[8 + inpos] >>> 24) + | ((in[9 + inpos] & 63) << (14 - 6)); + out[21 + outpos] = ((in[9 + inpos] >>> 6) & 16383); + out[22 + outpos] = (in[9 + inpos] >>> 20) + | ((in[10 + inpos] & 3) << (14 - 2)); + out[23 + outpos] = ((in[10 + inpos] >>> 2) & 16383); + out[24 + outpos] = ((in[10 + inpos] >>> 16) & 16383); + out[25 + outpos] = (in[10 + inpos] >>> 30) + | ((in[11 + inpos] & 4095) << (14 - 12)); + out[26 + outpos] = ((in[11 + inpos] >>> 12) & 16383); + out[27 + outpos] = (in[11 + inpos] >>> 26) + | ((in[12 + inpos] & 255) << (14 - 8)); + out[28 + outpos] = ((in[12 + inpos] >>> 8) & 16383); + out[29 + outpos] = (in[12 + inpos] >>> 22) + | ((in[13 + inpos] & 15) << (14 - 4)); + out[30 + outpos] = ((in[13 + inpos] >>> 4) & 16383); + out[31 + outpos] = (in[13 + inpos] >>> 18); + } + protected static void fastunpack15(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = ((in[0 + inpos] >>> 0) & 32767); + out[1 + outpos] = ((in[0 + inpos] >>> 15) & 32767); + out[2 + outpos] = (in[0 + inpos] >>> 30) + | ((in[1 + inpos] & 8191) << (15 - 13)); + out[3 + outpos] = ((in[1 + inpos] >>> 13) & 32767); + out[4 + outpos] = (in[1 + inpos] >>> 28) + | ((in[2 + inpos] & 2047) << (15 - 11)); + out[5 + outpos] = ((in[2 + inpos] >>> 11) & 32767); + out[6 + outpos] = (in[2 + inpos] >>> 26) + | ((in[3 + inpos] & 511) << (15 - 9)); + out[7 + outpos] = ((in[3 + inpos] >>> 9) & 32767); + out[8 + outpos] = (in[3 + inpos] >>> 24) + | ((in[4 + inpos] & 127) << (15 - 7)); + out[9 + outpos] = ((in[4 + inpos] >>> 7) & 32767); + out[10 + outpos] = (in[4 + inpos] >>> 22) + | ((in[5 + inpos] & 31) << (15 - 5)); + out[11 + outpos] = ((in[5 + inpos] >>> 5) & 32767); + out[12 + outpos] = (in[5 + inpos] >>> 20) + | ((in[6 + inpos] & 7) << (15 - 3)); + out[13 + outpos] = ((in[6 + inpos] >>> 3) & 32767); + out[14 + outpos] = (in[6 + inpos] >>> 18) + | ((in[7 + inpos] & 1) << (15 - 1)); + out[15 + outpos] = ((in[7 + inpos] >>> 1) & 32767); + out[16 + outpos] = ((in[7 + inpos] >>> 16) & 32767); + out[17 + outpos] = (in[7 + inpos] >>> 31) + | ((in[8 + inpos] & 16383) << (15 - 14)); + out[18 + outpos] = ((in[8 + inpos] >>> 14) & 32767); + out[19 + outpos] = (in[8 + inpos] >>> 29) + | ((in[9 + inpos] & 4095) << (15 - 12)); + out[20 + outpos] = ((in[9 + inpos] >>> 12) & 32767); + out[21 + outpos] = (in[9 + inpos] >>> 27) + | ((in[10 + inpos] & 1023) << (15 - 10)); + out[22 + outpos] = ((in[10 + inpos] >>> 10) & 32767); + out[23 + outpos] = (in[10 + inpos] >>> 25) + | ((in[11 + inpos] & 255) << (15 - 8)); + out[24 + outpos] = ((in[11 + inpos] >>> 8) & 32767); + out[25 + outpos] = (in[11 + inpos] >>> 23) + | ((in[12 + inpos] & 63) << (15 - 6)); + out[26 + outpos] = ((in[12 + inpos] >>> 6) & 32767); + out[27 + outpos] = (in[12 + inpos] >>> 21) + | ((in[13 + inpos] & 15) << (15 - 4)); + out[28 + outpos] = ((in[13 + inpos] >>> 4) & 32767); + out[29 + outpos] = (in[13 + inpos] >>> 19) + | ((in[14 + inpos] & 3) << (15 - 2)); + out[30 + outpos] = ((in[14 + inpos] >>> 2) & 32767); + out[31 + outpos] = (in[14 + inpos] >>> 17); + } - protected static void fastunpack28(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = ((in[0 + inpos] >>> 0) & 268435455) - ; - out[1 + outpos] = (in[0 + inpos] >>> 28) - | ((in[1 + inpos] & 16777215) << (28 - 24)) - ; - out[2 + outpos] = (in[1 + inpos] >>> 24) - | ((in[2 + inpos] & 1048575) << (28 - 20)) - ; - out[3 + outpos] = (in[2 + inpos] >>> 20) - | ((in[3 + inpos] & 65535) << (28 - 16)) - ; - out[4 + outpos] = (in[3 + inpos] >>> 16) - | ((in[4 + inpos] & 4095) << (28 - 12)) - ; - out[5 + outpos] = (in[4 + inpos] >>> 12) - | ((in[5 + inpos] & 255) << (28 - 8)) - ; - out[6 + outpos] = (in[5 + inpos] >>> 8) - | ((in[6 + inpos] & 15) << (28 - 4)) - ; - out[7 + outpos] = (in[6 + inpos] >>> 4) - ; - out[8 + outpos] = ((in[7 + inpos] >>> 0) & 268435455) - ; - out[9 + outpos] = (in[7 + inpos] >>> 28) - | ((in[8 + inpos] & 16777215) << (28 - 24)) - ; - out[10 + outpos] = (in[8 + inpos] >>> 24) - | ((in[9 + inpos] & 1048575) << (28 - 20)) - ; - out[11 + outpos] = (in[9 + inpos] >>> 20) - | ((in[10 + inpos] & 65535) << (28 - 16)) - ; - out[12 + outpos] = (in[10 + inpos] >>> 16) - | ((in[11 + inpos] & 4095) << (28 - 12)) - ; - out[13 + outpos] = (in[11 + inpos] >>> 12) - | ((in[12 + inpos] & 255) << (28 - 8)) - ; - out[14 + outpos] = (in[12 + inpos] >>> 8) - | ((in[13 + inpos] & 15) << (28 - 4)) - ; - out[15 + outpos] = (in[13 + inpos] >>> 4) - ; - out[16 + outpos] = ((in[14 + inpos] >>> 0) & 268435455) - ; - out[17 + outpos] = (in[14 + inpos] >>> 28) - | ((in[15 + inpos] & 16777215) << (28 - 24)) - ; - out[18 + outpos] = (in[15 + inpos] >>> 24) - | ((in[16 + inpos] & 1048575) << (28 - 20)) - ; - out[19 + outpos] = (in[16 + inpos] >>> 20) - | ((in[17 + inpos] & 65535) << (28 - 16)) - ; - out[20 + outpos] = (in[17 + inpos] >>> 16) - | ((in[18 + inpos] & 4095) << (28 - 12)) - ; - out[21 + outpos] = (in[18 + inpos] >>> 12) - | ((in[19 + inpos] & 255) << (28 - 8)) - ; - out[22 + outpos] = (in[19 + inpos] >>> 8) - | ((in[20 + inpos] & 15) << (28 - 4)) - ; - out[23 + outpos] = (in[20 + inpos] >>> 4) - ; - out[24 + outpos] = ((in[21 + inpos] >>> 0) & 268435455) - ; - out[25 + outpos] = (in[21 + inpos] >>> 28) - | ((in[22 + inpos] & 16777215) << (28 - 24)) - ; - out[26 + outpos] = (in[22 + inpos] >>> 24) - | ((in[23 + inpos] & 1048575) << (28 - 20)) - ; - out[27 + outpos] = (in[23 + inpos] >>> 20) - | ((in[24 + inpos] & 65535) << (28 - 16)) - ; - out[28 + outpos] = (in[24 + inpos] >>> 16) - | ((in[25 + inpos] & 4095) << (28 - 12)) - ; - out[29 + outpos] = (in[25 + inpos] >>> 12) - | ((in[26 + inpos] & 255) << (28 - 8)) - ; - out[30 + outpos] = (in[26 + inpos] >>> 8) - | ((in[27 + inpos] & 15) << (28 - 4)) - ; - out[31 + outpos] = (in[27 + inpos] >>> 4) - ; - } + protected static void fastunpack16(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = ((in[0 + inpos] >>> 0) & 65535); + out[1 + outpos] = (in[0 + inpos] >>> 16); + out[2 + outpos] = ((in[1 + inpos] >>> 0) & 65535); + out[3 + outpos] = (in[1 + inpos] >>> 16); + out[4 + outpos] = ((in[2 + inpos] >>> 0) & 65535); + out[5 + outpos] = (in[2 + inpos] >>> 16); + out[6 + outpos] = ((in[3 + inpos] >>> 0) & 65535); + out[7 + outpos] = (in[3 + inpos] >>> 16); + out[8 + outpos] = ((in[4 + inpos] >>> 0) & 65535); + out[9 + outpos] = (in[4 + inpos] >>> 16); + out[10 + outpos] = ((in[5 + inpos] >>> 0) & 65535); + out[11 + outpos] = (in[5 + inpos] >>> 16); + out[12 + outpos] = ((in[6 + inpos] >>> 0) & 65535); + out[13 + outpos] = (in[6 + inpos] >>> 16); + out[14 + outpos] = ((in[7 + inpos] >>> 0) & 65535); + out[15 + outpos] = (in[7 + inpos] >>> 16); + out[16 + outpos] = ((in[8 + inpos] >>> 0) & 65535); + out[17 + outpos] = (in[8 + inpos] >>> 16); + out[18 + outpos] = ((in[9 + inpos] >>> 0) & 65535); + out[19 + outpos] = (in[9 + inpos] >>> 16); + out[20 + outpos] = ((in[10 + inpos] >>> 0) & 65535); + out[21 + outpos] = (in[10 + inpos] >>> 16); + out[22 + outpos] = ((in[11 + inpos] >>> 0) & 65535); + out[23 + outpos] = (in[11 + inpos] >>> 16); + out[24 + outpos] = ((in[12 + inpos] >>> 0) & 65535); + out[25 + outpos] = (in[12 + inpos] >>> 16); + out[26 + outpos] = ((in[13 + inpos] >>> 0) & 65535); + out[27 + outpos] = (in[13 + inpos] >>> 16); + out[28 + outpos] = ((in[14 + inpos] >>> 0) & 65535); + out[29 + outpos] = (in[14 + inpos] >>> 16); + out[30 + outpos] = ((in[15 + inpos] >>> 0) & 65535); + out[31 + outpos] = (in[15 + inpos] >>> 16); + } + protected static void fastunpack17(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = ((in[0 + inpos] >>> 0) & 131071); + out[1 + outpos] = (in[0 + inpos] >>> 17) + | ((in[1 + inpos] & 3) << (17 - 2)); + out[2 + outpos] = ((in[1 + inpos] >>> 2) & 131071); + out[3 + outpos] = (in[1 + inpos] >>> 19) + | ((in[2 + inpos] & 15) << (17 - 4)); + out[4 + outpos] = ((in[2 + inpos] >>> 4) & 131071); + out[5 + outpos] = (in[2 + inpos] >>> 21) + | ((in[3 + inpos] & 63) << (17 - 6)); + out[6 + outpos] = ((in[3 + inpos] >>> 6) & 131071); + out[7 + outpos] = (in[3 + inpos] >>> 23) + | ((in[4 + inpos] & 255) << (17 - 8)); + out[8 + outpos] = ((in[4 + inpos] >>> 8) & 131071); + out[9 + outpos] = (in[4 + inpos] >>> 25) + | ((in[5 + inpos] & 1023) << (17 - 10)); + out[10 + outpos] = ((in[5 + inpos] >>> 10) & 131071); + out[11 + outpos] = (in[5 + inpos] >>> 27) + | ((in[6 + inpos] & 4095) << (17 - 12)); + out[12 + outpos] = ((in[6 + inpos] >>> 12) & 131071); + out[13 + outpos] = (in[6 + inpos] >>> 29) + | ((in[7 + inpos] & 16383) << (17 - 14)); + out[14 + outpos] = ((in[7 + inpos] >>> 14) & 131071); + out[15 + outpos] = (in[7 + inpos] >>> 31) + | ((in[8 + inpos] & 65535) << (17 - 16)); + out[16 + outpos] = (in[8 + inpos] >>> 16) + | ((in[9 + inpos] & 1) << (17 - 1)); + out[17 + outpos] = ((in[9 + inpos] >>> 1) & 131071); + out[18 + outpos] = (in[9 + inpos] >>> 18) + | ((in[10 + inpos] & 7) << (17 - 3)); + out[19 + outpos] = ((in[10 + inpos] >>> 3) & 131071); + out[20 + outpos] = (in[10 + inpos] >>> 20) + | ((in[11 + inpos] & 31) << (17 - 5)); + out[21 + outpos] = ((in[11 + inpos] >>> 5) & 131071); + out[22 + outpos] = (in[11 + inpos] >>> 22) + | ((in[12 + inpos] & 127) << (17 - 7)); + out[23 + outpos] = ((in[12 + inpos] >>> 7) & 131071); + out[24 + outpos] = (in[12 + inpos] >>> 24) + | ((in[13 + inpos] & 511) << (17 - 9)); + out[25 + outpos] = ((in[13 + inpos] >>> 9) & 131071); + out[26 + outpos] = (in[13 + inpos] >>> 26) + | ((in[14 + inpos] & 2047) << (17 - 11)); + out[27 + outpos] = ((in[14 + inpos] >>> 11) & 131071); + out[28 + outpos] = (in[14 + inpos] >>> 28) + | ((in[15 + inpos] & 8191) << (17 - 13)); + out[29 + outpos] = ((in[15 + inpos] >>> 13) & 131071); + out[30 + outpos] = (in[15 + inpos] >>> 30) + | ((in[16 + inpos] & 32767) << (17 - 15)); + out[31 + outpos] = (in[16 + inpos] >>> 15); + } - protected static void fastunpack29(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = ((in[0 + inpos] >>> 0) & 536870911) - ; - out[1 + outpos] = (in[0 + inpos] >>> 29) - | ((in[1 + inpos] & 67108863) << (29 - 26)) - ; - out[2 + outpos] = (in[1 + inpos] >>> 26) - | ((in[2 + inpos] & 8388607) << (29 - 23)) - ; - out[3 + outpos] = (in[2 + inpos] >>> 23) - | ((in[3 + inpos] & 1048575) << (29 - 20)) - ; - out[4 + outpos] = (in[3 + inpos] >>> 20) - | ((in[4 + inpos] & 131071) << (29 - 17)) - ; - out[5 + outpos] = (in[4 + inpos] >>> 17) - | ((in[5 + inpos] & 16383) << (29 - 14)) - ; - out[6 + outpos] = (in[5 + inpos] >>> 14) - | ((in[6 + inpos] & 2047) << (29 - 11)) - ; - out[7 + outpos] = (in[6 + inpos] >>> 11) - | ((in[7 + inpos] & 255) << (29 - 8)) - ; - out[8 + outpos] = (in[7 + inpos] >>> 8) - | ((in[8 + inpos] & 31) << (29 - 5)) - ; - out[9 + outpos] = (in[8 + inpos] >>> 5) - | ((in[9 + inpos] & 3) << (29 - 2)) - ; - out[10 + outpos] = ((in[9 + inpos] >>> 2) & 536870911) - ; - out[11 + outpos] = (in[9 + inpos] >>> 31) - | ((in[10 + inpos] & 268435455) << (29 - 28)) - ; - out[12 + outpos] = (in[10 + inpos] >>> 28) - | ((in[11 + inpos] & 33554431) << (29 - 25)) - ; - out[13 + outpos] = (in[11 + inpos] >>> 25) - | ((in[12 + inpos] & 4194303) << (29 - 22)) - ; - out[14 + outpos] = (in[12 + inpos] >>> 22) - | ((in[13 + inpos] & 524287) << (29 - 19)) - ; - out[15 + outpos] = (in[13 + inpos] >>> 19) - | ((in[14 + inpos] & 65535) << (29 - 16)) - ; - out[16 + outpos] = (in[14 + inpos] >>> 16) - | ((in[15 + inpos] & 8191) << (29 - 13)) - ; - out[17 + outpos] = (in[15 + inpos] >>> 13) - | ((in[16 + inpos] & 1023) << (29 - 10)) - ; - out[18 + outpos] = (in[16 + inpos] >>> 10) - | ((in[17 + inpos] & 127) << (29 - 7)) - ; - out[19 + outpos] = (in[17 + inpos] >>> 7) - | ((in[18 + inpos] & 15) << (29 - 4)) - ; - out[20 + outpos] = (in[18 + inpos] >>> 4) - | ((in[19 + inpos] & 1) << (29 - 1)) - ; - out[21 + outpos] = ((in[19 + inpos] >>> 1) & 536870911) - ; - out[22 + outpos] = (in[19 + inpos] >>> 30) - | ((in[20 + inpos] & 134217727) << (29 - 27)) - ; - out[23 + outpos] = (in[20 + inpos] >>> 27) - | ((in[21 + inpos] & 16777215) << (29 - 24)) - ; - out[24 + outpos] = (in[21 + inpos] >>> 24) - | ((in[22 + inpos] & 2097151) << (29 - 21)) - ; - out[25 + outpos] = (in[22 + inpos] >>> 21) - | ((in[23 + inpos] & 262143) << (29 - 18)) - ; - out[26 + outpos] = (in[23 + inpos] >>> 18) - | ((in[24 + inpos] & 32767) << (29 - 15)) - ; - out[27 + outpos] = (in[24 + inpos] >>> 15) - | ((in[25 + inpos] & 4095) << (29 - 12)) - ; - out[28 + outpos] = (in[25 + inpos] >>> 12) - | ((in[26 + inpos] & 511) << (29 - 9)) - ; - out[29 + outpos] = (in[26 + inpos] >>> 9) - | ((in[27 + inpos] & 63) << (29 - 6)) - ; - out[30 + outpos] = (in[27 + inpos] >>> 6) - | ((in[28 + inpos] & 7) << (29 - 3)) - ; - out[31 + outpos] = (in[28 + inpos] >>> 3) - ; - } + protected static void fastunpack18(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = ((in[0 + inpos] >>> 0) & 262143); + out[1 + outpos] = (in[0 + inpos] >>> 18) + | ((in[1 + inpos] & 15) << (18 - 4)); + out[2 + outpos] = ((in[1 + inpos] >>> 4) & 262143); + out[3 + outpos] = (in[1 + inpos] >>> 22) + | ((in[2 + inpos] & 255) << (18 - 8)); + out[4 + outpos] = ((in[2 + inpos] >>> 8) & 262143); + out[5 + outpos] = (in[2 + inpos] >>> 26) + | ((in[3 + inpos] & 4095) << (18 - 12)); + out[6 + outpos] = ((in[3 + inpos] >>> 12) & 262143); + out[7 + outpos] = (in[3 + inpos] >>> 30) + | ((in[4 + inpos] & 65535) << (18 - 16)); + out[8 + outpos] = (in[4 + inpos] >>> 16) + | ((in[5 + inpos] & 3) << (18 - 2)); + out[9 + outpos] = ((in[5 + inpos] >>> 2) & 262143); + out[10 + outpos] = (in[5 + inpos] >>> 20) + | ((in[6 + inpos] & 63) << (18 - 6)); + out[11 + outpos] = ((in[6 + inpos] >>> 6) & 262143); + out[12 + outpos] = (in[6 + inpos] >>> 24) + | ((in[7 + inpos] & 1023) << (18 - 10)); + out[13 + outpos] = ((in[7 + inpos] >>> 10) & 262143); + out[14 + outpos] = (in[7 + inpos] >>> 28) + | ((in[8 + inpos] & 16383) << (18 - 14)); + out[15 + outpos] = (in[8 + inpos] >>> 14); + out[16 + outpos] = ((in[9 + inpos] >>> 0) & 262143); + out[17 + outpos] = (in[9 + inpos] >>> 18) + | ((in[10 + inpos] & 15) << (18 - 4)); + out[18 + outpos] = ((in[10 + inpos] >>> 4) & 262143); + out[19 + outpos] = (in[10 + inpos] >>> 22) + | ((in[11 + inpos] & 255) << (18 - 8)); + out[20 + outpos] = ((in[11 + inpos] >>> 8) & 262143); + out[21 + outpos] = (in[11 + inpos] >>> 26) + | ((in[12 + inpos] & 4095) << (18 - 12)); + out[22 + outpos] = ((in[12 + inpos] >>> 12) & 262143); + out[23 + outpos] = (in[12 + inpos] >>> 30) + | ((in[13 + inpos] & 65535) << (18 - 16)); + out[24 + outpos] = (in[13 + inpos] >>> 16) + | ((in[14 + inpos] & 3) << (18 - 2)); + out[25 + outpos] = ((in[14 + inpos] >>> 2) & 262143); + out[26 + outpos] = (in[14 + inpos] >>> 20) + | ((in[15 + inpos] & 63) << (18 - 6)); + out[27 + outpos] = ((in[15 + inpos] >>> 6) & 262143); + out[28 + outpos] = (in[15 + inpos] >>> 24) + | ((in[16 + inpos] & 1023) << (18 - 10)); + out[29 + outpos] = ((in[16 + inpos] >>> 10) & 262143); + out[30 + outpos] = (in[16 + inpos] >>> 28) + | ((in[17 + inpos] & 16383) << (18 - 14)); + out[31 + outpos] = (in[17 + inpos] >>> 14); + } + protected static void fastunpack19(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = ((in[0 + inpos] >>> 0) & 524287); + out[1 + outpos] = (in[0 + inpos] >>> 19) + | ((in[1 + inpos] & 63) << (19 - 6)); + out[2 + outpos] = ((in[1 + inpos] >>> 6) & 524287); + out[3 + outpos] = (in[1 + inpos] >>> 25) + | ((in[2 + inpos] & 4095) << (19 - 12)); + out[4 + outpos] = ((in[2 + inpos] >>> 12) & 524287); + out[5 + outpos] = (in[2 + inpos] >>> 31) + | ((in[3 + inpos] & 262143) << (19 - 18)); + out[6 + outpos] = (in[3 + inpos] >>> 18) + | ((in[4 + inpos] & 31) << (19 - 5)); + out[7 + outpos] = ((in[4 + inpos] >>> 5) & 524287); + out[8 + outpos] = (in[4 + inpos] >>> 24) + | ((in[5 + inpos] & 2047) << (19 - 11)); + out[9 + outpos] = ((in[5 + inpos] >>> 11) & 524287); + out[10 + outpos] = (in[5 + inpos] >>> 30) + | ((in[6 + inpos] & 131071) << (19 - 17)); + out[11 + outpos] = (in[6 + inpos] >>> 17) + | ((in[7 + inpos] & 15) << (19 - 4)); + out[12 + outpos] = ((in[7 + inpos] >>> 4) & 524287); + out[13 + outpos] = (in[7 + inpos] >>> 23) + | ((in[8 + inpos] & 1023) << (19 - 10)); + out[14 + outpos] = ((in[8 + inpos] >>> 10) & 524287); + out[15 + outpos] = (in[8 + inpos] >>> 29) + | ((in[9 + inpos] & 65535) << (19 - 16)); + out[16 + outpos] = (in[9 + inpos] >>> 16) + | ((in[10 + inpos] & 7) << (19 - 3)); + out[17 + outpos] = ((in[10 + inpos] >>> 3) & 524287); + out[18 + outpos] = (in[10 + inpos] >>> 22) + | ((in[11 + inpos] & 511) << (19 - 9)); + out[19 + outpos] = ((in[11 + inpos] >>> 9) & 524287); + out[20 + outpos] = (in[11 + inpos] >>> 28) + | ((in[12 + inpos] & 32767) << (19 - 15)); + out[21 + outpos] = (in[12 + inpos] >>> 15) + | ((in[13 + inpos] & 3) << (19 - 2)); + out[22 + outpos] = ((in[13 + inpos] >>> 2) & 524287); + out[23 + outpos] = (in[13 + inpos] >>> 21) + | ((in[14 + inpos] & 255) << (19 - 8)); + out[24 + outpos] = ((in[14 + inpos] >>> 8) & 524287); + out[25 + outpos] = (in[14 + inpos] >>> 27) + | ((in[15 + inpos] & 16383) << (19 - 14)); + out[26 + outpos] = (in[15 + inpos] >>> 14) + | ((in[16 + inpos] & 1) << (19 - 1)); + out[27 + outpos] = ((in[16 + inpos] >>> 1) & 524287); + out[28 + outpos] = (in[16 + inpos] >>> 20) + | ((in[17 + inpos] & 127) << (19 - 7)); + out[29 + outpos] = ((in[17 + inpos] >>> 7) & 524287); + out[30 + outpos] = (in[17 + inpos] >>> 26) + | ((in[18 + inpos] & 8191) << (19 - 13)); + out[31 + outpos] = (in[18 + inpos] >>> 13); + } - protected static void fastunpack30(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = ((in[0 + inpos] >>> 0) & 1073741823) - ; - out[1 + outpos] = (in[0 + inpos] >>> 30) - | ((in[1 + inpos] & 268435455) << (30 - 28)) - ; - out[2 + outpos] = (in[1 + inpos] >>> 28) - | ((in[2 + inpos] & 67108863) << (30 - 26)) - ; - out[3 + outpos] = (in[2 + inpos] >>> 26) - | ((in[3 + inpos] & 16777215) << (30 - 24)) - ; - out[4 + outpos] = (in[3 + inpos] >>> 24) - | ((in[4 + inpos] & 4194303) << (30 - 22)) - ; - out[5 + outpos] = (in[4 + inpos] >>> 22) - | ((in[5 + inpos] & 1048575) << (30 - 20)) - ; - out[6 + outpos] = (in[5 + inpos] >>> 20) - | ((in[6 + inpos] & 262143) << (30 - 18)) - ; - out[7 + outpos] = (in[6 + inpos] >>> 18) - | ((in[7 + inpos] & 65535) << (30 - 16)) - ; - out[8 + outpos] = (in[7 + inpos] >>> 16) - | ((in[8 + inpos] & 16383) << (30 - 14)) - ; - out[9 + outpos] = (in[8 + inpos] >>> 14) - | ((in[9 + inpos] & 4095) << (30 - 12)) - ; - out[10 + outpos] = (in[9 + inpos] >>> 12) - | ((in[10 + inpos] & 1023) << (30 - 10)) - ; - out[11 + outpos] = (in[10 + inpos] >>> 10) - | ((in[11 + inpos] & 255) << (30 - 8)) - ; - out[12 + outpos] = (in[11 + inpos] >>> 8) - | ((in[12 + inpos] & 63) << (30 - 6)) - ; - out[13 + outpos] = (in[12 + inpos] >>> 6) - | ((in[13 + inpos] & 15) << (30 - 4)) - ; - out[14 + outpos] = (in[13 + inpos] >>> 4) - | ((in[14 + inpos] & 3) << (30 - 2)) - ; - out[15 + outpos] = (in[14 + inpos] >>> 2) - ; - out[16 + outpos] = ((in[15 + inpos] >>> 0) & 1073741823) - ; - out[17 + outpos] = (in[15 + inpos] >>> 30) - | ((in[16 + inpos] & 268435455) << (30 - 28)) - ; - out[18 + outpos] = (in[16 + inpos] >>> 28) - | ((in[17 + inpos] & 67108863) << (30 - 26)) - ; - out[19 + outpos] = (in[17 + inpos] >>> 26) - | ((in[18 + inpos] & 16777215) << (30 - 24)) - ; - out[20 + outpos] = (in[18 + inpos] >>> 24) - | ((in[19 + inpos] & 4194303) << (30 - 22)) - ; - out[21 + outpos] = (in[19 + inpos] >>> 22) - | ((in[20 + inpos] & 1048575) << (30 - 20)) - ; - out[22 + outpos] = (in[20 + inpos] >>> 20) - | ((in[21 + inpos] & 262143) << (30 - 18)) - ; - out[23 + outpos] = (in[21 + inpos] >>> 18) - | ((in[22 + inpos] & 65535) << (30 - 16)) - ; - out[24 + outpos] = (in[22 + inpos] >>> 16) - | ((in[23 + inpos] & 16383) << (30 - 14)) - ; - out[25 + outpos] = (in[23 + inpos] >>> 14) - | ((in[24 + inpos] & 4095) << (30 - 12)) - ; - out[26 + outpos] = (in[24 + inpos] >>> 12) - | ((in[25 + inpos] & 1023) << (30 - 10)) - ; - out[27 + outpos] = (in[25 + inpos] >>> 10) - | ((in[26 + inpos] & 255) << (30 - 8)) - ; - out[28 + outpos] = (in[26 + inpos] >>> 8) - | ((in[27 + inpos] & 63) << (30 - 6)) - ; - out[29 + outpos] = (in[27 + inpos] >>> 6) - | ((in[28 + inpos] & 15) << (30 - 4)) - ; - out[30 + outpos] = (in[28 + inpos] >>> 4) - | ((in[29 + inpos] & 3) << (30 - 2)) - ; - out[31 + outpos] = (in[29 + inpos] >>> 2) - ; - } + protected static void fastunpack2(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = ((in[0 + inpos] >>> 0) & 3); + out[1 + outpos] = ((in[0 + inpos] >>> 2) & 3); + out[2 + outpos] = ((in[0 + inpos] >>> 4) & 3); + out[3 + outpos] = ((in[0 + inpos] >>> 6) & 3); + out[4 + outpos] = ((in[0 + inpos] >>> 8) & 3); + out[5 + outpos] = ((in[0 + inpos] >>> 10) & 3); + out[6 + outpos] = ((in[0 + inpos] >>> 12) & 3); + out[7 + outpos] = ((in[0 + inpos] >>> 14) & 3); + out[8 + outpos] = ((in[0 + inpos] >>> 16) & 3); + out[9 + outpos] = ((in[0 + inpos] >>> 18) & 3); + out[10 + outpos] = ((in[0 + inpos] >>> 20) & 3); + out[11 + outpos] = ((in[0 + inpos] >>> 22) & 3); + out[12 + outpos] = ((in[0 + inpos] >>> 24) & 3); + out[13 + outpos] = ((in[0 + inpos] >>> 26) & 3); + out[14 + outpos] = ((in[0 + inpos] >>> 28) & 3); + out[15 + outpos] = (in[0 + inpos] >>> 30); + out[16 + outpos] = ((in[1 + inpos] >>> 0) & 3); + out[17 + outpos] = ((in[1 + inpos] >>> 2) & 3); + out[18 + outpos] = ((in[1 + inpos] >>> 4) & 3); + out[19 + outpos] = ((in[1 + inpos] >>> 6) & 3); + out[20 + outpos] = ((in[1 + inpos] >>> 8) & 3); + out[21 + outpos] = ((in[1 + inpos] >>> 10) & 3); + out[22 + outpos] = ((in[1 + inpos] >>> 12) & 3); + out[23 + outpos] = ((in[1 + inpos] >>> 14) & 3); + out[24 + outpos] = ((in[1 + inpos] >>> 16) & 3); + out[25 + outpos] = ((in[1 + inpos] >>> 18) & 3); + out[26 + outpos] = ((in[1 + inpos] >>> 20) & 3); + out[27 + outpos] = ((in[1 + inpos] >>> 22) & 3); + out[28 + outpos] = ((in[1 + inpos] >>> 24) & 3); + out[29 + outpos] = ((in[1 + inpos] >>> 26) & 3); + out[30 + outpos] = ((in[1 + inpos] >>> 28) & 3); + out[31 + outpos] = (in[1 + inpos] >>> 30); + } + protected static void fastunpack20(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = ((in[0 + inpos] >>> 0) & 1048575); + out[1 + outpos] = (in[0 + inpos] >>> 20) + | ((in[1 + inpos] & 255) << (20 - 8)); + out[2 + outpos] = ((in[1 + inpos] >>> 8) & 1048575); + out[3 + outpos] = (in[1 + inpos] >>> 28) + | ((in[2 + inpos] & 65535) << (20 - 16)); + out[4 + outpos] = (in[2 + inpos] >>> 16) + | ((in[3 + inpos] & 15) << (20 - 4)); + out[5 + outpos] = ((in[3 + inpos] >>> 4) & 1048575); + out[6 + outpos] = (in[3 + inpos] >>> 24) + | ((in[4 + inpos] & 4095) << (20 - 12)); + out[7 + outpos] = (in[4 + inpos] >>> 12); + out[8 + outpos] = ((in[5 + inpos] >>> 0) & 1048575); + out[9 + outpos] = (in[5 + inpos] >>> 20) + | ((in[6 + inpos] & 255) << (20 - 8)); + out[10 + outpos] = ((in[6 + inpos] >>> 8) & 1048575); + out[11 + outpos] = (in[6 + inpos] >>> 28) + | ((in[7 + inpos] & 65535) << (20 - 16)); + out[12 + outpos] = (in[7 + inpos] >>> 16) + | ((in[8 + inpos] & 15) << (20 - 4)); + out[13 + outpos] = ((in[8 + inpos] >>> 4) & 1048575); + out[14 + outpos] = (in[8 + inpos] >>> 24) + | ((in[9 + inpos] & 4095) << (20 - 12)); + out[15 + outpos] = (in[9 + inpos] >>> 12); + out[16 + outpos] = ((in[10 + inpos] >>> 0) & 1048575); + out[17 + outpos] = (in[10 + inpos] >>> 20) + | ((in[11 + inpos] & 255) << (20 - 8)); + out[18 + outpos] = ((in[11 + inpos] >>> 8) & 1048575); + out[19 + outpos] = (in[11 + inpos] >>> 28) + | ((in[12 + inpos] & 65535) << (20 - 16)); + out[20 + outpos] = (in[12 + inpos] >>> 16) + | ((in[13 + inpos] & 15) << (20 - 4)); + out[21 + outpos] = ((in[13 + inpos] >>> 4) & 1048575); + out[22 + outpos] = (in[13 + inpos] >>> 24) + | ((in[14 + inpos] & 4095) << (20 - 12)); + out[23 + outpos] = (in[14 + inpos] >>> 12); + out[24 + outpos] = ((in[15 + inpos] >>> 0) & 1048575); + out[25 + outpos] = (in[15 + inpos] >>> 20) + | ((in[16 + inpos] & 255) << (20 - 8)); + out[26 + outpos] = ((in[16 + inpos] >>> 8) & 1048575); + out[27 + outpos] = (in[16 + inpos] >>> 28) + | ((in[17 + inpos] & 65535) << (20 - 16)); + out[28 + outpos] = (in[17 + inpos] >>> 16) + | ((in[18 + inpos] & 15) << (20 - 4)); + out[29 + outpos] = ((in[18 + inpos] >>> 4) & 1048575); + out[30 + outpos] = (in[18 + inpos] >>> 24) + | ((in[19 + inpos] & 4095) << (20 - 12)); + out[31 + outpos] = (in[19 + inpos] >>> 12); + } - protected static void fastunpack31(final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = ((in[0 + inpos] >>> 0) & 2147483647) - ; - out[1 + outpos] = (in[0 + inpos] >>> 31) - | ((in[1 + inpos] & 1073741823) << (31 - 30)) - ; - out[2 + outpos] = (in[1 + inpos] >>> 30) - | ((in[2 + inpos] & 536870911) << (31 - 29)) - ; - out[3 + outpos] = (in[2 + inpos] >>> 29) - | ((in[3 + inpos] & 268435455) << (31 - 28)) - ; - out[4 + outpos] = (in[3 + inpos] >>> 28) - | ((in[4 + inpos] & 134217727) << (31 - 27)) - ; - out[5 + outpos] = (in[4 + inpos] >>> 27) - | ((in[5 + inpos] & 67108863) << (31 - 26)) - ; - out[6 + outpos] = (in[5 + inpos] >>> 26) - | ((in[6 + inpos] & 33554431) << (31 - 25)) - ; - out[7 + outpos] = (in[6 + inpos] >>> 25) - | ((in[7 + inpos] & 16777215) << (31 - 24)) - ; - out[8 + outpos] = (in[7 + inpos] >>> 24) - | ((in[8 + inpos] & 8388607) << (31 - 23)) - ; - out[9 + outpos] = (in[8 + inpos] >>> 23) - | ((in[9 + inpos] & 4194303) << (31 - 22)) - ; - out[10 + outpos] = (in[9 + inpos] >>> 22) - | ((in[10 + inpos] & 2097151) << (31 - 21)) - ; - out[11 + outpos] = (in[10 + inpos] >>> 21) - | ((in[11 + inpos] & 1048575) << (31 - 20)) - ; - out[12 + outpos] = (in[11 + inpos] >>> 20) - | ((in[12 + inpos] & 524287) << (31 - 19)) - ; - out[13 + outpos] = (in[12 + inpos] >>> 19) - | ((in[13 + inpos] & 262143) << (31 - 18)) - ; - out[14 + outpos] = (in[13 + inpos] >>> 18) - | ((in[14 + inpos] & 131071) << (31 - 17)) - ; - out[15 + outpos] = (in[14 + inpos] >>> 17) - | ((in[15 + inpos] & 65535) << (31 - 16)) - ; - out[16 + outpos] = (in[15 + inpos] >>> 16) - | ((in[16 + inpos] & 32767) << (31 - 15)) - ; - out[17 + outpos] = (in[16 + inpos] >>> 15) - | ((in[17 + inpos] & 16383) << (31 - 14)) - ; - out[18 + outpos] = (in[17 + inpos] >>> 14) - | ((in[18 + inpos] & 8191) << (31 - 13)) - ; - out[19 + outpos] = (in[18 + inpos] >>> 13) - | ((in[19 + inpos] & 4095) << (31 - 12)) - ; - out[20 + outpos] = (in[19 + inpos] >>> 12) - | ((in[20 + inpos] & 2047) << (31 - 11)) - ; - out[21 + outpos] = (in[20 + inpos] >>> 11) - | ((in[21 + inpos] & 1023) << (31 - 10)) - ; - out[22 + outpos] = (in[21 + inpos] >>> 10) - | ((in[22 + inpos] & 511) << (31 - 9)) - ; - out[23 + outpos] = (in[22 + inpos] >>> 9) - | ((in[23 + inpos] & 255) << (31 - 8)) - ; - out[24 + outpos] = (in[23 + inpos] >>> 8) - | ((in[24 + inpos] & 127) << (31 - 7)) - ; - out[25 + outpos] = (in[24 + inpos] >>> 7) - | ((in[25 + inpos] & 63) << (31 - 6)) - ; - out[26 + outpos] = (in[25 + inpos] >>> 6) - | ((in[26 + inpos] & 31) << (31 - 5)) - ; - out[27 + outpos] = (in[26 + inpos] >>> 5) - | ((in[27 + inpos] & 15) << (31 - 4)) - ; - out[28 + outpos] = (in[27 + inpos] >>> 4) - | ((in[28 + inpos] & 7) << (31 - 3)) - ; - out[29 + outpos] = (in[28 + inpos] >>> 3) - | ((in[29 + inpos] & 3) << (31 - 2)) - ; - out[30 + outpos] = (in[29 + inpos] >>> 2) - | ((in[30 + inpos] & 1) << (31 - 1)) - ; - out[31 + outpos] = (in[30 + inpos] >>> 1) - ; - } + protected static void fastunpack21(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = ((in[0 + inpos] >>> 0) & 2097151); + out[1 + outpos] = (in[0 + inpos] >>> 21) + | ((in[1 + inpos] & 1023) << (21 - 10)); + out[2 + outpos] = ((in[1 + inpos] >>> 10) & 2097151); + out[3 + outpos] = (in[1 + inpos] >>> 31) + | ((in[2 + inpos] & 1048575) << (21 - 20)); + out[4 + outpos] = (in[2 + inpos] >>> 20) + | ((in[3 + inpos] & 511) << (21 - 9)); + out[5 + outpos] = ((in[3 + inpos] >>> 9) & 2097151); + out[6 + outpos] = (in[3 + inpos] >>> 30) + | ((in[4 + inpos] & 524287) << (21 - 19)); + out[7 + outpos] = (in[4 + inpos] >>> 19) + | ((in[5 + inpos] & 255) << (21 - 8)); + out[8 + outpos] = ((in[5 + inpos] >>> 8) & 2097151); + out[9 + outpos] = (in[5 + inpos] >>> 29) + | ((in[6 + inpos] & 262143) << (21 - 18)); + out[10 + outpos] = (in[6 + inpos] >>> 18) + | ((in[7 + inpos] & 127) << (21 - 7)); + out[11 + outpos] = ((in[7 + inpos] >>> 7) & 2097151); + out[12 + outpos] = (in[7 + inpos] >>> 28) + | ((in[8 + inpos] & 131071) << (21 - 17)); + out[13 + outpos] = (in[8 + inpos] >>> 17) + | ((in[9 + inpos] & 63) << (21 - 6)); + out[14 + outpos] = ((in[9 + inpos] >>> 6) & 2097151); + out[15 + outpos] = (in[9 + inpos] >>> 27) + | ((in[10 + inpos] & 65535) << (21 - 16)); + out[16 + outpos] = (in[10 + inpos] >>> 16) + | ((in[11 + inpos] & 31) << (21 - 5)); + out[17 + outpos] = ((in[11 + inpos] >>> 5) & 2097151); + out[18 + outpos] = (in[11 + inpos] >>> 26) + | ((in[12 + inpos] & 32767) << (21 - 15)); + out[19 + outpos] = (in[12 + inpos] >>> 15) + | ((in[13 + inpos] & 15) << (21 - 4)); + out[20 + outpos] = ((in[13 + inpos] >>> 4) & 2097151); + out[21 + outpos] = (in[13 + inpos] >>> 25) + | ((in[14 + inpos] & 16383) << (21 - 14)); + out[22 + outpos] = (in[14 + inpos] >>> 14) + | ((in[15 + inpos] & 7) << (21 - 3)); + out[23 + outpos] = ((in[15 + inpos] >>> 3) & 2097151); + out[24 + outpos] = (in[15 + inpos] >>> 24) + | ((in[16 + inpos] & 8191) << (21 - 13)); + out[25 + outpos] = (in[16 + inpos] >>> 13) + | ((in[17 + inpos] & 3) << (21 - 2)); + out[26 + outpos] = ((in[17 + inpos] >>> 2) & 2097151); + out[27 + outpos] = (in[17 + inpos] >>> 23) + | ((in[18 + inpos] & 4095) << (21 - 12)); + out[28 + outpos] = (in[18 + inpos] >>> 12) + | ((in[19 + inpos] & 1) << (21 - 1)); + out[29 + outpos] = ((in[19 + inpos] >>> 1) & 2097151); + out[30 + outpos] = (in[19 + inpos] >>> 22) + | ((in[20 + inpos] & 2047) << (21 - 11)); + out[31 + outpos] = (in[20 + inpos] >>> 11); + } + protected static void fastunpack22(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = ((in[0 + inpos] >>> 0) & 4194303); + out[1 + outpos] = (in[0 + inpos] >>> 22) + | ((in[1 + inpos] & 4095) << (22 - 12)); + out[2 + outpos] = (in[1 + inpos] >>> 12) + | ((in[2 + inpos] & 3) << (22 - 2)); + out[3 + outpos] = ((in[2 + inpos] >>> 2) & 4194303); + out[4 + outpos] = (in[2 + inpos] >>> 24) + | ((in[3 + inpos] & 16383) << (22 - 14)); + out[5 + outpos] = (in[3 + inpos] >>> 14) + | ((in[4 + inpos] & 15) << (22 - 4)); + out[6 + outpos] = ((in[4 + inpos] >>> 4) & 4194303); + out[7 + outpos] = (in[4 + inpos] >>> 26) + | ((in[5 + inpos] & 65535) << (22 - 16)); + out[8 + outpos] = (in[5 + inpos] >>> 16) + | ((in[6 + inpos] & 63) << (22 - 6)); + out[9 + outpos] = ((in[6 + inpos] >>> 6) & 4194303); + out[10 + outpos] = (in[6 + inpos] >>> 28) + | ((in[7 + inpos] & 262143) << (22 - 18)); + out[11 + outpos] = (in[7 + inpos] >>> 18) + | ((in[8 + inpos] & 255) << (22 - 8)); + out[12 + outpos] = ((in[8 + inpos] >>> 8) & 4194303); + out[13 + outpos] = (in[8 + inpos] >>> 30) + | ((in[9 + inpos] & 1048575) << (22 - 20)); + out[14 + outpos] = (in[9 + inpos] >>> 20) + | ((in[10 + inpos] & 1023) << (22 - 10)); + out[15 + outpos] = (in[10 + inpos] >>> 10); + out[16 + outpos] = ((in[11 + inpos] >>> 0) & 4194303); + out[17 + outpos] = (in[11 + inpos] >>> 22) + | ((in[12 + inpos] & 4095) << (22 - 12)); + out[18 + outpos] = (in[12 + inpos] >>> 12) + | ((in[13 + inpos] & 3) << (22 - 2)); + out[19 + outpos] = ((in[13 + inpos] >>> 2) & 4194303); + out[20 + outpos] = (in[13 + inpos] >>> 24) + | ((in[14 + inpos] & 16383) << (22 - 14)); + out[21 + outpos] = (in[14 + inpos] >>> 14) + | ((in[15 + inpos] & 15) << (22 - 4)); + out[22 + outpos] = ((in[15 + inpos] >>> 4) & 4194303); + out[23 + outpos] = (in[15 + inpos] >>> 26) + | ((in[16 + inpos] & 65535) << (22 - 16)); + out[24 + outpos] = (in[16 + inpos] >>> 16) + | ((in[17 + inpos] & 63) << (22 - 6)); + out[25 + outpos] = ((in[17 + inpos] >>> 6) & 4194303); + out[26 + outpos] = (in[17 + inpos] >>> 28) + | ((in[18 + inpos] & 262143) << (22 - 18)); + out[27 + outpos] = (in[18 + inpos] >>> 18) + | ((in[19 + inpos] & 255) << (22 - 8)); + out[28 + outpos] = ((in[19 + inpos] >>> 8) & 4194303); + out[29 + outpos] = (in[19 + inpos] >>> 30) + | ((in[20 + inpos] & 1048575) << (22 - 20)); + out[30 + outpos] = (in[20 + inpos] >>> 20) + | ((in[21 + inpos] & 1023) << (22 - 10)); + out[31 + outpos] = (in[21 + inpos] >>> 10); + } - protected static void fastunpack32(final int[] in, int inpos, final int[] out, int outpos) { - System.arraycopy(in, inpos, out, outpos, 32); - } + protected static void fastunpack23(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = ((in[0 + inpos] >>> 0) & 8388607); + out[1 + outpos] = (in[0 + inpos] >>> 23) + | ((in[1 + inpos] & 16383) << (23 - 14)); + out[2 + outpos] = (in[1 + inpos] >>> 14) + | ((in[2 + inpos] & 31) << (23 - 5)); + out[3 + outpos] = ((in[2 + inpos] >>> 5) & 8388607); + out[4 + outpos] = (in[2 + inpos] >>> 28) + | ((in[3 + inpos] & 524287) << (23 - 19)); + out[5 + outpos] = (in[3 + inpos] >>> 19) + | ((in[4 + inpos] & 1023) << (23 - 10)); + out[6 + outpos] = (in[4 + inpos] >>> 10) + | ((in[5 + inpos] & 1) << (23 - 1)); + out[7 + outpos] = ((in[5 + inpos] >>> 1) & 8388607); + out[8 + outpos] = (in[5 + inpos] >>> 24) + | ((in[6 + inpos] & 32767) << (23 - 15)); + out[9 + outpos] = (in[6 + inpos] >>> 15) + | ((in[7 + inpos] & 63) << (23 - 6)); + out[10 + outpos] = ((in[7 + inpos] >>> 6) & 8388607); + out[11 + outpos] = (in[7 + inpos] >>> 29) + | ((in[8 + inpos] & 1048575) << (23 - 20)); + out[12 + outpos] = (in[8 + inpos] >>> 20) + | ((in[9 + inpos] & 2047) << (23 - 11)); + out[13 + outpos] = (in[9 + inpos] >>> 11) + | ((in[10 + inpos] & 3) << (23 - 2)); + out[14 + outpos] = ((in[10 + inpos] >>> 2) & 8388607); + out[15 + outpos] = (in[10 + inpos] >>> 25) + | ((in[11 + inpos] & 65535) << (23 - 16)); + out[16 + outpos] = (in[11 + inpos] >>> 16) + | ((in[12 + inpos] & 127) << (23 - 7)); + out[17 + outpos] = ((in[12 + inpos] >>> 7) & 8388607); + out[18 + outpos] = (in[12 + inpos] >>> 30) + | ((in[13 + inpos] & 2097151) << (23 - 21)); + out[19 + outpos] = (in[13 + inpos] >>> 21) + | ((in[14 + inpos] & 4095) << (23 - 12)); + out[20 + outpos] = (in[14 + inpos] >>> 12) + | ((in[15 + inpos] & 7) << (23 - 3)); + out[21 + outpos] = ((in[15 + inpos] >>> 3) & 8388607); + out[22 + outpos] = (in[15 + inpos] >>> 26) + | ((in[16 + inpos] & 131071) << (23 - 17)); + out[23 + outpos] = (in[16 + inpos] >>> 17) + | ((in[17 + inpos] & 255) << (23 - 8)); + out[24 + outpos] = ((in[17 + inpos] >>> 8) & 8388607); + out[25 + outpos] = (in[17 + inpos] >>> 31) + | ((in[18 + inpos] & 4194303) << (23 - 22)); + out[26 + outpos] = (in[18 + inpos] >>> 22) + | ((in[19 + inpos] & 8191) << (23 - 13)); + out[27 + outpos] = (in[19 + inpos] >>> 13) + | ((in[20 + inpos] & 15) << (23 - 4)); + out[28 + outpos] = ((in[20 + inpos] >>> 4) & 8388607); + out[29 + outpos] = (in[20 + inpos] >>> 27) + | ((in[21 + inpos] & 262143) << (23 - 18)); + out[30 + outpos] = (in[21 + inpos] >>> 18) + | ((in[22 + inpos] & 511) << (23 - 9)); + out[31 + outpos] = (in[22 + inpos] >>> 9); + } + protected static void fastunpack24(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = ((in[0 + inpos] >>> 0) & 16777215); + out[1 + outpos] = (in[0 + inpos] >>> 24) + | ((in[1 + inpos] & 65535) << (24 - 16)); + out[2 + outpos] = (in[1 + inpos] >>> 16) + | ((in[2 + inpos] & 255) << (24 - 8)); + out[3 + outpos] = (in[2 + inpos] >>> 8); + out[4 + outpos] = ((in[3 + inpos] >>> 0) & 16777215); + out[5 + outpos] = (in[3 + inpos] >>> 24) + | ((in[4 + inpos] & 65535) << (24 - 16)); + out[6 + outpos] = (in[4 + inpos] >>> 16) + | ((in[5 + inpos] & 255) << (24 - 8)); + out[7 + outpos] = (in[5 + inpos] >>> 8); + out[8 + outpos] = ((in[6 + inpos] >>> 0) & 16777215); + out[9 + outpos] = (in[6 + inpos] >>> 24) + | ((in[7 + inpos] & 65535) << (24 - 16)); + out[10 + outpos] = (in[7 + inpos] >>> 16) + | ((in[8 + inpos] & 255) << (24 - 8)); + out[11 + outpos] = (in[8 + inpos] >>> 8); + out[12 + outpos] = ((in[9 + inpos] >>> 0) & 16777215); + out[13 + outpos] = (in[9 + inpos] >>> 24) + | ((in[10 + inpos] & 65535) << (24 - 16)); + out[14 + outpos] = (in[10 + inpos] >>> 16) + | ((in[11 + inpos] & 255) << (24 - 8)); + out[15 + outpos] = (in[11 + inpos] >>> 8); + out[16 + outpos] = ((in[12 + inpos] >>> 0) & 16777215); + out[17 + outpos] = (in[12 + inpos] >>> 24) + | ((in[13 + inpos] & 65535) << (24 - 16)); + out[18 + outpos] = (in[13 + inpos] >>> 16) + | ((in[14 + inpos] & 255) << (24 - 8)); + out[19 + outpos] = (in[14 + inpos] >>> 8); + out[20 + outpos] = ((in[15 + inpos] >>> 0) & 16777215); + out[21 + outpos] = (in[15 + inpos] >>> 24) + | ((in[16 + inpos] & 65535) << (24 - 16)); + out[22 + outpos] = (in[16 + inpos] >>> 16) + | ((in[17 + inpos] & 255) << (24 - 8)); + out[23 + outpos] = (in[17 + inpos] >>> 8); + out[24 + outpos] = ((in[18 + inpos] >>> 0) & 16777215); + out[25 + outpos] = (in[18 + inpos] >>> 24) + | ((in[19 + inpos] & 65535) << (24 - 16)); + out[26 + outpos] = (in[19 + inpos] >>> 16) + | ((in[20 + inpos] & 255) << (24 - 8)); + out[27 + outpos] = (in[20 + inpos] >>> 8); + out[28 + outpos] = ((in[21 + inpos] >>> 0) & 16777215); + out[29 + outpos] = (in[21 + inpos] >>> 24) + | ((in[22 + inpos] & 65535) << (24 - 16)); + out[30 + outpos] = (in[22 + inpos] >>> 16) + | ((in[23 + inpos] & 255) << (24 - 8)); + out[31 + outpos] = (in[23 + inpos] >>> 8); + } - protected static void fastpack32(final int[] in, int inpos, final int[] out, int outpos) { - System.arraycopy(in, inpos, out, outpos, 32); - } + protected static void fastunpack25(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = ((in[0 + inpos] >>> 0) & 33554431); + out[1 + outpos] = (in[0 + inpos] >>> 25) + | ((in[1 + inpos] & 262143) << (25 - 18)); + out[2 + outpos] = (in[1 + inpos] >>> 18) + | ((in[2 + inpos] & 2047) << (25 - 11)); + out[3 + outpos] = (in[2 + inpos] >>> 11) + | ((in[3 + inpos] & 15) << (25 - 4)); + out[4 + outpos] = ((in[3 + inpos] >>> 4) & 33554431); + out[5 + outpos] = (in[3 + inpos] >>> 29) + | ((in[4 + inpos] & 4194303) << (25 - 22)); + out[6 + outpos] = (in[4 + inpos] >>> 22) + | ((in[5 + inpos] & 32767) << (25 - 15)); + out[7 + outpos] = (in[5 + inpos] >>> 15) + | ((in[6 + inpos] & 255) << (25 - 8)); + out[8 + outpos] = (in[6 + inpos] >>> 8) + | ((in[7 + inpos] & 1) << (25 - 1)); + out[9 + outpos] = ((in[7 + inpos] >>> 1) & 33554431); + out[10 + outpos] = (in[7 + inpos] >>> 26) + | ((in[8 + inpos] & 524287) << (25 - 19)); + out[11 + outpos] = (in[8 + inpos] >>> 19) + | ((in[9 + inpos] & 4095) << (25 - 12)); + out[12 + outpos] = (in[9 + inpos] >>> 12) + | ((in[10 + inpos] & 31) << (25 - 5)); + out[13 + outpos] = ((in[10 + inpos] >>> 5) & 33554431); + out[14 + outpos] = (in[10 + inpos] >>> 30) + | ((in[11 + inpos] & 8388607) << (25 - 23)); + out[15 + outpos] = (in[11 + inpos] >>> 23) + | ((in[12 + inpos] & 65535) << (25 - 16)); + out[16 + outpos] = (in[12 + inpos] >>> 16) + | ((in[13 + inpos] & 511) << (25 - 9)); + out[17 + outpos] = (in[13 + inpos] >>> 9) + | ((in[14 + inpos] & 3) << (25 - 2)); + out[18 + outpos] = ((in[14 + inpos] >>> 2) & 33554431); + out[19 + outpos] = (in[14 + inpos] >>> 27) + | ((in[15 + inpos] & 1048575) << (25 - 20)); + out[20 + outpos] = (in[15 + inpos] >>> 20) + | ((in[16 + inpos] & 8191) << (25 - 13)); + out[21 + outpos] = (in[16 + inpos] >>> 13) + | ((in[17 + inpos] & 63) << (25 - 6)); + out[22 + outpos] = ((in[17 + inpos] >>> 6) & 33554431); + out[23 + outpos] = (in[17 + inpos] >>> 31) + | ((in[18 + inpos] & 16777215) << (25 - 24)); + out[24 + outpos] = (in[18 + inpos] >>> 24) + | ((in[19 + inpos] & 131071) << (25 - 17)); + out[25 + outpos] = (in[19 + inpos] >>> 17) + | ((in[20 + inpos] & 1023) << (25 - 10)); + out[26 + outpos] = (in[20 + inpos] >>> 10) + | ((in[21 + inpos] & 7) << (25 - 3)); + out[27 + outpos] = ((in[21 + inpos] >>> 3) & 33554431); + out[28 + outpos] = (in[21 + inpos] >>> 28) + | ((in[22 + inpos] & 2097151) << (25 - 21)); + out[29 + outpos] = (in[22 + inpos] >>> 21) + | ((in[23 + inpos] & 16383) << (25 - 14)); + out[30 + outpos] = (in[23 + inpos] >>> 14) + | ((in[24 + inpos] & 127) << (25 - 7)); + out[31 + outpos] = (in[24 + inpos] >>> 7); + } + protected static void fastunpack26(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = ((in[0 + inpos] >>> 0) & 67108863); + out[1 + outpos] = (in[0 + inpos] >>> 26) + | ((in[1 + inpos] & 1048575) << (26 - 20)); + out[2 + outpos] = (in[1 + inpos] >>> 20) + | ((in[2 + inpos] & 16383) << (26 - 14)); + out[3 + outpos] = (in[2 + inpos] >>> 14) + | ((in[3 + inpos] & 255) << (26 - 8)); + out[4 + outpos] = (in[3 + inpos] >>> 8) + | ((in[4 + inpos] & 3) << (26 - 2)); + out[5 + outpos] = ((in[4 + inpos] >>> 2) & 67108863); + out[6 + outpos] = (in[4 + inpos] >>> 28) + | ((in[5 + inpos] & 4194303) << (26 - 22)); + out[7 + outpos] = (in[5 + inpos] >>> 22) + | ((in[6 + inpos] & 65535) << (26 - 16)); + out[8 + outpos] = (in[6 + inpos] >>> 16) + | ((in[7 + inpos] & 1023) << (26 - 10)); + out[9 + outpos] = (in[7 + inpos] >>> 10) + | ((in[8 + inpos] & 15) << (26 - 4)); + out[10 + outpos] = ((in[8 + inpos] >>> 4) & 67108863); + out[11 + outpos] = (in[8 + inpos] >>> 30) + | ((in[9 + inpos] & 16777215) << (26 - 24)); + out[12 + outpos] = (in[9 + inpos] >>> 24) + | ((in[10 + inpos] & 262143) << (26 - 18)); + out[13 + outpos] = (in[10 + inpos] >>> 18) + | ((in[11 + inpos] & 4095) << (26 - 12)); + out[14 + outpos] = (in[11 + inpos] >>> 12) + | ((in[12 + inpos] & 63) << (26 - 6)); + out[15 + outpos] = (in[12 + inpos] >>> 6); + out[16 + outpos] = ((in[13 + inpos] >>> 0) & 67108863); + out[17 + outpos] = (in[13 + inpos] >>> 26) + | ((in[14 + inpos] & 1048575) << (26 - 20)); + out[18 + outpos] = (in[14 + inpos] >>> 20) + | ((in[15 + inpos] & 16383) << (26 - 14)); + out[19 + outpos] = (in[15 + inpos] >>> 14) + | ((in[16 + inpos] & 255) << (26 - 8)); + out[20 + outpos] = (in[16 + inpos] >>> 8) + | ((in[17 + inpos] & 3) << (26 - 2)); + out[21 + outpos] = ((in[17 + inpos] >>> 2) & 67108863); + out[22 + outpos] = (in[17 + inpos] >>> 28) + | ((in[18 + inpos] & 4194303) << (26 - 22)); + out[23 + outpos] = (in[18 + inpos] >>> 22) + | ((in[19 + inpos] & 65535) << (26 - 16)); + out[24 + outpos] = (in[19 + inpos] >>> 16) + | ((in[20 + inpos] & 1023) << (26 - 10)); + out[25 + outpos] = (in[20 + inpos] >>> 10) + | ((in[21 + inpos] & 15) << (26 - 4)); + out[26 + outpos] = ((in[21 + inpos] >>> 4) & 67108863); + out[27 + outpos] = (in[21 + inpos] >>> 30) + | ((in[22 + inpos] & 16777215) << (26 - 24)); + out[28 + outpos] = (in[22 + inpos] >>> 24) + | ((in[23 + inpos] & 262143) << (26 - 18)); + out[29 + outpos] = (in[23 + inpos] >>> 18) + | ((in[24 + inpos] & 4095) << (26 - 12)); + out[30 + outpos] = (in[24 + inpos] >>> 12) + | ((in[25 + inpos] & 63) << (26 - 6)); + out[31 + outpos] = (in[25 + inpos] >>> 6); + } - protected static void fastpackwithoutmask32(final int[] in, int inpos, final int[] out, int outpos) { - System.arraycopy(in, inpos, out, outpos, 32); - } + protected static void fastunpack27(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = ((in[0 + inpos] >>> 0) & 134217727); + out[1 + outpos] = (in[0 + inpos] >>> 27) + | ((in[1 + inpos] & 4194303) << (27 - 22)); + out[2 + outpos] = (in[1 + inpos] >>> 22) + | ((in[2 + inpos] & 131071) << (27 - 17)); + out[3 + outpos] = (in[2 + inpos] >>> 17) + | ((in[3 + inpos] & 4095) << (27 - 12)); + out[4 + outpos] = (in[3 + inpos] >>> 12) + | ((in[4 + inpos] & 127) << (27 - 7)); + out[5 + outpos] = (in[4 + inpos] >>> 7) + | ((in[5 + inpos] & 3) << (27 - 2)); + out[6 + outpos] = ((in[5 + inpos] >>> 2) & 134217727); + out[7 + outpos] = (in[5 + inpos] >>> 29) + | ((in[6 + inpos] & 16777215) << (27 - 24)); + out[8 + outpos] = (in[6 + inpos] >>> 24) + | ((in[7 + inpos] & 524287) << (27 - 19)); + out[9 + outpos] = (in[7 + inpos] >>> 19) + | ((in[8 + inpos] & 16383) << (27 - 14)); + out[10 + outpos] = (in[8 + inpos] >>> 14) + | ((in[9 + inpos] & 511) << (27 - 9)); + out[11 + outpos] = (in[9 + inpos] >>> 9) + | ((in[10 + inpos] & 15) << (27 - 4)); + out[12 + outpos] = ((in[10 + inpos] >>> 4) & 134217727); + out[13 + outpos] = (in[10 + inpos] >>> 31) + | ((in[11 + inpos] & 67108863) << (27 - 26)); + out[14 + outpos] = (in[11 + inpos] >>> 26) + | ((in[12 + inpos] & 2097151) << (27 - 21)); + out[15 + outpos] = (in[12 + inpos] >>> 21) + | ((in[13 + inpos] & 65535) << (27 - 16)); + out[16 + outpos] = (in[13 + inpos] >>> 16) + | ((in[14 + inpos] & 2047) << (27 - 11)); + out[17 + outpos] = (in[14 + inpos] >>> 11) + | ((in[15 + inpos] & 63) << (27 - 6)); + out[18 + outpos] = (in[15 + inpos] >>> 6) + | ((in[16 + inpos] & 1) << (27 - 1)); + out[19 + outpos] = ((in[16 + inpos] >>> 1) & 134217727); + out[20 + outpos] = (in[16 + inpos] >>> 28) + | ((in[17 + inpos] & 8388607) << (27 - 23)); + out[21 + outpos] = (in[17 + inpos] >>> 23) + | ((in[18 + inpos] & 262143) << (27 - 18)); + out[22 + outpos] = (in[18 + inpos] >>> 18) + | ((in[19 + inpos] & 8191) << (27 - 13)); + out[23 + outpos] = (in[19 + inpos] >>> 13) + | ((in[20 + inpos] & 255) << (27 - 8)); + out[24 + outpos] = (in[20 + inpos] >>> 8) + | ((in[21 + inpos] & 7) << (27 - 3)); + out[25 + outpos] = ((in[21 + inpos] >>> 3) & 134217727); + out[26 + outpos] = (in[21 + inpos] >>> 30) + | ((in[22 + inpos] & 33554431) << (27 - 25)); + out[27 + outpos] = (in[22 + inpos] >>> 25) + | ((in[23 + inpos] & 1048575) << (27 - 20)); + out[28 + outpos] = (in[23 + inpos] >>> 20) + | ((in[24 + inpos] & 32767) << (27 - 15)); + out[29 + outpos] = (in[24 + inpos] >>> 15) + | ((in[25 + inpos] & 1023) << (27 - 10)); + out[30 + outpos] = (in[25 + inpos] >>> 10) + | ((in[26 + inpos] & 31) << (27 - 5)); + out[31 + outpos] = (in[26 + inpos] >>> 5); + } + protected static void fastunpack28(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = ((in[0 + inpos] >>> 0) & 268435455); + out[1 + outpos] = (in[0 + inpos] >>> 28) + | ((in[1 + inpos] & 16777215) << (28 - 24)); + out[2 + outpos] = (in[1 + inpos] >>> 24) + | ((in[2 + inpos] & 1048575) << (28 - 20)); + out[3 + outpos] = (in[2 + inpos] >>> 20) + | ((in[3 + inpos] & 65535) << (28 - 16)); + out[4 + outpos] = (in[3 + inpos] >>> 16) + | ((in[4 + inpos] & 4095) << (28 - 12)); + out[5 + outpos] = (in[4 + inpos] >>> 12) + | ((in[5 + inpos] & 255) << (28 - 8)); + out[6 + outpos] = (in[5 + inpos] >>> 8) + | ((in[6 + inpos] & 15) << (28 - 4)); + out[7 + outpos] = (in[6 + inpos] >>> 4); + out[8 + outpos] = ((in[7 + inpos] >>> 0) & 268435455); + out[9 + outpos] = (in[7 + inpos] >>> 28) + | ((in[8 + inpos] & 16777215) << (28 - 24)); + out[10 + outpos] = (in[8 + inpos] >>> 24) + | ((in[9 + inpos] & 1048575) << (28 - 20)); + out[11 + outpos] = (in[9 + inpos] >>> 20) + | ((in[10 + inpos] & 65535) << (28 - 16)); + out[12 + outpos] = (in[10 + inpos] >>> 16) + | ((in[11 + inpos] & 4095) << (28 - 12)); + out[13 + outpos] = (in[11 + inpos] >>> 12) + | ((in[12 + inpos] & 255) << (28 - 8)); + out[14 + outpos] = (in[12 + inpos] >>> 8) + | ((in[13 + inpos] & 15) << (28 - 4)); + out[15 + outpos] = (in[13 + inpos] >>> 4); + out[16 + outpos] = ((in[14 + inpos] >>> 0) & 268435455); + out[17 + outpos] = (in[14 + inpos] >>> 28) + | ((in[15 + inpos] & 16777215) << (28 - 24)); + out[18 + outpos] = (in[15 + inpos] >>> 24) + | ((in[16 + inpos] & 1048575) << (28 - 20)); + out[19 + outpos] = (in[16 + inpos] >>> 20) + | ((in[17 + inpos] & 65535) << (28 - 16)); + out[20 + outpos] = (in[17 + inpos] >>> 16) + | ((in[18 + inpos] & 4095) << (28 - 12)); + out[21 + outpos] = (in[18 + inpos] >>> 12) + | ((in[19 + inpos] & 255) << (28 - 8)); + out[22 + outpos] = (in[19 + inpos] >>> 8) + | ((in[20 + inpos] & 15) << (28 - 4)); + out[23 + outpos] = (in[20 + inpos] >>> 4); + out[24 + outpos] = ((in[21 + inpos] >>> 0) & 268435455); + out[25 + outpos] = (in[21 + inpos] >>> 28) + | ((in[22 + inpos] & 16777215) << (28 - 24)); + out[26 + outpos] = (in[22 + inpos] >>> 24) + | ((in[23 + inpos] & 1048575) << (28 - 20)); + out[27 + outpos] = (in[23 + inpos] >>> 20) + | ((in[24 + inpos] & 65535) << (28 - 16)); + out[28 + outpos] = (in[24 + inpos] >>> 16) + | ((in[25 + inpos] & 4095) << (28 - 12)); + out[29 + outpos] = (in[25 + inpos] >>> 12) + | ((in[26 + inpos] & 255) << (28 - 8)); + out[30 + outpos] = (in[26 + inpos] >>> 8) + | ((in[27 + inpos] & 15) << (28 - 4)); + out[31 + outpos] = (in[27 + inpos] >>> 4); + } - protected static void fastunpack0(final int[] in, int inpos, final int[] out, int outpos) { - Arrays.fill(out, outpos, outpos + 32, 0); - } + protected static void fastunpack29(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = ((in[0 + inpos] >>> 0) & 536870911); + out[1 + outpos] = (in[0 + inpos] >>> 29) + | ((in[1 + inpos] & 67108863) << (29 - 26)); + out[2 + outpos] = (in[1 + inpos] >>> 26) + | ((in[2 + inpos] & 8388607) << (29 - 23)); + out[3 + outpos] = (in[2 + inpos] >>> 23) + | ((in[3 + inpos] & 1048575) << (29 - 20)); + out[4 + outpos] = (in[3 + inpos] >>> 20) + | ((in[4 + inpos] & 131071) << (29 - 17)); + out[5 + outpos] = (in[4 + inpos] >>> 17) + | ((in[5 + inpos] & 16383) << (29 - 14)); + out[6 + outpos] = (in[5 + inpos] >>> 14) + | ((in[6 + inpos] & 2047) << (29 - 11)); + out[7 + outpos] = (in[6 + inpos] >>> 11) + | ((in[7 + inpos] & 255) << (29 - 8)); + out[8 + outpos] = (in[7 + inpos] >>> 8) + | ((in[8 + inpos] & 31) << (29 - 5)); + out[9 + outpos] = (in[8 + inpos] >>> 5) + | ((in[9 + inpos] & 3) << (29 - 2)); + out[10 + outpos] = ((in[9 + inpos] >>> 2) & 536870911); + out[11 + outpos] = (in[9 + inpos] >>> 31) + | ((in[10 + inpos] & 268435455) << (29 - 28)); + out[12 + outpos] = (in[10 + inpos] >>> 28) + | ((in[11 + inpos] & 33554431) << (29 - 25)); + out[13 + outpos] = (in[11 + inpos] >>> 25) + | ((in[12 + inpos] & 4194303) << (29 - 22)); + out[14 + outpos] = (in[12 + inpos] >>> 22) + | ((in[13 + inpos] & 524287) << (29 - 19)); + out[15 + outpos] = (in[13 + inpos] >>> 19) + | ((in[14 + inpos] & 65535) << (29 - 16)); + out[16 + outpos] = (in[14 + inpos] >>> 16) + | ((in[15 + inpos] & 8191) << (29 - 13)); + out[17 + outpos] = (in[15 + inpos] >>> 13) + | ((in[16 + inpos] & 1023) << (29 - 10)); + out[18 + outpos] = (in[16 + inpos] >>> 10) + | ((in[17 + inpos] & 127) << (29 - 7)); + out[19 + outpos] = (in[17 + inpos] >>> 7) + | ((in[18 + inpos] & 15) << (29 - 4)); + out[20 + outpos] = (in[18 + inpos] >>> 4) + | ((in[19 + inpos] & 1) << (29 - 1)); + out[21 + outpos] = ((in[19 + inpos] >>> 1) & 536870911); + out[22 + outpos] = (in[19 + inpos] >>> 30) + | ((in[20 + inpos] & 134217727) << (29 - 27)); + out[23 + outpos] = (in[20 + inpos] >>> 27) + | ((in[21 + inpos] & 16777215) << (29 - 24)); + out[24 + outpos] = (in[21 + inpos] >>> 24) + | ((in[22 + inpos] & 2097151) << (29 - 21)); + out[25 + outpos] = (in[22 + inpos] >>> 21) + | ((in[23 + inpos] & 262143) << (29 - 18)); + out[26 + outpos] = (in[23 + inpos] >>> 18) + | ((in[24 + inpos] & 32767) << (29 - 15)); + out[27 + outpos] = (in[24 + inpos] >>> 15) + | ((in[25 + inpos] & 4095) << (29 - 12)); + out[28 + outpos] = (in[25 + inpos] >>> 12) + | ((in[26 + inpos] & 511) << (29 - 9)); + out[29 + outpos] = (in[26 + inpos] >>> 9) + | ((in[27 + inpos] & 63) << (29 - 6)); + out[30 + outpos] = (in[27 + inpos] >>> 6) + | ((in[28 + inpos] & 7) << (29 - 3)); + out[31 + outpos] = (in[28 + inpos] >>> 3); + } + protected static void fastunpack3(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = ((in[0 + inpos] >>> 0) & 7); + out[1 + outpos] = ((in[0 + inpos] >>> 3) & 7); + out[2 + outpos] = ((in[0 + inpos] >>> 6) & 7); + out[3 + outpos] = ((in[0 + inpos] >>> 9) & 7); + out[4 + outpos] = ((in[0 + inpos] >>> 12) & 7); + out[5 + outpos] = ((in[0 + inpos] >>> 15) & 7); + out[6 + outpos] = ((in[0 + inpos] >>> 18) & 7); + out[7 + outpos] = ((in[0 + inpos] >>> 21) & 7); + out[8 + outpos] = ((in[0 + inpos] >>> 24) & 7); + out[9 + outpos] = ((in[0 + inpos] >>> 27) & 7); + out[10 + outpos] = (in[0 + inpos] >>> 30) + | ((in[1 + inpos] & 1) << (3 - 1)); + out[11 + outpos] = ((in[1 + inpos] >>> 1) & 7); + out[12 + outpos] = ((in[1 + inpos] >>> 4) & 7); + out[13 + outpos] = ((in[1 + inpos] >>> 7) & 7); + out[14 + outpos] = ((in[1 + inpos] >>> 10) & 7); + out[15 + outpos] = ((in[1 + inpos] >>> 13) & 7); + out[16 + outpos] = ((in[1 + inpos] >>> 16) & 7); + out[17 + outpos] = ((in[1 + inpos] >>> 19) & 7); + out[18 + outpos] = ((in[1 + inpos] >>> 22) & 7); + out[19 + outpos] = ((in[1 + inpos] >>> 25) & 7); + out[20 + outpos] = ((in[1 + inpos] >>> 28) & 7); + out[21 + outpos] = (in[1 + inpos] >>> 31) + | ((in[2 + inpos] & 3) << (3 - 2)); + out[22 + outpos] = ((in[2 + inpos] >>> 2) & 7); + out[23 + outpos] = ((in[2 + inpos] >>> 5) & 7); + out[24 + outpos] = ((in[2 + inpos] >>> 8) & 7); + out[25 + outpos] = ((in[2 + inpos] >>> 11) & 7); + out[26 + outpos] = ((in[2 + inpos] >>> 14) & 7); + out[27 + outpos] = ((in[2 + inpos] >>> 17) & 7); + out[28 + outpos] = ((in[2 + inpos] >>> 20) & 7); + out[29 + outpos] = ((in[2 + inpos] >>> 23) & 7); + out[30 + outpos] = ((in[2 + inpos] >>> 26) & 7); + out[31 + outpos] = (in[2 + inpos] >>> 29); + } - protected static void fastpack0(final int[] in, int inpos, final int[] out, int outpos) { - // nothing - } + protected static void fastunpack30(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = ((in[0 + inpos] >>> 0) & 1073741823); + out[1 + outpos] = (in[0 + inpos] >>> 30) + | ((in[1 + inpos] & 268435455) << (30 - 28)); + out[2 + outpos] = (in[1 + inpos] >>> 28) + | ((in[2 + inpos] & 67108863) << (30 - 26)); + out[3 + outpos] = (in[2 + inpos] >>> 26) + | ((in[3 + inpos] & 16777215) << (30 - 24)); + out[4 + outpos] = (in[3 + inpos] >>> 24) + | ((in[4 + inpos] & 4194303) << (30 - 22)); + out[5 + outpos] = (in[4 + inpos] >>> 22) + | ((in[5 + inpos] & 1048575) << (30 - 20)); + out[6 + outpos] = (in[5 + inpos] >>> 20) + | ((in[6 + inpos] & 262143) << (30 - 18)); + out[7 + outpos] = (in[6 + inpos] >>> 18) + | ((in[7 + inpos] & 65535) << (30 - 16)); + out[8 + outpos] = (in[7 + inpos] >>> 16) + | ((in[8 + inpos] & 16383) << (30 - 14)); + out[9 + outpos] = (in[8 + inpos] >>> 14) + | ((in[9 + inpos] & 4095) << (30 - 12)); + out[10 + outpos] = (in[9 + inpos] >>> 12) + | ((in[10 + inpos] & 1023) << (30 - 10)); + out[11 + outpos] = (in[10 + inpos] >>> 10) + | ((in[11 + inpos] & 255) << (30 - 8)); + out[12 + outpos] = (in[11 + inpos] >>> 8) + | ((in[12 + inpos] & 63) << (30 - 6)); + out[13 + outpos] = (in[12 + inpos] >>> 6) + | ((in[13 + inpos] & 15) << (30 - 4)); + out[14 + outpos] = (in[13 + inpos] >>> 4) + | ((in[14 + inpos] & 3) << (30 - 2)); + out[15 + outpos] = (in[14 + inpos] >>> 2); + out[16 + outpos] = ((in[15 + inpos] >>> 0) & 1073741823); + out[17 + outpos] = (in[15 + inpos] >>> 30) + | ((in[16 + inpos] & 268435455) << (30 - 28)); + out[18 + outpos] = (in[16 + inpos] >>> 28) + | ((in[17 + inpos] & 67108863) << (30 - 26)); + out[19 + outpos] = (in[17 + inpos] >>> 26) + | ((in[18 + inpos] & 16777215) << (30 - 24)); + out[20 + outpos] = (in[18 + inpos] >>> 24) + | ((in[19 + inpos] & 4194303) << (30 - 22)); + out[21 + outpos] = (in[19 + inpos] >>> 22) + | ((in[20 + inpos] & 1048575) << (30 - 20)); + out[22 + outpos] = (in[20 + inpos] >>> 20) + | ((in[21 + inpos] & 262143) << (30 - 18)); + out[23 + outpos] = (in[21 + inpos] >>> 18) + | ((in[22 + inpos] & 65535) << (30 - 16)); + out[24 + outpos] = (in[22 + inpos] >>> 16) + | ((in[23 + inpos] & 16383) << (30 - 14)); + out[25 + outpos] = (in[23 + inpos] >>> 14) + | ((in[24 + inpos] & 4095) << (30 - 12)); + out[26 + outpos] = (in[24 + inpos] >>> 12) + | ((in[25 + inpos] & 1023) << (30 - 10)); + out[27 + outpos] = (in[25 + inpos] >>> 10) + | ((in[26 + inpos] & 255) << (30 - 8)); + out[28 + outpos] = (in[26 + inpos] >>> 8) + | ((in[27 + inpos] & 63) << (30 - 6)); + out[29 + outpos] = (in[27 + inpos] >>> 6) + | ((in[28 + inpos] & 15) << (30 - 4)); + out[30 + outpos] = (in[28 + inpos] >>> 4) + | ((in[29 + inpos] & 3) << (30 - 2)); + out[31 + outpos] = (in[29 + inpos] >>> 2); + } + protected static void fastunpack31(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = ((in[0 + inpos] >>> 0) & 2147483647); + out[1 + outpos] = (in[0 + inpos] >>> 31) + | ((in[1 + inpos] & 1073741823) << (31 - 30)); + out[2 + outpos] = (in[1 + inpos] >>> 30) + | ((in[2 + inpos] & 536870911) << (31 - 29)); + out[3 + outpos] = (in[2 + inpos] >>> 29) + | ((in[3 + inpos] & 268435455) << (31 - 28)); + out[4 + outpos] = (in[3 + inpos] >>> 28) + | ((in[4 + inpos] & 134217727) << (31 - 27)); + out[5 + outpos] = (in[4 + inpos] >>> 27) + | ((in[5 + inpos] & 67108863) << (31 - 26)); + out[6 + outpos] = (in[5 + inpos] >>> 26) + | ((in[6 + inpos] & 33554431) << (31 - 25)); + out[7 + outpos] = (in[6 + inpos] >>> 25) + | ((in[7 + inpos] & 16777215) << (31 - 24)); + out[8 + outpos] = (in[7 + inpos] >>> 24) + | ((in[8 + inpos] & 8388607) << (31 - 23)); + out[9 + outpos] = (in[8 + inpos] >>> 23) + | ((in[9 + inpos] & 4194303) << (31 - 22)); + out[10 + outpos] = (in[9 + inpos] >>> 22) + | ((in[10 + inpos] & 2097151) << (31 - 21)); + out[11 + outpos] = (in[10 + inpos] >>> 21) + | ((in[11 + inpos] & 1048575) << (31 - 20)); + out[12 + outpos] = (in[11 + inpos] >>> 20) + | ((in[12 + inpos] & 524287) << (31 - 19)); + out[13 + outpos] = (in[12 + inpos] >>> 19) + | ((in[13 + inpos] & 262143) << (31 - 18)); + out[14 + outpos] = (in[13 + inpos] >>> 18) + | ((in[14 + inpos] & 131071) << (31 - 17)); + out[15 + outpos] = (in[14 + inpos] >>> 17) + | ((in[15 + inpos] & 65535) << (31 - 16)); + out[16 + outpos] = (in[15 + inpos] >>> 16) + | ((in[16 + inpos] & 32767) << (31 - 15)); + out[17 + outpos] = (in[16 + inpos] >>> 15) + | ((in[17 + inpos] & 16383) << (31 - 14)); + out[18 + outpos] = (in[17 + inpos] >>> 14) + | ((in[18 + inpos] & 8191) << (31 - 13)); + out[19 + outpos] = (in[18 + inpos] >>> 13) + | ((in[19 + inpos] & 4095) << (31 - 12)); + out[20 + outpos] = (in[19 + inpos] >>> 12) + | ((in[20 + inpos] & 2047) << (31 - 11)); + out[21 + outpos] = (in[20 + inpos] >>> 11) + | ((in[21 + inpos] & 1023) << (31 - 10)); + out[22 + outpos] = (in[21 + inpos] >>> 10) + | ((in[22 + inpos] & 511) << (31 - 9)); + out[23 + outpos] = (in[22 + inpos] >>> 9) + | ((in[23 + inpos] & 255) << (31 - 8)); + out[24 + outpos] = (in[23 + inpos] >>> 8) + | ((in[24 + inpos] & 127) << (31 - 7)); + out[25 + outpos] = (in[24 + inpos] >>> 7) + | ((in[25 + inpos] & 63) << (31 - 6)); + out[26 + outpos] = (in[25 + inpos] >>> 6) + | ((in[26 + inpos] & 31) << (31 - 5)); + out[27 + outpos] = (in[26 + inpos] >>> 5) + | ((in[27 + inpos] & 15) << (31 - 4)); + out[28 + outpos] = (in[27 + inpos] >>> 4) + | ((in[28 + inpos] & 7) << (31 - 3)); + out[29 + outpos] = (in[28 + inpos] >>> 3) + | ((in[29 + inpos] & 3) << (31 - 2)); + out[30 + outpos] = (in[29 + inpos] >>> 2) + | ((in[30 + inpos] & 1) << (31 - 1)); + out[31 + outpos] = (in[30 + inpos] >>> 1); + } - protected static void fastpackwithoutmask0(final int[] in, int inpos, final int[] out, int outpos) { - // nothing - } + protected static void fastunpack32(final int[] in, int inpos, + final int[] out, int outpos) { + System.arraycopy(in, inpos, out, outpos, 32); + } + protected static void fastunpack4(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = ((in[0 + inpos] >>> 0) & 15); + out[1 + outpos] = ((in[0 + inpos] >>> 4) & 15); + out[2 + outpos] = ((in[0 + inpos] >>> 8) & 15); + out[3 + outpos] = ((in[0 + inpos] >>> 12) & 15); + out[4 + outpos] = ((in[0 + inpos] >>> 16) & 15); + out[5 + outpos] = ((in[0 + inpos] >>> 20) & 15); + out[6 + outpos] = ((in[0 + inpos] >>> 24) & 15); + out[7 + outpos] = (in[0 + inpos] >>> 28); + out[8 + outpos] = ((in[1 + inpos] >>> 0) & 15); + out[9 + outpos] = ((in[1 + inpos] >>> 4) & 15); + out[10 + outpos] = ((in[1 + inpos] >>> 8) & 15); + out[11 + outpos] = ((in[1 + inpos] >>> 12) & 15); + out[12 + outpos] = ((in[1 + inpos] >>> 16) & 15); + out[13 + outpos] = ((in[1 + inpos] >>> 20) & 15); + out[14 + outpos] = ((in[1 + inpos] >>> 24) & 15); + out[15 + outpos] = (in[1 + inpos] >>> 28); + out[16 + outpos] = ((in[2 + inpos] >>> 0) & 15); + out[17 + outpos] = ((in[2 + inpos] >>> 4) & 15); + out[18 + outpos] = ((in[2 + inpos] >>> 8) & 15); + out[19 + outpos] = ((in[2 + inpos] >>> 12) & 15); + out[20 + outpos] = ((in[2 + inpos] >>> 16) & 15); + out[21 + outpos] = ((in[2 + inpos] >>> 20) & 15); + out[22 + outpos] = ((in[2 + inpos] >>> 24) & 15); + out[23 + outpos] = (in[2 + inpos] >>> 28); + out[24 + outpos] = ((in[3 + inpos] >>> 0) & 15); + out[25 + outpos] = ((in[3 + inpos] >>> 4) & 15); + out[26 + outpos] = ((in[3 + inpos] >>> 8) & 15); + out[27 + outpos] = ((in[3 + inpos] >>> 12) & 15); + out[28 + outpos] = ((in[3 + inpos] >>> 16) & 15); + out[29 + outpos] = ((in[3 + inpos] >>> 20) & 15); + out[30 + outpos] = ((in[3 + inpos] >>> 24) & 15); + out[31 + outpos] = (in[3 + inpos] >>> 28); + } - protected static void fastunpack(final int[] in, int inpos, final int[] out, int outpos, final int bit) { - switch (bit) { - case 0: - fastunpack0(in, inpos, out, outpos); - break; - case 1: - fastunpack1(in, inpos, out, outpos); - break; - case 2: - fastunpack2(in, inpos, out, outpos); - break; - case 3: - fastunpack3(in, inpos, out, outpos); - break; - case 4: - fastunpack4(in, inpos, out, outpos); - break; - case 5: - fastunpack5(in, inpos, out, outpos); - break; - case 6: - fastunpack6(in, inpos, out, outpos); - break; - case 7: - fastunpack7(in, inpos, out, outpos); - break; - case 8: - fastunpack8(in, inpos, out, outpos); - break; - case 9: - fastunpack9(in, inpos, out, outpos); - break; - case 10: - fastunpack10(in, inpos, out, outpos); - break; - case 11: - fastunpack11(in, inpos, out, outpos); - break; - case 12: - fastunpack12(in, inpos, out, outpos); - break; - case 13: - fastunpack13(in, inpos, out, outpos); - break; - case 14: - fastunpack14(in, inpos, out, outpos); - break; - case 15: - fastunpack15(in, inpos, out, outpos); - break; - case 16: - fastunpack16(in, inpos, out, outpos); - break; - case 17: - fastunpack17(in, inpos, out, outpos); - break; - case 18: - fastunpack18(in, inpos, out, outpos); - break; - case 19: - fastunpack19(in, inpos, out, outpos); - break; - case 20: - fastunpack20(in, inpos, out, outpos); - break; - case 21: - fastunpack21(in, inpos, out, outpos); - break; - case 22: - fastunpack22(in, inpos, out, outpos); - break; - case 23: - fastunpack23(in, inpos, out, outpos); - break; - case 24: - fastunpack24(in, inpos, out, outpos); - break; - case 25: - fastunpack25(in, inpos, out, outpos); - break; - case 26: - fastunpack26(in, inpos, out, outpos); - break; - case 27: - fastunpack27(in, inpos, out, outpos); - break; - case 28: - fastunpack28(in, inpos, out, outpos); - break; - case 29: - fastunpack29(in, inpos, out, outpos); - break; - case 30: - fastunpack30(in, inpos, out, outpos); - break; - case 31: - fastunpack31(in, inpos, out, outpos); - break; - case 32: - fastunpack32(in, inpos, out, outpos); - break; - default: - throw new IllegalArgumentException("Unsupported bit width."); + protected static void fastunpack5(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = ((in[0 + inpos] >>> 0) & 31); + out[1 + outpos] = ((in[0 + inpos] >>> 5) & 31); + out[2 + outpos] = ((in[0 + inpos] >>> 10) & 31); + out[3 + outpos] = ((in[0 + inpos] >>> 15) & 31); + out[4 + outpos] = ((in[0 + inpos] >>> 20) & 31); + out[5 + outpos] = ((in[0 + inpos] >>> 25) & 31); + out[6 + outpos] = (in[0 + inpos] >>> 30) + | ((in[1 + inpos] & 7) << (5 - 3)); + out[7 + outpos] = ((in[1 + inpos] >>> 3) & 31); + out[8 + outpos] = ((in[1 + inpos] >>> 8) & 31); + out[9 + outpos] = ((in[1 + inpos] >>> 13) & 31); + out[10 + outpos] = ((in[1 + inpos] >>> 18) & 31); + out[11 + outpos] = ((in[1 + inpos] >>> 23) & 31); + out[12 + outpos] = (in[1 + inpos] >>> 28) + | ((in[2 + inpos] & 1) << (5 - 1)); + out[13 + outpos] = ((in[2 + inpos] >>> 1) & 31); + out[14 + outpos] = ((in[2 + inpos] >>> 6) & 31); + out[15 + outpos] = ((in[2 + inpos] >>> 11) & 31); + out[16 + outpos] = ((in[2 + inpos] >>> 16) & 31); + out[17 + outpos] = ((in[2 + inpos] >>> 21) & 31); + out[18 + outpos] = ((in[2 + inpos] >>> 26) & 31); + out[19 + outpos] = (in[2 + inpos] >>> 31) + | ((in[3 + inpos] & 15) << (5 - 4)); + out[20 + outpos] = ((in[3 + inpos] >>> 4) & 31); + out[21 + outpos] = ((in[3 + inpos] >>> 9) & 31); + out[22 + outpos] = ((in[3 + inpos] >>> 14) & 31); + out[23 + outpos] = ((in[3 + inpos] >>> 19) & 31); + out[24 + outpos] = ((in[3 + inpos] >>> 24) & 31); + out[25 + outpos] = (in[3 + inpos] >>> 29) + | ((in[4 + inpos] & 3) << (5 - 2)); + out[26 + outpos] = ((in[4 + inpos] >>> 2) & 31); + out[27 + outpos] = ((in[4 + inpos] >>> 7) & 31); + out[28 + outpos] = ((in[4 + inpos] >>> 12) & 31); + out[29 + outpos] = ((in[4 + inpos] >>> 17) & 31); + out[30 + outpos] = ((in[4 + inpos] >>> 22) & 31); + out[31 + outpos] = (in[4 + inpos] >>> 27); } - } + protected static void fastunpack6(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = ((in[0 + inpos] >>> 0) & 63); + out[1 + outpos] = ((in[0 + inpos] >>> 6) & 63); + out[2 + outpos] = ((in[0 + inpos] >>> 12) & 63); + out[3 + outpos] = ((in[0 + inpos] >>> 18) & 63); + out[4 + outpos] = ((in[0 + inpos] >>> 24) & 63); + out[5 + outpos] = (in[0 + inpos] >>> 30) + | ((in[1 + inpos] & 15) << (6 - 4)); + out[6 + outpos] = ((in[1 + inpos] >>> 4) & 63); + out[7 + outpos] = ((in[1 + inpos] >>> 10) & 63); + out[8 + outpos] = ((in[1 + inpos] >>> 16) & 63); + out[9 + outpos] = ((in[1 + inpos] >>> 22) & 63); + out[10 + outpos] = (in[1 + inpos] >>> 28) + | ((in[2 + inpos] & 3) << (6 - 2)); + out[11 + outpos] = ((in[2 + inpos] >>> 2) & 63); + out[12 + outpos] = ((in[2 + inpos] >>> 8) & 63); + out[13 + outpos] = ((in[2 + inpos] >>> 14) & 63); + out[14 + outpos] = ((in[2 + inpos] >>> 20) & 63); + out[15 + outpos] = (in[2 + inpos] >>> 26); + out[16 + outpos] = ((in[3 + inpos] >>> 0) & 63); + out[17 + outpos] = ((in[3 + inpos] >>> 6) & 63); + out[18 + outpos] = ((in[3 + inpos] >>> 12) & 63); + out[19 + outpos] = ((in[3 + inpos] >>> 18) & 63); + out[20 + outpos] = ((in[3 + inpos] >>> 24) & 63); + out[21 + outpos] = (in[3 + inpos] >>> 30) + | ((in[4 + inpos] & 15) << (6 - 4)); + out[22 + outpos] = ((in[4 + inpos] >>> 4) & 63); + out[23 + outpos] = ((in[4 + inpos] >>> 10) & 63); + out[24 + outpos] = ((in[4 + inpos] >>> 16) & 63); + out[25 + outpos] = ((in[4 + inpos] >>> 22) & 63); + out[26 + outpos] = (in[4 + inpos] >>> 28) + | ((in[5 + inpos] & 3) << (6 - 2)); + out[27 + outpos] = ((in[5 + inpos] >>> 2) & 63); + out[28 + outpos] = ((in[5 + inpos] >>> 8) & 63); + out[29 + outpos] = ((in[5 + inpos] >>> 14) & 63); + out[30 + outpos] = ((in[5 + inpos] >>> 20) & 63); + out[31 + outpos] = (in[5 + inpos] >>> 26); + } - protected static void fastpack(final int[] in, int inpos, final int[] out, int outpos, final int bit) { - switch (bit) { - case 0: - fastpack0(in, inpos, out, outpos); - break; - case 1: - fastpack1(in, inpos, out, outpos); - break; - case 2: - fastpack2(in, inpos, out, outpos); - break; - case 3: - fastpack3(in, inpos, out, outpos); - break; - case 4: - fastpack4(in, inpos, out, outpos); - break; - case 5: - fastpack5(in, inpos, out, outpos); - break; - case 6: - fastpack6(in, inpos, out, outpos); - break; - case 7: - fastpack7(in, inpos, out, outpos); - break; - case 8: - fastpack8(in, inpos, out, outpos); - break; - case 9: - fastpack9(in, inpos, out, outpos); - break; - case 10: - fastpack10(in, inpos, out, outpos); - break; - case 11: - fastpack11(in, inpos, out, outpos); - break; - case 12: - fastpack12(in, inpos, out, outpos); - break; - case 13: - fastpack13(in, inpos, out, outpos); - break; - case 14: - fastpack14(in, inpos, out, outpos); - break; - case 15: - fastpack15(in, inpos, out, outpos); - break; - case 16: - fastpack16(in, inpos, out, outpos); - break; - case 17: - fastpack17(in, inpos, out, outpos); - break; - case 18: - fastpack18(in, inpos, out, outpos); - break; - case 19: - fastpack19(in, inpos, out, outpos); - break; - case 20: - fastpack20(in, inpos, out, outpos); - break; - case 21: - fastpack21(in, inpos, out, outpos); - break; - case 22: - fastpack22(in, inpos, out, outpos); - break; - case 23: - fastpack23(in, inpos, out, outpos); - break; - case 24: - fastpack24(in, inpos, out, outpos); - break; - case 25: - fastpack25(in, inpos, out, outpos); - break; - case 26: - fastpack26(in, inpos, out, outpos); - break; - case 27: - fastpack27(in, inpos, out, outpos); - break; - case 28: - fastpack28(in, inpos, out, outpos); - break; - case 29: - fastpack29(in, inpos, out, outpos); - break; - case 30: - fastpack30(in, inpos, out, outpos); - break; - case 31: - fastpack31(in, inpos, out, outpos); - break; - case 32: - fastpack32(in, inpos, out, outpos); - break; - default: - throw new IllegalArgumentException("Unsupported bit width."); + protected static void fastunpack7(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = ((in[0 + inpos] >>> 0) & 127); + out[1 + outpos] = ((in[0 + inpos] >>> 7) & 127); + out[2 + outpos] = ((in[0 + inpos] >>> 14) & 127); + out[3 + outpos] = ((in[0 + inpos] >>> 21) & 127); + out[4 + outpos] = (in[0 + inpos] >>> 28) + | ((in[1 + inpos] & 7) << (7 - 3)); + out[5 + outpos] = ((in[1 + inpos] >>> 3) & 127); + out[6 + outpos] = ((in[1 + inpos] >>> 10) & 127); + out[7 + outpos] = ((in[1 + inpos] >>> 17) & 127); + out[8 + outpos] = ((in[1 + inpos] >>> 24) & 127); + out[9 + outpos] = (in[1 + inpos] >>> 31) + | ((in[2 + inpos] & 63) << (7 - 6)); + out[10 + outpos] = ((in[2 + inpos] >>> 6) & 127); + out[11 + outpos] = ((in[2 + inpos] >>> 13) & 127); + out[12 + outpos] = ((in[2 + inpos] >>> 20) & 127); + out[13 + outpos] = (in[2 + inpos] >>> 27) + | ((in[3 + inpos] & 3) << (7 - 2)); + out[14 + outpos] = ((in[3 + inpos] >>> 2) & 127); + out[15 + outpos] = ((in[3 + inpos] >>> 9) & 127); + out[16 + outpos] = ((in[3 + inpos] >>> 16) & 127); + out[17 + outpos] = ((in[3 + inpos] >>> 23) & 127); + out[18 + outpos] = (in[3 + inpos] >>> 30) + | ((in[4 + inpos] & 31) << (7 - 5)); + out[19 + outpos] = ((in[4 + inpos] >>> 5) & 127); + out[20 + outpos] = ((in[4 + inpos] >>> 12) & 127); + out[21 + outpos] = ((in[4 + inpos] >>> 19) & 127); + out[22 + outpos] = (in[4 + inpos] >>> 26) + | ((in[5 + inpos] & 1) << (7 - 1)); + out[23 + outpos] = ((in[5 + inpos] >>> 1) & 127); + out[24 + outpos] = ((in[5 + inpos] >>> 8) & 127); + out[25 + outpos] = ((in[5 + inpos] >>> 15) & 127); + out[26 + outpos] = ((in[5 + inpos] >>> 22) & 127); + out[27 + outpos] = (in[5 + inpos] >>> 29) + | ((in[6 + inpos] & 15) << (7 - 4)); + out[28 + outpos] = ((in[6 + inpos] >>> 4) & 127); + out[29 + outpos] = ((in[6 + inpos] >>> 11) & 127); + out[30 + outpos] = ((in[6 + inpos] >>> 18) & 127); + out[31 + outpos] = (in[6 + inpos] >>> 25); } - } + protected static void fastunpack8(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = ((in[0 + inpos] >>> 0) & 255); + out[1 + outpos] = ((in[0 + inpos] >>> 8) & 255); + out[2 + outpos] = ((in[0 + inpos] >>> 16) & 255); + out[3 + outpos] = (in[0 + inpos] >>> 24); + out[4 + outpos] = ((in[1 + inpos] >>> 0) & 255); + out[5 + outpos] = ((in[1 + inpos] >>> 8) & 255); + out[6 + outpos] = ((in[1 + inpos] >>> 16) & 255); + out[7 + outpos] = (in[1 + inpos] >>> 24); + out[8 + outpos] = ((in[2 + inpos] >>> 0) & 255); + out[9 + outpos] = ((in[2 + inpos] >>> 8) & 255); + out[10 + outpos] = ((in[2 + inpos] >>> 16) & 255); + out[11 + outpos] = (in[2 + inpos] >>> 24); + out[12 + outpos] = ((in[3 + inpos] >>> 0) & 255); + out[13 + outpos] = ((in[3 + inpos] >>> 8) & 255); + out[14 + outpos] = ((in[3 + inpos] >>> 16) & 255); + out[15 + outpos] = (in[3 + inpos] >>> 24); + out[16 + outpos] = ((in[4 + inpos] >>> 0) & 255); + out[17 + outpos] = ((in[4 + inpos] >>> 8) & 255); + out[18 + outpos] = ((in[4 + inpos] >>> 16) & 255); + out[19 + outpos] = (in[4 + inpos] >>> 24); + out[20 + outpos] = ((in[5 + inpos] >>> 0) & 255); + out[21 + outpos] = ((in[5 + inpos] >>> 8) & 255); + out[22 + outpos] = ((in[5 + inpos] >>> 16) & 255); + out[23 + outpos] = (in[5 + inpos] >>> 24); + out[24 + outpos] = ((in[6 + inpos] >>> 0) & 255); + out[25 + outpos] = ((in[6 + inpos] >>> 8) & 255); + out[26 + outpos] = ((in[6 + inpos] >>> 16) & 255); + out[27 + outpos] = (in[6 + inpos] >>> 24); + out[28 + outpos] = ((in[7 + inpos] >>> 0) & 255); + out[29 + outpos] = ((in[7 + inpos] >>> 8) & 255); + out[30 + outpos] = ((in[7 + inpos] >>> 16) & 255); + out[31 + outpos] = (in[7 + inpos] >>> 24); + } - protected static void fastpackwithoutmask(final int[] in, int inpos, final int[] out, int outpos, final int bit) { - switch (bit) { - case 0: - fastpackwithoutmask0(in, inpos, out, outpos); - break; - case 1: - fastpackwithoutmask1(in, inpos, out, outpos); - break; - case 2: - fastpackwithoutmask2(in, inpos, out, outpos); - break; - case 3: - fastpackwithoutmask3(in, inpos, out, outpos); - break; - case 4: - fastpackwithoutmask4(in, inpos, out, outpos); - break; - case 5: - fastpackwithoutmask5(in, inpos, out, outpos); - break; - case 6: - fastpackwithoutmask6(in, inpos, out, outpos); - break; - case 7: - fastpackwithoutmask7(in, inpos, out, outpos); - break; - case 8: - fastpackwithoutmask8(in, inpos, out, outpos); - break; - case 9: - fastpackwithoutmask9(in, inpos, out, outpos); - break; - case 10: - fastpackwithoutmask10(in, inpos, out, outpos); - break; - case 11: - fastpackwithoutmask11(in, inpos, out, outpos); - break; - case 12: - fastpackwithoutmask12(in, inpos, out, outpos); - break; - case 13: - fastpackwithoutmask13(in, inpos, out, outpos); - break; - case 14: - fastpackwithoutmask14(in, inpos, out, outpos); - break; - case 15: - fastpackwithoutmask15(in, inpos, out, outpos); - break; - case 16: - fastpackwithoutmask16(in, inpos, out, outpos); - break; - case 17: - fastpackwithoutmask17(in, inpos, out, outpos); - break; - case 18: - fastpackwithoutmask18(in, inpos, out, outpos); - break; - case 19: - fastpackwithoutmask19(in, inpos, out, outpos); - break; - case 20: - fastpackwithoutmask20(in, inpos, out, outpos); - break; - case 21: - fastpackwithoutmask21(in, inpos, out, outpos); - break; - case 22: - fastpackwithoutmask22(in, inpos, out, outpos); - break; - case 23: - fastpackwithoutmask23(in, inpos, out, outpos); - break; - case 24: - fastpackwithoutmask24(in, inpos, out, outpos); - break; - case 25: - fastpackwithoutmask25(in, inpos, out, outpos); - break; - case 26: - fastpackwithoutmask26(in, inpos, out, outpos); - break; - case 27: - fastpackwithoutmask27(in, inpos, out, outpos); - break; - case 28: - fastpackwithoutmask28(in, inpos, out, outpos); - break; - case 29: - fastpackwithoutmask29(in, inpos, out, outpos); - break; - case 30: - fastpackwithoutmask30(in, inpos, out, outpos); - break; - case 31: - fastpackwithoutmask31(in, inpos, out, outpos); - break; - case 32: - fastpackwithoutmask32(in, inpos, out, outpos); - break; - default: - throw new IllegalArgumentException("Unsupported bit width."); + protected static void fastunpack9(final int[] in, int inpos, + final int[] out, int outpos) { + out[0 + outpos] = ((in[0 + inpos] >>> 0) & 511); + out[1 + outpos] = ((in[0 + inpos] >>> 9) & 511); + out[2 + outpos] = ((in[0 + inpos] >>> 18) & 511); + out[3 + outpos] = (in[0 + inpos] >>> 27) + | ((in[1 + inpos] & 15) << (9 - 4)); + out[4 + outpos] = ((in[1 + inpos] >>> 4) & 511); + out[5 + outpos] = ((in[1 + inpos] >>> 13) & 511); + out[6 + outpos] = ((in[1 + inpos] >>> 22) & 511); + out[7 + outpos] = (in[1 + inpos] >>> 31) + | ((in[2 + inpos] & 255) << (9 - 8)); + out[8 + outpos] = ((in[2 + inpos] >>> 8) & 511); + out[9 + outpos] = ((in[2 + inpos] >>> 17) & 511); + out[10 + outpos] = (in[2 + inpos] >>> 26) + | ((in[3 + inpos] & 7) << (9 - 3)); + out[11 + outpos] = ((in[3 + inpos] >>> 3) & 511); + out[12 + outpos] = ((in[3 + inpos] >>> 12) & 511); + out[13 + outpos] = ((in[3 + inpos] >>> 21) & 511); + out[14 + outpos] = (in[3 + inpos] >>> 30) + | ((in[4 + inpos] & 127) << (9 - 7)); + out[15 + outpos] = ((in[4 + inpos] >>> 7) & 511); + out[16 + outpos] = ((in[4 + inpos] >>> 16) & 511); + out[17 + outpos] = (in[4 + inpos] >>> 25) + | ((in[5 + inpos] & 3) << (9 - 2)); + out[18 + outpos] = ((in[5 + inpos] >>> 2) & 511); + out[19 + outpos] = ((in[5 + inpos] >>> 11) & 511); + out[20 + outpos] = ((in[5 + inpos] >>> 20) & 511); + out[21 + outpos] = (in[5 + inpos] >>> 29) + | ((in[6 + inpos] & 63) << (9 - 6)); + out[22 + outpos] = ((in[6 + inpos] >>> 6) & 511); + out[23 + outpos] = ((in[6 + inpos] >>> 15) & 511); + out[24 + outpos] = (in[6 + inpos] >>> 24) + | ((in[7 + inpos] & 1) << (9 - 1)); + out[25 + outpos] = ((in[7 + inpos] >>> 1) & 511); + out[26 + outpos] = ((in[7 + inpos] >>> 10) & 511); + out[27 + outpos] = ((in[7 + inpos] >>> 19) & 511); + out[28 + outpos] = (in[7 + inpos] >>> 28) + | ((in[8 + inpos] & 31) << (9 - 5)); + out[29 + outpos] = ((in[8 + inpos] >>> 5) & 511); + out[30 + outpos] = ((in[8 + inpos] >>> 14) & 511); + out[31 + outpos] = (in[8 + inpos] >>> 23); } - } } diff --git a/src/main/java/me/lemire/integercompression/ByteIntegerCODEC.java b/src/main/java/me/lemire/integercompression/ByteIntegerCODEC.java new file mode 100644 index 0000000..6e8f903 --- /dev/null +++ b/src/main/java/me/lemire/integercompression/ByteIntegerCODEC.java @@ -0,0 +1,60 @@ +/** + * This code is released under the + * Apache License Version 2.0 http://www.apache.org/licenses/. + * + * (c) Daniel Lemire, http://lemire.me/en/ + */ + +package me.lemire.integercompression; + +/** + * Interface describing a CODEC to compress integers to bytes. + * + * @author Daniel Lemire + * + */ +public interface ByteIntegerCODEC { + /** + * Compress data from an array to another array. + * + * Both inpos and outpos are modified to represent how much data was + * read and written to. If 12 ints (inlength = 12) are compressed to 3 + * bytes, then inpos will be incremented by 12 while outpos will be + * incremented by 3. We use IntWrapper to pass the values by reference. + * + * @param in + * input array + * @param inpos + * location in the input array + * @param inlength + * how many integers to compress + * @param out + * output array + * @param outpos + * where to write in the output array + */ + public void compress(int[] in, IntWrapper inpos, int inlength, + byte[] out, IntWrapper outpos); + + /** + * Uncompress data from an array to another array. + * + * Both inpos and outpos parameters are modified to indicate new + * positions after read/write. + * + * @param in + * array containing data in compressed form + * @param inpos + * where to start reading in the array + * @param inlength + * length of the compressed data (ignored by some + * schemes) + * @param out + * array where to write the compressed output + * @param outpos + * where to write the compressed output in out + */ + public void uncompress(byte[] in, IntWrapper inpos, int inlength, + int[] out, IntWrapper outpos); + +} diff --git a/src/main/java/me/lemire/integercompression/Composition.java b/src/main/java/me/lemire/integercompression/Composition.java index df6f3a5..a11278b 100644 --- a/src/main/java/me/lemire/integercompression/Composition.java +++ b/src/main/java/me/lemire/integercompression/Composition.java @@ -6,60 +6,64 @@ */ package me.lemire.integercompression; - /** * Helper class to compose schemes. - * + * * @author Daniel Lemire */ public class Composition implements IntegerCODEC { - IntegerCODEC F1, F2; - - /** - * Compose a scheme from a first one (f1) and a second one (f2). - * The first one is called first and then the second one tries to - * compress whatever remains from the first run. - * - * By convention, the first scheme should be such that if, during - * decoding, a 32-bit zero is first encountered, then there is no - * output. - * - * @param f1 first codec - * @param f2 second codec - */ - public Composition(IntegerCODEC f1, IntegerCODEC f2) { - F1 = f1; - F2 = f2; - } + IntegerCODEC F1, F2; - @Override - public void compress(int[] in, IntWrapper inpos, int inlength, int[] out, - IntWrapper outpos) { - if(inlength == 0) return; - int init = inpos.get(); - F1.compress(in, inpos, inlength, out, outpos); - if (outpos.get() == 0) { - out[0] = 0; - outpos.increment(); + /** + * Compose a scheme from a first one (f1) and a second one (f2). The + * first one is called first and then the second one tries to compress + * whatever remains from the first run. + * + * By convention, the first scheme should be such that if, during + * decoding, a 32-bit zero is first encountered, then there is no + * output. + * + * @param f1 + * first codec + * @param f2 + * second codec + */ + public Composition(IntegerCODEC f1, IntegerCODEC f2) { + F1 = f1; + F2 = f2; } - inlength -= inpos.get() - init; - F2.compress(in, inpos, inlength, out, outpos); - } - @Override - public void uncompress(int[] in, IntWrapper inpos, int inlength, - int[] out, IntWrapper outpos) { - if(inlength == 0) return; - final int init = inpos.get(); - F1.uncompress(in, inpos, inlength, out, outpos); - inlength -= inpos.get() - init; - F2.uncompress(in, inpos, inlength, out, outpos); - } + @Override + public void compress(int[] in, IntWrapper inpos, int inlength, + int[] out, IntWrapper outpos) { + if (inlength == 0) { + return; + } + int inposInit = inpos.get(); + int outposInit = outpos.get(); + F1.compress(in, inpos, inlength, out, outpos); + if (outpos.get() == outposInit) { + out[outposInit] = 0; + outpos.increment(); + } + inlength -= inpos.get() - inposInit; + F2.compress(in, inpos, inlength, out, outpos); + } + @Override + public void uncompress(int[] in, IntWrapper inpos, int inlength, + int[] out, IntWrapper outpos) { + if (inlength == 0) + return; + final int init = inpos.get(); + F1.uncompress(in, inpos, inlength, out, outpos); + inlength -= inpos.get() - init; + F2.uncompress(in, inpos, inlength, out, outpos); + } - @Override - public String toString() { - return F1.toString() + "+" + F2.toString(); - } + @Override + public String toString() { + return F1.toString() + " + " + F2.toString(); + } } diff --git a/src/main/java/me/lemire/integercompression/Delta.java b/src/main/java/me/lemire/integercompression/Delta.java deleted file mode 100644 index 372da82..0000000 --- a/src/main/java/me/lemire/integercompression/Delta.java +++ /dev/null @@ -1,63 +0,0 @@ -/** - * This code is released under the - * Apache License Version 2.0 http://www.apache.org/licenses/. - * - * (c) Daniel Lemire, http://lemire.me/en/ - */ - -package me.lemire.integercompression; - -/** - * Generic class to compute differential coding. - * - * @author Daniel Lemire - * - */ -public class Delta { - - /** - * Apply differential coding (in-place). - * - * @param data data to be modified - */ - public static void delta(int[] data) { - for (int i = data.length - 1; i > 0; --i) { - data[i] -= data[i - 1]; - } - } - - /** - * Undo differential coding (in-place). Effectively - * computes a prefix sum. - * - * @param data to be modified. - */ - public static void inverseDelta(int[] data) { - for (int i = 1; i < data.length; ++i) { - data[i] += data[i - 1]; - } - } - - /** - * Like inverseDelta, only faster. - * - * @param data to be modified - */ - public static void fastinverseDelta(int[] data) { - int sz0 = data.length / 4 * 4; - int i = 1; - if (sz0 >= 4) { - int a = data[0]; - for (; i < sz0 - 4; i += 4) { - a = data[i] += a; - a = data[i + 1] += a; - a = data[i + 2] += a; - a = data[i + 3] += a; - } - } - - for (; i != data.length; ++i) { - data[i] += data[i - 1]; - } - } -} diff --git a/src/main/java/me/lemire/integercompression/DeltaZigzagBinaryPacking.java b/src/main/java/me/lemire/integercompression/DeltaZigzagBinaryPacking.java new file mode 100644 index 0000000..a774836 --- /dev/null +++ b/src/main/java/me/lemire/integercompression/DeltaZigzagBinaryPacking.java @@ -0,0 +1,105 @@ +/* + * This code is released under the + * Apache License Version 2.0 http://www.apache.org/licenses/. + */ + +package me.lemire.integercompression; + +/** + * BinaryPacking with Delta+Zigzag Encoding. + * + * It encodes integers in blocks of 128 integers. For arrays containing + * an arbitrary number of integers, you should use it in conjunction + * with another CODEC: + * + *
IntegerCODEC ic = new Composition(new DeltaZigzagBinaryPacking(),
+ *                      new DeltaZigzagVariableByte()).
+ * + * @author MURAOKA Taro http://github.com/koron + */ +public final class DeltaZigzagBinaryPacking implements IntegerCODEC { + + private static final int BLOCK_LENGTH = 128; + + @Override + public void compress(int[] inBuf, IntWrapper inPos, int inLen, + int[] outBuf, IntWrapper outPos) { + inLen = inLen - inLen % BLOCK_LENGTH; + if (inLen == 0) { + return; + } + + outBuf[outPos.get()] = inLen; + outPos.increment(); + + DeltaZigzagEncoding.Encoder ctx = new DeltaZigzagEncoding.Encoder(0); + int[] work = new int[BLOCK_LENGTH]; + + int op = outPos.get(); + int ip = inPos.get(); + final int inPosLast = ip + inLen; + for (; ip < inPosLast; ip += BLOCK_LENGTH) { + ctx.encodeArray(inBuf, ip, BLOCK_LENGTH, work); + final int bits1 = Util.maxbits32(work, 0); + final int bits2 = Util.maxbits32(work, 32); + final int bits3 = Util.maxbits32(work, 64); + final int bits4 = Util.maxbits32(work, 96); + outBuf[op++] = (bits1 << 24) | (bits2 << 16) + | (bits3 << 8) | (bits4 << 0); + op += pack(work, 0, outBuf, op, bits1); + op += pack(work, 32, outBuf, op, bits2); + op += pack(work, 64, outBuf, op, bits3); + op += pack(work, 96, outBuf, op, bits4); + } + + inPos.add(inLen); + outPos.set(op); + } + + @Override + public void uncompress(int[] inBuf, IntWrapper inPos, int inLen, + int[] outBuf, IntWrapper outPos) { + if (inLen == 0) { + return; + } + + final int outLen = inBuf[inPos.get()]; + inPos.increment(); + + DeltaZigzagEncoding.Decoder ctx = new DeltaZigzagEncoding.Decoder(0); + int[] work = new int[BLOCK_LENGTH]; + + int ip = inPos.get(); + int op = outPos.get(); + final int outPosLast = op + outLen; + for (; op < outPosLast; op += BLOCK_LENGTH) { + int n = inBuf[ip++]; + ip += unpack(inBuf, ip, work, 0, (n >> 24) & 0x3F); + ip += unpack(inBuf, ip, work, 32, (n >> 16) & 0x3F); + ip += unpack(inBuf, ip, work, 64, (n >> 8) & 0x3F); + ip += unpack(inBuf, ip, work, 96, (n >> 0) & 0x3F); + ctx.decodeArray(work, 0, BLOCK_LENGTH, outBuf, op); + } + + outPos.add(outLen); + inPos.set(ip); + } + + private static int pack(int[] inBuf, int inOff, int[] outBuf, + int outOff, int validBits) { + BitPacking.fastpackwithoutmask(inBuf, inOff, outBuf, outOff, + validBits); + return validBits; + } + + private static int unpack(int[] inBuf, int inOff, int[] outBuf, + int outOff, int validBits) { + BitPacking.fastunpack(inBuf, inOff, outBuf, outOff, validBits); + return validBits; + } + + @Override + public String toString() { + return this.getClass().getSimpleName(); + } +} diff --git a/src/main/java/me/lemire/integercompression/DeltaZigzagEncoding.java b/src/main/java/me/lemire/integercompression/DeltaZigzagEncoding.java new file mode 100644 index 0000000..a3f0d7e --- /dev/null +++ b/src/main/java/me/lemire/integercompression/DeltaZigzagEncoding.java @@ -0,0 +1,94 @@ +/* + * This code is released under the + * Apache License Version 2.0 http://www.apache.org/licenses/. + */ +package me.lemire.integercompression; + +/** + * Delta+Zigzag Encoding. + * + * @author MURAOKA Taro http://github.com/koron + */ +public final class DeltaZigzagEncoding { + + static class Context { + int contextValue; + + Context(int contextValue) { + this.contextValue = contextValue; + } + + void setContextValue(int contextValue) { + this.contextValue = contextValue; + } + + int getContextValue() { + return this.contextValue; + } + } + + static class Encoder extends Context { + Encoder(int contextValue) { + super(contextValue); + } + + int encodeInt(int value) { + int n = value - this.contextValue; + this.contextValue = value; + return (n << 1) ^ (n >> 31); + } + + int[] encodeArray(int[] src, int srcoff, int length, + int[] dst, int dstoff) { + for (int i = 0; i < length; ++i) { + dst[dstoff + i] = encodeInt(src[srcoff + i]); + } + return dst; + } + + int[] encodeArray(int[] src, int srcoff, int length, + int[] dst) { + return encodeArray(src, srcoff, length, dst, 0); + } + + int[] encodeArray(int[] src, int offset, int length) { + return encodeArray(src, offset, length, + new int[length], 0); + } + + int[] encodeArray(int[] src) { + return encodeArray(src, 0, src.length, + new int[src.length], 0); + } + } + + static class Decoder extends Context { + Decoder(int contextValue) { + super(contextValue); + } + + int decodeInt(int value) { + int n = (value >>> 1) ^ ((value << 31) >> 31); + n += this.contextValue; + this.contextValue = n; + return n; + } + + int[] decodeArray(int[] src, int srcoff, int length, + int[] dst, int dstoff) { + for (int i = 0; i < length; ++i) { + dst[dstoff + i] = decodeInt(src[srcoff + i]); + } + return dst; + } + + int[] decodeArray(int[] src, int offset, int length) { + return decodeArray(src, offset, length, + new int[length], 0); + } + + int[] decodeArray(int[] src) { + return decodeArray(src, 0, src.length); + } + } +} diff --git a/src/main/java/me/lemire/integercompression/DeltaZigzagVariableByte.java b/src/main/java/me/lemire/integercompression/DeltaZigzagVariableByte.java new file mode 100644 index 0000000..2f8c709 --- /dev/null +++ b/src/main/java/me/lemire/integercompression/DeltaZigzagVariableByte.java @@ -0,0 +1,144 @@ +/* + * This code is released under the + * Apache License Version 2.0 http://www.apache.org/licenses/. + */ + +package me.lemire.integercompression; + +import java.nio.ByteBuffer; +import java.nio.IntBuffer; + +/** + * VariableByte with Delta+Zigzag Encoding. + * + * @author MURAOKA Taro http://github.com/koron + */ +public class DeltaZigzagVariableByte implements IntegerCODEC { + + @Override + public String toString() { + return DeltaZigzagVariableByte.class.getSimpleName(); + } + + @Override + public void compress(int[] inBuf, IntWrapper inPos, int inLen, + int[] outBuf, IntWrapper outPos) { + if (inLen == 0) { + return; + } + + ByteBuffer byteBuf = makeBuffer(inLen * 5 + 3); + DeltaZigzagEncoding.Encoder ctx = new DeltaZigzagEncoding.Encoder(0); + + // Delta+Zigzag+VariableByte encoding. + int ip = inPos.get(); + final int inPosLast = ip + inLen; + for (; ip < inPosLast; ++ip) { + // Filter with delta+zigzag encoding. + int n = ctx.encodeInt(inBuf[ip]); + // Variable byte encoding. + switch (Integer.numberOfLeadingZeros(n)) { + case 0: + case 1: + case 2: + case 3: + byteBuf.put((byte) (((n >>> 28) & 0x7F) | 0x80)); + // through. + //$FALL-THROUGH$ + case 4: + case 5: + case 6: + case 7: + case 8: + case 9: + case 10: + byteBuf.put((byte) (((n >>> 21) & 0x7F) | 0x80)); + // through. + //$FALL-THROUGH$ + case 11: + case 12: + case 13: + case 14: + case 15: + case 16: + case 17: + byteBuf.put((byte) (((n >>> 14) & 0x7F) | 0x80)); + // through. + //$FALL-THROUGH$ + case 18: + case 19: + case 20: + case 21: + case 22: + case 23: + case 24: + byteBuf.put((byte) (((n >>> 7) & 0x7F) | 0x80)); + // through. + //$FALL-THROUGH$ + default: + byteBuf.put((byte) (n & 0x7F)); + } + } + + // Padding buffer to considerable as IntBuffer. + for (int i = (4 - (byteBuf.position() % 4)) % 4; i > 0; --i) { + byteBuf.put((byte) (0x80)); + } + + int outLen = byteBuf.position() / 4; + byteBuf.flip(); + IntBuffer intBuf = byteBuf.asIntBuffer(); + /* + * System.out.println(String.format( + * "inLen=%d pos=%d limit=%d outLen=%d outBuf.len=%d", inLen, + * intBuf.position(), intBuf.limit(), outLen, outBuf.length)); + */ + intBuf.get(outBuf, outPos.get(), outLen); + inPos.add(inLen); + outPos.add(outLen); + } + + @Override + public void uncompress(int[] inBuf, IntWrapper inPos, int inLen, + int[] outBuf, IntWrapper outPos) { + DeltaZigzagEncoding.Decoder ctx = new DeltaZigzagEncoding.Decoder(0); + + int ip = inPos.get(); + int op = outPos.get(); + int vbcNum = 0, vbcShift = 24; // Variable Byte Context. + final int inPosLast = ip + inLen; + while (ip < inPosLast) { + // Fetch a byte value. + int n = (inBuf[ip] >>> vbcShift) & 0xFF; + if (vbcShift > 0) { + vbcShift -= 8; + } else { + vbcShift = 24; + ip++; + } + // Decode variable byte and delta+zigzag. + vbcNum = (vbcNum << 7) + (n & 0x7F); + if ((n & 0x80) == 0) { + outBuf[op++] = ctx.decodeInt(vbcNum); + vbcNum = 0; + } + } + + outPos.set(op); + inPos.set(inPosLast); + } + + /** + * Creates a new buffer of the requested size. + * + * In case you need a different way to allocate buffers, you can override this method + * with a custom behavior. The default implementation allocates a new Java direct + * {@link ByteBuffer} on each invocation. + * + * @param sizeInBytes + * @return + */ + protected ByteBuffer makeBuffer(int sizeInBytes) { + return ByteBuffer.allocateDirect(sizeInBytes); + } +} diff --git a/src/main/java/me/lemire/integercompression/FastPFOR.java b/src/main/java/me/lemire/integercompression/FastPFOR.java index e0f7da1..5475496 100644 --- a/src/main/java/me/lemire/integercompression/FastPFOR.java +++ b/src/main/java/me/lemire/integercompression/FastPFOR.java @@ -7,264 +7,359 @@ package me.lemire.integercompression; import java.nio.ByteBuffer; +import java.nio.ByteOrder; import java.util.Arrays; /** - * This is a new PFOR Scheme designed by D. Lemire called FastPFOR. - *

- * For details, please see - *

- * Daniel Lemire and Leonid Boytsov, Decoding billions of integers per second through vectorization - * Software: Practice & Experience - * http://onlinelibrary.wiley.com/doi/10.1002/spe.2203/abstract - * http://arxiv.org/abs/1209.2137 - *

- * For sufficiently compressible arrays, it is faster and better than other PFOR - * schemes. + * This is a patching scheme designed for speed. + * It encodes integers in blocks of integers within pages of + * up to 65536 integers. Note that it is important, to get good + * compression and good performance, to use sizeable arrays (greater than 1024 integers). + * For arrays containing a number of integers that is not divisible by BLOCK_SIZE, you should use + * it in conjunction with another CODEC: + * + * IntegerCODEC ic = new Composition(new FastPFOR(), new VariableByte()). + *

+ * For details, please see: + *

+ * Daniel Lemire and Leonid Boytsov, Decoding billions of integers per second + * through vectorization Software: Practice & Experience + * http://onlinelibrary.wiley.com/doi/10.1002/spe.2203/abstract + * http://arxiv.org/abs/1209.2137 + *

+ *

For sufficiently compressible and long arrays, it is faster and better than other PFOR + * schemes.

+ * + * Note that this does not use differential coding: if you are working on sorted + * lists, you should first compute deltas, @see me.lemire.integercompression.differential.Delta#delta. + * + * For multi-threaded applications, each thread should use its own FastPFOR + * object. * * @author Daniel Lemire */ -public final class FastPFOR implements IntegerCODEC { - final static int BLOCK_SIZE = 128; - final static int OVERHEAD_OF_EACH_EXCEPT = 8; - final static int DEFAULT_PAGE_SIZE = 65536; - - int pageSize; - final int[][] dataTobePacked = new int[32][]; - final ByteBuffer byteContainer; +public class FastPFOR implements IntegerCODEC,SkippableIntegerCODEC { + final static int OVERHEAD_OF_EACH_EXCEPT = 8; + private static final int OVERHEAD_OF_EACH_PAGE_IN_INTS = 36; // 1 int for the header + // 1 int for the byte array size + // 1 int for the bitmap + // 1 int for byte array padding (to align to 4 bytes) + // 32 to have enough space to bit-pack the exceptions + private static final int OVERHEAD_OF_EACH_BLOCK_IN_INTS = 1; // 1 byte for the number of bits allocated per truncated integer + // 1 byte for the number of exceptions + /** + * + */ + public final static int DEFAULT_PAGE_SIZE = 65536; + /** + * + */ + public final static int BLOCK_SIZE = 256; - // Working area for compress and uncompress. - int[] dataPointers; - int[] freqs; - byte[] bestbbestcexceptmaxb; + final int pageSize; + final int[][] dataTobePacked = new int[33][]; + final ByteBuffer byteContainer; - /** - * Construct the FastPFOR CODEC. - * @param pagesize the desired page size (for expert use) - */ - public FastPFOR(int pagesize) { - pageSize = pagesize; - // Initiate arrrays. - byteContainer = ByteBuffer.allocateDirect(3 * pageSize / BLOCK_SIZE - + pageSize); - for (int k = 1; k < 32; ++k) - dataTobePacked[k] = new int[pageSize / 32 * 4]; // heuristic - } + // Working area for compress and uncompress. + final int[] dataPointers = new int[33]; + final int[] freqs = new int[33]; + final int[] bestbbestcexceptmaxb = new int[3]; - /** - * Construct the fastPFOR CODEC with default parameters. - */ - public FastPFOR() { - this(DEFAULT_PAGE_SIZE); - } - /** - * Compress data in blocks of 128 integers (if fewer than 128 integers are - * provided, nothing is done). - * - * @see IntegerCODEC#compress(int[], IntWrapper, int, int[], IntWrapper) - */ - @Override - public void compress(int[] in, IntWrapper inpos, int inlength, int[] out, - IntWrapper outpos) { - inlength = Util.floorBy(inlength, 128); - if (inlength == 0) return; + /** + * Construct the FastPFOR CODEC. + * + * @param pagesize + * the desired page size (recommended value is FastPFOR.DEFAULT_PAGE_SIZE) + */ + FastPFOR(int pagesize) { + pageSize = pagesize; + // Initiate arrrays. + byteContainer = makeBuffer(3 * pageSize + / BLOCK_SIZE + pageSize); + byteContainer.order(ByteOrder.LITTLE_ENDIAN); + for (int k = 1; k < dataTobePacked.length; ++k) + dataTobePacked[k] = new int[pageSize / 32 * 4]; // heuristic + } - out[outpos.get()] = inlength; - outpos.increment(); + /** + * Construct the fastPFOR CODEC with default parameters. + */ + public FastPFOR() { + this( DEFAULT_PAGE_SIZE); + } - // Allocate memory for working area. - dataPointers = new int[33]; - freqs = new int[33]; - bestbbestcexceptmaxb = new byte[3]; + /** + * Compress data in blocks of BLOCK_SIZE integers (if fewer than BLOCK_SIZE integers + * are provided, nothing is done). + * + * @see IntegerCODEC#compress(int[], IntWrapper, int, int[], IntWrapper) + */ + @Override + public void headlessCompress(int[] in, IntWrapper inpos, int inlength, + int[] out, IntWrapper outpos) { + inlength = Util.greatestMultiple(inlength, BLOCK_SIZE); + // Allocate memory for working area. - final int finalinpos = inpos.get() + inlength; - while (inpos.get() != finalinpos) { - int thissize = Math.min(pageSize, finalinpos - inpos.get()); - encodePage(in, inpos, thissize, out, outpos); - } + final int finalinpos = inpos.get() + inlength; + while (inpos.get() != finalinpos) { + int thissize = Math.min(pageSize, + finalinpos - inpos.get()); + encodePage(in, inpos, thissize, out, outpos); + } - dataPointers = null; - freqs = null; - bestbbestcexceptmaxb = null; - } - private void getBestBFromData(int[] in, int pos) { - Arrays.fill(freqs, 0); - for (int k = pos, k_end = pos + BLOCK_SIZE; k < k_end; ++k) { - freqs[Util.bits(in[k])]++; } - bestbbestcexceptmaxb[0] = 32; - while (freqs[bestbbestcexceptmaxb[0]] == 0) - bestbbestcexceptmaxb[0]--; - bestbbestcexceptmaxb[2] = bestbbestcexceptmaxb[0]; - int bestcost = bestbbestcexceptmaxb[0] * BLOCK_SIZE; - byte cexcept = 0; - bestbbestcexceptmaxb[1] = cexcept; - for (int b = bestbbestcexceptmaxb[0] - 1; b >= 0; --b) { - cexcept += freqs[b + 1]; - if (cexcept < 0) - break; - // the extra 8 is the cost of storing maxbits - int thiscost = cexcept * OVERHEAD_OF_EACH_EXCEPT + cexcept - * (bestbbestcexceptmaxb[2] - b) + b * BLOCK_SIZE + 8; - if (thiscost < bestcost) { - bestcost = thiscost; - bestbbestcexceptmaxb[0] = (byte) b; + + private void getBestBFromData(int[] in, int pos) { + Arrays.fill(freqs, 0); + for (int k = pos, k_end = pos + BLOCK_SIZE; k < k_end; ++k) { + freqs[Util.bits(in[k])]++; + } + bestbbestcexceptmaxb[0] = 32; + while (freqs[bestbbestcexceptmaxb[0]] == 0) + bestbbestcexceptmaxb[0]--; + bestbbestcexceptmaxb[2] = bestbbestcexceptmaxb[0]; + int bestcost = bestbbestcexceptmaxb[0] * BLOCK_SIZE; + int cexcept = 0; bestbbestcexceptmaxb[1] = cexcept; - } + for (int b = bestbbestcexceptmaxb[0] - 1; b >= 0; --b) { + cexcept += freqs[b + 1]; + if (cexcept == BLOCK_SIZE) + break; + // the extra 8 is the cost of storing maxbits + int thiscost = cexcept * OVERHEAD_OF_EACH_EXCEPT + + cexcept * (bestbbestcexceptmaxb[2] - b) + b + * BLOCK_SIZE + 8; + if(bestbbestcexceptmaxb[2] - b == 1) thiscost -= cexcept; + if (thiscost < bestcost) { + bestcost = thiscost; + bestbbestcexceptmaxb[0] = b; + bestbbestcexceptmaxb[1] = cexcept; + } + } } - } - private void encodePage(int[] in, IntWrapper inpos, int thissize, - int[] out, IntWrapper outpos) { - final int headerpos = outpos.get(); - outpos.increment(); - int tmpoutpos = outpos.get(); + private void encodePage(int[] in, IntWrapper inpos, int thissize, + int[] out, IntWrapper outpos) { + final int headerpos = outpos.get(); + outpos.increment(); + int tmpoutpos = outpos.get(); + + // Clear working area. + Arrays.fill(dataPointers, 0); + byteContainer.clear(); - // Clear working area. - Arrays.fill(dataPointers, 0); - //Arrays.fill(bestbbestcexceptmaxb, (byte)0);//DL:unncessary - byteContainer.clear(); + int tmpinpos = inpos.get(); + for (final int finalinpos = tmpinpos + thissize - BLOCK_SIZE; tmpinpos <= finalinpos; tmpinpos += BLOCK_SIZE) { + getBestBFromData(in, tmpinpos); + final int tmpbestb = bestbbestcexceptmaxb[0]; + byteContainer.put((byte)bestbbestcexceptmaxb[0]); + byteContainer.put((byte)bestbbestcexceptmaxb[1]); + if (bestbbestcexceptmaxb[1] > 0) { + byteContainer.put((byte)bestbbestcexceptmaxb[2]); + final int index = bestbbestcexceptmaxb[2] + - bestbbestcexceptmaxb[0]; + if (dataPointers[index] + + bestbbestcexceptmaxb[1] >= dataTobePacked[index].length) { + int newsize = 2 * (dataPointers[index] + bestbbestcexceptmaxb[1]); + // make sure it is a multiple of 32 + newsize = Util + .greatestMultiple(newsize + 31, 32); + dataTobePacked[index] = Arrays.copyOf( + dataTobePacked[index], newsize); + } + for (int k = 0; k < BLOCK_SIZE; ++k) { + if ((in[k + tmpinpos] >>> bestbbestcexceptmaxb[0]) != 0) { + // we have an exception + byteContainer.put((byte) k); + dataTobePacked[index][dataPointers[index]++] = in[k + + tmpinpos] >>> tmpbestb; + } + } - int tmpinpos = inpos.get(); - for (final int finalinpos = tmpinpos + thissize - BLOCK_SIZE; tmpinpos <= finalinpos; tmpinpos += BLOCK_SIZE) { - getBestBFromData(in, tmpinpos); - final int tmpbestb = bestbbestcexceptmaxb[0]; - byteContainer.put(bestbbestcexceptmaxb[0]); - byteContainer.put(bestbbestcexceptmaxb[1]); - if (bestbbestcexceptmaxb[1] > 0) { - byteContainer.put(bestbbestcexceptmaxb[2]); - final int index = bestbbestcexceptmaxb[2] - - bestbbestcexceptmaxb[0]; - if (dataPointers[index] + bestbbestcexceptmaxb[1] >= dataTobePacked[index].length) { - int newsize = 2 * (dataPointers[index] + bestbbestcexceptmaxb[1]); - // make sure it is a multiple of 32 - newsize = Util.floorBy(newsize + 31, 32); - dataTobePacked[index] = Arrays.copyOf( - dataTobePacked[index], newsize); + } + for (int k = 0; k < BLOCK_SIZE; k += 32) { + BitPacking.fastpack(in, tmpinpos + k, out, + tmpoutpos, tmpbestb); + tmpoutpos += tmpbestb; + } } - for (int k = 0; k < BLOCK_SIZE; ++k) { - if ((in[k + tmpinpos] >>> bestbbestcexceptmaxb[0]) != 0) { - // we have an exception - byteContainer.put((byte) k); - dataTobePacked[index][dataPointers[index]++] = in[k - + tmpinpos] >>> tmpbestb; - } + inpos.set(tmpinpos); + out[headerpos] = tmpoutpos - headerpos; + final int bytesize = byteContainer.position(); + while ((byteContainer.position() & 3) != 0) + byteContainer.put((byte) 0); + out[tmpoutpos++] = bytesize; + final int howmanyints = byteContainer.position() / 4; + byteContainer.flip(); + byteContainer.asIntBuffer().get(out, tmpoutpos, howmanyints); + tmpoutpos += howmanyints; + int bitmap = 0; + for (int k = 2; k <= 32; ++k) { + if (dataPointers[k] != 0) + bitmap |= (1 << (k - 1)); } + out[tmpoutpos++] = bitmap; - } - for (int k = 0; k < 128; k += 32) { - BitPacking.fastpack(in, tmpinpos + k, out, tmpoutpos, tmpbestb); - tmpoutpos += tmpbestb; - } - } - inpos.set(tmpinpos); - out[headerpos] = tmpoutpos - headerpos; - while ((byteContainer.position() & 3) != 0) - byteContainer.put((byte) 0); - final int bytesize = byteContainer.position(); - out[tmpoutpos++] = bytesize; - final int howmanyints = bytesize / 4; - byteContainer.flip(); - byteContainer.asIntBuffer().get(out, tmpoutpos, howmanyints); - tmpoutpos += howmanyints; - int bitmap = 0; - for (int k = 1; k <= 32; ++k) { - if (dataPointers[k] != 0) - bitmap |= (1 << (k - 1)); - } - out[tmpoutpos++] = bitmap; - for (int k = 1; k <= 31; ++k) { - if (dataPointers[k] != 0) { - out[tmpoutpos++] = dataPointers[k];// size - for (int j = 0; j < dataPointers[k]; j += 32) { - BitPacking.fastpack(dataTobePacked[k], j, out, tmpoutpos, k); - tmpoutpos += k; + for (int k = 2; k <= 32; ++k) { + if (dataPointers[k] != 0) { + out[tmpoutpos++] = dataPointers[k];// size + int j = 0; + for (; j < dataPointers[k]; j += 32) { + BitPacking.fastpack(dataTobePacked[k], + j, out, tmpoutpos, k); + tmpoutpos += k; + } + int overflow = j - dataPointers[k]; + tmpoutpos -= overflow * k / 32; + } } - } + outpos.set(tmpoutpos); } - outpos.set(tmpoutpos); - } - /** - * Uncompress data in blocks of 128 integers. In this - * particular case, the inlength parameter is ignored: - * it is deduced from the compressed data. - * - * @see IntegerCODEC#compress(int[], IntWrapper, int, int[], IntWrapper) - */ - @Override - public void uncompress(int[] in, IntWrapper inpos, int inlength, int[] out, - IntWrapper outpos) { - if (inlength == 0) return; + /** + * Uncompress data in blocks of integers. In this particular case, + * the inlength parameter is ignored: it is deduced from the compressed + * data. + * + * @see IntegerCODEC#compress(int[], IntWrapper, int, int[], IntWrapper) + */ + @Override + public void headlessUncompress(int[] in, IntWrapper inpos, int inlength, + int[] out, IntWrapper outpos, int mynvalue) { + mynvalue = Util.greatestMultiple(mynvalue, BLOCK_SIZE); + int finalout = outpos.get() + mynvalue; + while (outpos.get() != finalout) { + int thissize = Math.min(pageSize, + finalout - outpos.get()); + decodePage(in, inpos, out, outpos, thissize); + } + } - int mynvalue = in[inpos.get()]; - inpos.increment(); + @Override + public int maxHeadlessCompressedLength(IntWrapper compressedPositions, int inlength) { + inlength = Util.greatestMultiple(inlength, BLOCK_SIZE); - dataPointers = new int[33]; + int pageCount = (inlength + pageSize - 1) / pageSize; + int blockCount = inlength / BLOCK_SIZE; - int finalout = outpos.get() + mynvalue; - while (outpos.get() != finalout) { - int thissize = Math.min(pageSize, finalout - outpos.get()); - decodePage(in, inpos, out, outpos, thissize); + // getBestBFromData limits the memory used for exceptions so that the total size of the block does not exceed BLOCK_SIZE integers. + int blockSizeInInts = OVERHEAD_OF_EACH_BLOCK_IN_INTS + BLOCK_SIZE; + return OVERHEAD_OF_EACH_PAGE_IN_INTS * pageCount + blockSizeInInts * blockCount + 24; } - dataPointers = null; - } - - private void decodePage(int[] in, IntWrapper inpos, int[] out, - IntWrapper outpos, int thissize) { - final int initpos = inpos.get(); - final int wheremeta = in[inpos.get()]; - inpos.increment(); - int inexcept = initpos + wheremeta; - final int bytesize = in[inexcept++]; - byteContainer.clear(); - byteContainer.asIntBuffer().put(in, inexcept, bytesize / 4); - inexcept += bytesize / 4; + private void decodePage(int[] in, IntWrapper inpos, int[] out, + IntWrapper outpos, int thissize) { + final int initpos = inpos.get(); + final int wheremeta = in[inpos.get()]; + inpos.increment(); + int inexcept = initpos + wheremeta; + final int bytesize = in[inexcept++]; + byteContainer.clear(); + byteContainer.asIntBuffer().put(in, inexcept, (bytesize + 3) / 4); + inexcept += (bytesize + 3)/ 4; - final int bitmap = in[inexcept++]; - for (int k = 1; k <= 31; ++k) { - if ((bitmap & (1 << (k - 1))) != 0) { - int size = in[inexcept++]; - if (dataTobePacked[k].length < size) - dataTobePacked[k] = new int[Util.floorBy(size + 31, 32)]; - for (int j = 0; j < size; j += 32) { - BitPacking - .fastunpack(in, inexcept, dataTobePacked[k], j, k); - inexcept += k; + final int bitmap = in[inexcept++]; + for (int k = 2; k <= 32; ++k) { + if ((bitmap & (1 << (k - 1))) != 0) { + int size = in[inexcept++]; + int roundedup = Util + .greatestMultiple(size + 31, 32); + if (dataTobePacked[k].length < roundedup) + dataTobePacked[k] = new int[roundedup]; + if(inexcept + roundedup/32*k <= in.length) { + int j = 0; + for (; j < size; j += 32) { + BitPacking.fastunpack(in, inexcept, + dataTobePacked[k], j, k); + inexcept += k; + } + int overflow = j - size; + inexcept -= overflow * k / 32; + } else { + int j = 0; + int[] buf = new int[roundedup/32*k]; + int initinexcept = inexcept; + System.arraycopy(in, inexcept, buf, 0, in.length - inexcept); + for (; j < size; j += 32) { + BitPacking.fastunpack(buf, inexcept-initinexcept, + dataTobePacked[k], j, k); + inexcept += k; + } + int overflow = j - size; + inexcept -= overflow * k / 32; + } + } } - } - } - Arrays.fill(dataPointers, 0); - int tmpoutpos = outpos.get(); - int tmpinpos = inpos.get(); + Arrays.fill(dataPointers, 0); + int tmpoutpos = outpos.get(); + int tmpinpos = inpos.get(); - for (int run = 0, run_end = thissize / BLOCK_SIZE; run < run_end; ++run, tmpoutpos += BLOCK_SIZE) { - final byte b = byteContainer.get(); - final byte cexcept = byteContainer.get(); - for (int k = 0; k < 128; k += 32) { - BitPacking.fastunpack(in, tmpinpos, out, tmpoutpos + k, b); - tmpinpos += b; - } - if (cexcept > 0) { - final byte maxbits = byteContainer.get(); - final int index = maxbits - b; - for (int k = 0; k < cexcept; ++k) { - final byte pos = byteContainer.get(); - final int exceptvalue = dataTobePacked[index][dataPointers[index]++]; - out[pos + tmpoutpos] |= exceptvalue << b; + for (int run = 0, run_end = thissize / BLOCK_SIZE; run < run_end; ++run, tmpoutpos += BLOCK_SIZE) { + final int b = byteContainer.get(); + final int cexcept = byteContainer.get() & 0xFF; + for (int k = 0; k < BLOCK_SIZE; k += 32) { + BitPacking.fastunpack(in, tmpinpos, out, + tmpoutpos + k, b); + tmpinpos += b; + } + if (cexcept > 0) { + final int maxbits = byteContainer.get(); + final int index = maxbits - b; + if(index == 1) { + for (int k = 0; k < cexcept; ++k) { + final int pos = byteContainer.get() &0xFF; + out[pos + tmpoutpos] |= 1 << b; + } + } else { + for (int k = 0; k < cexcept; ++k) { + final int pos = byteContainer.get() &0xFF; + final int exceptvalue = dataTobePacked[index][dataPointers[index]++]; + out[pos + tmpoutpos] |= exceptvalue << b; + } + } + } } + outpos.set(tmpoutpos); + inpos.set(inexcept); + } + @Override + public void compress(int[] in, IntWrapper inpos, int inlength, int[] out, + IntWrapper outpos) { + inlength = Util.greatestMultiple(inlength, BLOCK_SIZE); + if (inlength == 0) + return; + out[outpos.get()] = inlength; + outpos.increment(); + headlessCompress(in, inpos, inlength, out, outpos); + } - } + @Override + public void uncompress(int[] in, IntWrapper inpos, int inlength, int[] out, + IntWrapper outpos) { + if (inlength == 0) + return; + final int outlength = in[inpos.get()]; + inpos.increment(); + headlessUncompress(in, inpos, inlength, out, outpos, outlength); + } + @Override + public String toString() { + return this.getClass().getSimpleName(); } - outpos.set(tmpoutpos); - inpos.set(inexcept); - } - @Override - public String toString() { - return this.getClass().getSimpleName(); - } + /** + * Creates a new buffer of the requested size. + * + * In case you need a different way to allocate buffers, you can override this method + * with a custom behavior. The default implementation allocates a new Java direct + * {@link ByteBuffer} on each invocation. + * + * @param sizeInBytes + * @return + */ + protected ByteBuffer makeBuffer(int sizeInBytes) { + return ByteBuffer.allocateDirect(sizeInBytes); + } } diff --git a/src/main/java/me/lemire/integercompression/FastPFOR128.java b/src/main/java/me/lemire/integercompression/FastPFOR128.java new file mode 100644 index 0000000..0557c62 --- /dev/null +++ b/src/main/java/me/lemire/integercompression/FastPFOR128.java @@ -0,0 +1,346 @@ +/** + * This code is released under the + * Apache License Version 2.0 http://www.apache.org/licenses/. + * + * (c) Daniel Lemire, http://lemire.me/en/ + */ +package me.lemire.integercompression; + +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.util.Arrays; + +/** + * This class is similar to FastPFOR but uses a small block size. + * + * Note that this does not use differential coding: if you are working on sorted + * lists, you should first compute deltas, @see me.lemire.integercompression.differential.Delta#delta. + * + * For multi-threaded applications, each thread should use its own FastPFOR + * object. + * + * @author Daniel Lemire + */ +public class FastPFOR128 implements IntegerCODEC,SkippableIntegerCODEC { + final static int OVERHEAD_OF_EACH_EXCEPT = 8; + private static final int OVERHEAD_OF_EACH_PAGE_IN_INTS = 36; // 1 int for the header + // 1 int for the byte array size + // 1 int for the bitmap + // 1 int for byte array padding (to align to 4 bytes) + // 32 to have enough space to bit-pack the exceptions + private static final int OVERHEAD_OF_EACH_BLOCK_IN_INTS = 1; // 1 byte for the number of bits allocated per truncated integer + // 1 byte for the number of exceptions + /** + * + */ + public final static int DEFAULT_PAGE_SIZE = 65536; + /** + * + */ + public final static int BLOCK_SIZE = 128; + + final int pageSize; + final int[][] dataTobePacked = new int[33][]; + final ByteBuffer byteContainer; + + // Working area for compress and uncompress. + final int[] dataPointers = new int[33]; + final int[] freqs = new int[33]; + final int[] bestbbestcexceptmaxb = new int[3]; + + /** + * Construct the FastPFOR CODEC. + * + * @param pagesize + * the desired page size (recommended value is FastPFOR.DEFAULT_PAGE_SIZE) + */ + public FastPFOR128(int pagesize) { + pageSize = pagesize; + // Initiate arrrays. + byteContainer = makeBuffer(3 * pageSize + / BLOCK_SIZE + pageSize); + byteContainer.order(ByteOrder.LITTLE_ENDIAN); + for (int k = 1; k < dataTobePacked.length; ++k) + dataTobePacked[k] = new int[pageSize / 32 * 4]; // heuristic + } + /** + * Construct the fastPFOR CODEC with default parameters. + */ + public FastPFOR128() { + this(DEFAULT_PAGE_SIZE); + } + + /** + * Compress data in blocks of BLOCK_SIZE integers (if fewer than BLOCK_SIZE integers + * are provided, nothing is done). + * + * @see IntegerCODEC#compress(int[], IntWrapper, int, int[], IntWrapper) + */ + @Override + public void headlessCompress(int[] in, IntWrapper inpos, int inlength, + int[] out, IntWrapper outpos) { + inlength = Util.greatestMultiple(inlength, BLOCK_SIZE); + final int finalinpos = inpos.get() + inlength; + while (inpos.get() != finalinpos) { + int thissize = Math.min(pageSize, + finalinpos - inpos.get()); + encodePage(in, inpos, thissize, out, outpos); + } + } + + private void getBestBFromData(int[] in, int pos) { + Arrays.fill(freqs, 0); + for (int k = pos, k_end = pos + BLOCK_SIZE; k < k_end; ++k) { + freqs[Util.bits(in[k])]++; + } + bestbbestcexceptmaxb[0] = 32; + while (freqs[bestbbestcexceptmaxb[0]] == 0) + bestbbestcexceptmaxb[0]--; + bestbbestcexceptmaxb[2] = bestbbestcexceptmaxb[0]; + int bestcost = bestbbestcexceptmaxb[0] * BLOCK_SIZE; + int cexcept = 0; + bestbbestcexceptmaxb[1] = cexcept; + for (int b = bestbbestcexceptmaxb[0] - 1; b >= 0; --b) { + cexcept += freqs[b + 1]; + if (cexcept == BLOCK_SIZE) + break; + // the extra 8 is the cost of storing maxbits + int thiscost = cexcept * OVERHEAD_OF_EACH_EXCEPT + + cexcept * (bestbbestcexceptmaxb[2] - b) + b + * BLOCK_SIZE + 8; + if(bestbbestcexceptmaxb[2] - b == 1) thiscost -= cexcept; + if (thiscost < bestcost) { + bestcost = thiscost; + bestbbestcexceptmaxb[0] = b; + bestbbestcexceptmaxb[1] = cexcept; + } + } + } + + private void encodePage(int[] in, IntWrapper inpos, int thissize, + int[] out, IntWrapper outpos) { + final int headerpos = outpos.get(); + outpos.increment(); + int tmpoutpos = outpos.get(); + + // Clear working area. + Arrays.fill(dataPointers, 0); + byteContainer.clear(); + + int tmpinpos = inpos.get(); + for (final int finalinpos = tmpinpos + thissize - BLOCK_SIZE; tmpinpos <= finalinpos; tmpinpos += BLOCK_SIZE) { + getBestBFromData(in, tmpinpos); + final int tmpbestb = bestbbestcexceptmaxb[0]; + byteContainer.put((byte)bestbbestcexceptmaxb[0]); + byteContainer.put((byte)bestbbestcexceptmaxb[1]); + if (bestbbestcexceptmaxb[1] > 0) { + byteContainer.put((byte)bestbbestcexceptmaxb[2]); + final int index = bestbbestcexceptmaxb[2] + - bestbbestcexceptmaxb[0]; + if (dataPointers[index] + + bestbbestcexceptmaxb[1] >= dataTobePacked[index].length) { + int newsize = 2 * (dataPointers[index] + bestbbestcexceptmaxb[1]); + // make sure it is a multiple of 32 + newsize = Util + .greatestMultiple(newsize + 31, 32); + dataTobePacked[index] = Arrays.copyOf( + dataTobePacked[index], newsize); + } + for (int k = 0; k < BLOCK_SIZE; ++k) { + if ((in[k + tmpinpos] >>> bestbbestcexceptmaxb[0]) != 0) { + // we have an exception + byteContainer.put((byte) k); + dataTobePacked[index][dataPointers[index]++] = in[k + + tmpinpos] >>> tmpbestb; + } + } + + } + for (int k = 0; k < BLOCK_SIZE; k += 32) { + BitPacking.fastpack(in, tmpinpos + k, out, + tmpoutpos, tmpbestb); + tmpoutpos += tmpbestb; + } + } + inpos.set(tmpinpos); + out[headerpos] = tmpoutpos - headerpos; + final int bytesize = byteContainer.position(); + while ((byteContainer.position() & 3) != 0) + byteContainer.put((byte) 0); + out[tmpoutpos++] = bytesize; + final int howmanyints = byteContainer.position() / 4; + byteContainer.flip(); + byteContainer.asIntBuffer().get(out, tmpoutpos, howmanyints); + tmpoutpos += howmanyints; + int bitmap = 0; + for (int k = 2; k <= 32; ++k) { + if (dataPointers[k] != 0) + bitmap |= (1 << (k - 1)); + } + out[tmpoutpos++] = bitmap; + + for (int k = 2; k <= 32; ++k) { + if (dataPointers[k] != 0) { + out[tmpoutpos++] = dataPointers[k];// size + int j = 0; + for (; j < dataPointers[k]; j += 32) { + BitPacking.fastpack(dataTobePacked[k], + j, out, tmpoutpos, k); + tmpoutpos += k; + } + int overflow = j - dataPointers[k]; + tmpoutpos -= overflow * k / 32; + } + } + outpos.set(tmpoutpos); + } + + /** + * Uncompress data in blocks of integers. In this particular case, + * the inlength parameter is ignored: it is deduced from the compressed + * data. + * + * @see IntegerCODEC#compress(int[], IntWrapper, int, int[], IntWrapper) + */ + @Override + public void headlessUncompress(int[] in, IntWrapper inpos, int inlength, + int[] out, IntWrapper outpos, int mynvalue) { + if (inlength == 0) + return; + mynvalue = Util.greatestMultiple(mynvalue, BLOCK_SIZE); + int finalout = outpos.get() + mynvalue; + while (outpos.get() != finalout) { + int thissize = Math.min(pageSize, + finalout - outpos.get()); + decodePage(in, inpos, out, outpos, thissize); + } + } + + @Override + public int maxHeadlessCompressedLength(IntWrapper compressedPositions, int inlength) { + inlength = Util.greatestMultiple(inlength, BLOCK_SIZE); + + int pageCount = (inlength + pageSize - 1) / pageSize; + int blockCount = inlength / BLOCK_SIZE; + + // getBestBFromData limits the memory used for exceptions so that the total size of the block does not exceed BLOCK_SIZE integers. + int blockSizeInInts = OVERHEAD_OF_EACH_BLOCK_IN_INTS + BLOCK_SIZE; + return OVERHEAD_OF_EACH_PAGE_IN_INTS * pageCount + blockSizeInInts * blockCount + 24; + } + + private void decodePage(int[] in, IntWrapper inpos, int[] out, + IntWrapper outpos, int thissize) { + final int initpos = inpos.get(); + final int wheremeta = in[inpos.get()]; + inpos.increment(); + int inexcept = initpos + wheremeta; + final int bytesize = in[inexcept++]; + byteContainer.clear(); + byteContainer.asIntBuffer().put(in, inexcept, (bytesize + 3) / 4); + inexcept += (bytesize + 3)/ 4; + + final int bitmap = in[inexcept++]; + for (int k = 2; k <= 32; ++k) { + if ((bitmap & (1 << (k - 1))) != 0) { + int size = in[inexcept++]; + int roundedup = Util + .greatestMultiple(size + 31, 32); + if (dataTobePacked[k].length < roundedup) + dataTobePacked[k] = new int[roundedup]; + if(inexcept + roundedup/32*k <= in.length) { + int j = 0; + for (; j < size; j += 32) { + BitPacking.fastunpack(in, inexcept, + dataTobePacked[k], j, k); + inexcept += k; + } + int overflow = j - size; + inexcept -= overflow * k / 32; + } else { + int j = 0; + int[] buf = new int[roundedup/32*k]; + int initinexcept = inexcept; + System.arraycopy(in, inexcept, buf, 0, in.length - inexcept); + for (; j < size; j += 32) { + BitPacking.fastunpack(buf, inexcept-initinexcept, + dataTobePacked[k], j, k); + inexcept += k; + } + int overflow = j - size; + inexcept -= overflow * k / 32; + } + } + } + Arrays.fill(dataPointers, 0); + int tmpoutpos = outpos.get(); + int tmpinpos = inpos.get(); + + for (int run = 0, run_end = thissize / BLOCK_SIZE; run < run_end; ++run, tmpoutpos += BLOCK_SIZE) { + final int b = byteContainer.get(); + final int cexcept = byteContainer.get() & 0xFF; + for (int k = 0; k < BLOCK_SIZE; k += 32) { + BitPacking.fastunpack(in, tmpinpos, out, + tmpoutpos + k, b); + tmpinpos += b; + } + if (cexcept > 0) { + final int maxbits = byteContainer.get(); + final int index = maxbits - b; + if(index == 1) { + for (int k = 0; k < cexcept; ++k) { + final int pos = byteContainer.get() &0xFF; + out[pos + tmpoutpos] |= 1 << b; + } + } else { + for (int k = 0; k < cexcept; ++k) { + final int pos = byteContainer.get() &0xFF; + final int exceptvalue = dataTobePacked[index][dataPointers[index]++]; + out[pos + tmpoutpos] |= exceptvalue << b; + } + } + } + } + outpos.set(tmpoutpos); + inpos.set(inexcept); + } + + @Override + public void compress(int[] in, IntWrapper inpos, int inlength, int[] out, + IntWrapper outpos) { + inlength = Util.greatestMultiple(inlength, BLOCK_SIZE); + if (inlength == 0) + return; + out[outpos.get()] = inlength; + outpos.increment(); + headlessCompress(in, inpos, inlength, out, outpos); + } + + @Override + public void uncompress(int[] in, IntWrapper inpos, int inlength, int[] out, + IntWrapper outpos) { + if (inlength == 0) + return; + final int outlength = in[inpos.get()]; + inpos.increment(); + headlessUncompress(in, inpos, inlength, out, outpos, outlength); + } + + @Override + public String toString() { + return this.getClass().getSimpleName(); + } + + /** + * Creates a new buffer of the requested size. + * + * In case you need a different way to allocate buffers, you can override this method + * with a custom behavior. The default implementation allocates a new Java direct + * {@link ByteBuffer} on each invocation. + * + * @param sizeInBytes + * @return + */ + protected ByteBuffer makeBuffer(int sizeInBytes) { + return ByteBuffer.allocateDirect(sizeInBytes); + } +} diff --git a/src/main/java/me/lemire/integercompression/GroupSimple9.java b/src/main/java/me/lemire/integercompression/GroupSimple9.java new file mode 100644 index 0000000..bd8acfa --- /dev/null +++ b/src/main/java/me/lemire/integercompression/GroupSimple9.java @@ -0,0 +1,3558 @@ +package me.lemire.integercompression; + +/** + * Group Simple 9 is a variation on Simple 9 that preserves the same + * compression ratios but offers higher decoding speed by regrouping + * the 32-bit words into pairs of 64-bit words. + * + * original by Kun Jiang, Yuexiang Yang and Qinghua Zheng source: + * https://github.com/deeper2/simple + * + * Adapted by D. Lemire. + */ + +public final class GroupSimple9 implements IntegerCODEC, SkippableIntegerCODEC { + + private static final int[][] M = { { 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, 41, 42, 43, 44 }, { 45, 46, 47, 48, 49, 50, 51, 52, 53 }, + { 54, 55, 56, 57, 58, 59, 60, 61, 62 }, { 63, 64, 65, 66, 67, 68, 69, 70, 71 }, + { 72, 73, 74, 75, 76, 77, 78, 79, 80 } }; + + @Override + public void compress(int[] in, IntWrapper inpos, int inlength, int out[], IntWrapper outpos) { + if (inlength == 0) + return; + out[outpos.get()] = inlength; + outpos.increment(); + headlessCompress(in, inpos, inlength, out, outpos); + } + + private void encode0(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + for (int i = 0; i < 24; i++) + out[outf + 0] = (out[outf + 0] << 1) + (in[inf + i]); + for (int i = 0; i < 4; i++) + out[outf + 1] = (out[outf + 1] << 1) + in[inf + 24 + i]; + for (int i = 0; i < 28; i++) + out[outf + 1] = (out[outf + 1] << 1) + in[inf + 28 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode1(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + for (int i = 0; i < 24; i++) + out[outf + 0] = (out[outf + 0] << 1) + in[inf + i]; + for (int i = 0; i < 4; i++) + out[outf + 1] = (out[outf + 1] << 1) + in[inf + 24 + i]; + for (int i = 0; i < 14; i++) + out[outf + 1] = (out[outf + 1] << 2) + in[inf + 28 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode2(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + for (int i = 0; i < 24; i++) + out[outf + 0] = (out[outf + 0] << 1) + in[inf + i]; + for (int i = 0; i < 4; i++) + out[outf + 1] = (out[outf + 1] << 1) + in[inf + 24 + i]; + for (int i = 0; i < 9; i++) + out[outf + 1] = (out[outf + 1] << 3) + in[inf + 28 + i];// 第二个28位是低位存储的,所以浪费的1比特在最顶端。 + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode3(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + for (int i = 0; i < 24; i++) + out[outf + 0] = (out[outf + 0] << 1) + in[inf + i]; + for (int i = 0; i < 4; i++) + out[outf + 1] = (out[outf + 1] << 1) + in[inf + 24 + i]; + for (int i = 0; i < 7; i++) + out[outf + 1] = (out[outf + 1] << 4) + in[inf + 28 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode4(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + for (int i = 0; i < 24; i++) + out[outf + 0] = (out[outf + 0] << 1) + in[inf + i]; + for (int i = 0; i < 4; i++) + out[outf + 1] = (out[outf + 1] << 1) + in[inf + 24 + i]; + for (int i = 0; i < 5; i++) + out[outf + 1] = (out[outf + 1] << 5) + in[inf + 28 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode5(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + for (int i = 0; i < 24; i++) + out[outf + 0] = (out[outf + 0] << 1) + in[inf + i]; + for (int i = 0; i < 4; i++) + out[outf + 1] = (out[outf + 1] << 1) + in[inf + 24 + i]; + for (int i = 0; i < 4; i++) + out[outf + 1] = (out[outf + 1] << 7) + in[inf + 28 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode6(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + for (int i = 0; i < 24; i++) + out[outf + 0] = (out[outf + 0] << 1) + in[inf + i]; + for (int i = 0; i < 4; i++) + out[outf + 1] = (out[outf + 1] << 1) + in[inf + 24 + i]; + for (int i = 0; i < 3; i++) + out[outf + 1] = (out[outf + 1] << 9) + in[inf + 28 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode7(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + for (int i = 0; i < 24; i++) + out[outf + 0] = (out[outf + 0] << 1) + in[inf + i]; + for (int i = 0; i < 4; i++) + out[outf + 1] = (out[outf + 1] << 1) + in[inf + 24 + i]; + for (int i = 0; i < 2; i++) + out[outf + 1] = (out[outf + 1] << 14) + in[inf + 28 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode8(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + for (int i = 0; i < 24; i++) + out[outf + 0] = (out[outf + 0] << 1) + in[inf + i]; + for (int i = 0; i < 4; i++) + out[outf + 1] = (out[outf + 1] << 1) + in[inf + 24 + i]; + for (int i = 0; i < 1; i++) + out[outf + 1] = (out[outf + 1] << 28) + in[inf + 28 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode9(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + for (int i = 0; i < 12; i++) + out[outf + 0] = (out[outf + 0] << 2) + in[inf + i]; + for (int i = 0; i < 2; i++) + out[outf + 1] = (out[outf + 1] << 2) + in[inf + 12 + i]; + for (int i = 0; i < 28; i++) + out[outf + 1] = (out[outf + 1] << 1) + in[inf + 14 + i]; + + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode10(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + for (int i = 0; i < 12; i++) { + out[outf + 0] = (out[outf + 0] << 2) + in[inf + i]; + + } + for (int i = 0; i < 2; i++) + out[outf + 1] = (out[outf + 1] << 2) + in[inf + 12 + i]; + for (int i = 0; i < 14; i++) + out[outf + 1] = (out[outf + 1] << 2) + in[inf + 14 + i]; + + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode11(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + for (int i = 0; i < 12; i++) + out[outf + 0] = (out[outf + 0] << 2) + in[inf + i]; + for (int i = 0; i < 2; i++) + out[outf + 1] = (out[outf + 1] << 2) + in[inf + 12 + i]; + for (int i = 0; i < 9; i++) + out[outf + 1] = (out[outf + 1] << 3) + in[inf + 14 + i]; + + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode12(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + for (int i = 0; i < 12; i++) + out[outf + 0] = (out[outf + 0] << 2) + in[inf + i]; + for (int i = 0; i < 2; i++) + out[outf + 1] = (out[outf + 1] << 2) + in[inf + 12 + i]; + for (int i = 0; i < 7; i++) + out[outf + 1] = (out[outf + 1] << 4) + in[inf + 14 + i]; + + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode13(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + for (int i = 0; i < 12; i++) + out[outf + 0] = (out[outf + 0] << 2) + in[inf + i]; + for (int i = 0; i < 2; i++) + out[outf + 1] = (out[outf + 1] << 2) + in[inf + 12 + i]; + for (int i = 0; i < 5; i++) + out[outf + 1] = (out[outf + 1] << 5) + in[inf + 14 + i]; + + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode14(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + for (int i = 0; i < 12; i++) + out[outf + 0] = (out[outf + 0] << 2) + in[inf + i]; + for (int i = 0; i < 2; i++) + out[outf + 1] = (out[outf + 1] << 2) + in[inf + 12 + i]; + for (int i = 0; i < 4; i++) + out[outf + 1] = (out[outf + 1] << 7) + in[inf + 14 + i]; + + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode15(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + for (int i = 0; i < 12; i++) + out[outf + 0] = (out[outf + 0] << 2) + in[inf + i]; + for (int i = 0; i < 2; i++) + out[outf + 1] = (out[outf + 1] << 2) + in[inf + 12 + i]; + for (int i = 0; i < 3; i++) + out[outf + 1] = (out[outf + 1] << 9) + in[inf + 14 + i]; + + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode16(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + for (int i = 0; i < 12; i++) + out[outf + 0] = (out[outf + 0] << 2) + in[inf + i]; + for (int i = 0; i < 2; i++) + out[outf + 1] = (out[outf + 1] << 2) + in[inf + 12 + i]; + for (int i = 0; i < 2; i++) + out[outf + 1] = (out[outf + 1] << 14) + in[inf + 14 + i]; + + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode17(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + for (int i = 0; i < 12; i++) + out[outf + 0] = (out[outf + 0] << 2) + in[inf + i]; + for (int i = 0; i < 2; i++) + out[outf + 1] = (out[outf + 1] << 2) + in[inf + 12 + i]; + for (int i = 0; i < 1; i++) + out[outf + 1] = (out[outf + 1] << 28) + in[inf + 14 + i]; + + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode18(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + for (int i = 0; i < 8; i++) + out[outf + 0] = (out[outf + 0] << 3) + in[inf + i]; + for (int i = 0; i < 1; i++) + out[outf + 1] = (out[outf + 1] << 3) + in[inf + 8 + i]; + for (int i = 0; i < 28; i++) + out[outf + 1] = (out[outf + 1] << 1) + in[inf + 9 + i]; + + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode19(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + for (int i = 0; i < 8; i++) + out[outf + 0] = (out[outf + 0] << 3) + in[inf + i]; + for (int i = 0; i < 1; i++) + out[outf + 1] = (out[outf + 1] << 3) + in[inf + 8 + i]; + for (int i = 0; i < 14; i++) + out[outf + 1] = (out[outf + 1] << 2) + in[inf + 9 + i]; + + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode20(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + for (int i = 0; i < 8; i++) + out[outf + 0] = (out[outf + 0] << 3) + in[inf + i]; + for (int i = 0; i < 1; i++) + out[outf + 1] = (out[outf + 1] << 3) + in[inf + 8 + i]; + for (int i = 0; i < 9; i++) + out[outf + 1] = (out[outf + 1] << 3) + in[inf + 9 + i]; + + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode21(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + for (int i = 0; i < 8; i++) + out[outf + 0] = (out[outf + 0] << 3) + in[inf + i]; + for (int i = 0; i < 1; i++) + out[outf + 1] = (out[outf + 1] << 3) + in[inf + 8 + i]; + for (int i = 0; i < 7; i++) + out[outf + 1] = (out[outf + 1] << 4) + in[inf + 9 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode22(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + for (int i = 0; i < 8; i++) + out[outf + 0] = (out[outf + 0] << 3) + in[inf + i]; + for (int i = 0; i < 1; i++) + out[outf + 1] = (out[outf + 1] << 3) + in[inf + 8 + i]; + for (int i = 0; i < 5; i++) + out[outf + 1] = (out[outf + 1] << 5) + in[inf + 9 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode23(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + for (int i = 0; i < 8; i++) + out[outf + 0] = (out[outf + 0] << 3) + in[inf + i]; + for (int i = 0; i < 1; i++) + out[outf + 1] = (out[outf + 1] << 3) + in[inf + 8 + i]; + for (int i = 0; i < 4; i++) + out[outf + 1] = (out[outf + 1] << 7) + in[inf + 9 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode24(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + for (int i = 0; i < 8; i++) + out[outf + 0] = (out[outf + 0] << 3) + in[inf + i]; + for (int i = 0; i < 1; i++) + out[outf + 1] = (out[outf + 1] << 3) + in[inf + 8 + i]; + for (int i = 0; i < 3; i++) + out[outf + 1] = (out[outf + 1] << 9) + in[inf + 9 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode25(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + for (int i = 0; i < 8; i++) + out[outf + 0] = (out[outf + 0] << 3) + in[inf + i]; + for (int i = 0; i < 1; i++) + out[outf + 1] = (out[outf + 1] << 3) + in[inf + 8 + i]; + for (int i = 0; i < 2; i++) + out[outf + 1] = (out[outf + 1] << 14) + in[inf + 9 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode26(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + for (int i = 0; i < 8; i++) + out[outf + 0] = (out[outf + 0] << 3) + in[inf + i]; + for (int i = 0; i < 1; i++) + out[outf + 1] = (out[outf + 1] << 3) + in[inf + 8 + i]; + for (int i = 0; i < 1; i++) + out[outf + 1] = (out[outf + 1] << 28) + in[inf + 9 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode27(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + for (int i = 0; i < 6; i++) + out[outf + 0] = (out[outf + 0] << 4) + in[inf + i]; + for (int i = 0; i < 1; i++) + out[outf + 1] = (out[outf + 1] << 4) + in[inf + 6 + i]; + for (int i = 0; i < 28; i++) + out[outf + 1] = (out[outf + 1] << 1) + in[inf + 7 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode28(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + for (int i = 0; i < 6; i++) + out[outf + 0] = (out[outf + 0] << 4) + in[inf + i]; + for (int i = 0; i < 1; i++) + out[outf + 1] = (out[outf + 1] << 4) + in[inf + 6 + i]; + for (int i = 0; i < 14; i++) + out[outf + 1] = (out[outf + 1] << 2) + in[inf + 7 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode29(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + for (int i = 0; i < 6; i++) + out[outf + 0] = (out[outf + 0] << 4) + in[inf + i]; + for (int i = 0; i < 1; i++) + out[outf + 1] = (out[outf + 1] << 4) + in[inf + 6 + i]; + for (int i = 0; i < 9; i++) + out[outf + 1] = (out[outf + 1] << 3) + in[inf + 7 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode30(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + for (int i = 0; i < 6; i++) + out[outf + 0] = (out[outf + 0] << 4) + in[inf + i]; + for (int i = 0; i < 1; i++) + out[outf + 1] = (out[outf + 1] << 4) + in[inf + 6 + i]; + for (int i = 0; i < 7; i++) + out[outf + 1] = (out[outf + 1] << 4) + in[inf + 7 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode31(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + for (int i = 0; i < 6; i++) + out[outf + 0] = (out[outf + 0] << 4) + in[inf + i]; + for (int i = 0; i < 1; i++) + out[outf + 1] = (out[outf + 1] << 4) + in[inf + 6 + i]; + for (int i = 0; i < 5; i++) + out[outf + 1] = (out[outf + 1] << 5) + in[inf + 7 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode32(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + for (int i = 0; i < 6; i++) + out[outf + 0] = (out[outf + 0] << 4) + in[inf + i]; + for (int i = 0; i < 1; i++) + out[outf + 1] = (out[outf + 1] << 4) + in[inf + 6 + i]; + for (int i = 0; i < 4; i++) + out[outf + 1] = (out[outf + 1] << 7) + in[inf + 7 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode33(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + for (int i = 0; i < 6; i++) + out[outf + 0] = (out[outf + 0] << 4) + in[inf + i]; + for (int i = 0; i < 1; i++) + out[outf + 1] = (out[outf + 1] << 4) + in[inf + 6 + i]; + for (int i = 0; i < 3; i++) + out[outf + 1] = (out[outf + 1] << 9) + in[inf + 7 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode34(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + for (int i = 0; i < 6; i++) + out[outf + 0] = (out[outf + 0] << 4) + in[inf + i]; + for (int i = 0; i < 1; i++) + out[outf + 1] = (out[outf + 1] << 4) + in[inf + 6 + i]; + for (int i = 0; i < 2; i++) + out[outf + 1] = (out[outf + 1] << 14) + in[inf + 7 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode35(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + for (int i = 0; i < 6; i++) + out[outf + 0] = (out[outf + 0] << 4) + in[inf + i]; + for (int i = 0; i < 1; i++) + out[outf + 1] = (out[outf + 1] << 4) + in[inf + 6 + i]; + for (int i = 0; i < 1; i++) + out[outf + 1] = (out[outf + 1] << 28) + in[inf + 7 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode36(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + for (int i = 0; i < 4; i++) + out[outf + 0] = (out[outf + 0] << 5) + in[inf + i]; + out[outf + 0] = (out[outf + 0] << 4) + (in[inf + 4] >>> 1); + out[outf + 1] = (out[outf + 1] << 1) + ((in[inf + 4] << 31) >>> 31); + for (int i = 0; i < 28; i++) + out[outf + 1] = (out[outf + 1] << 1) + in[inf + 5 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode37(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + for (int i = 0; i < 4; i++) + out[outf + 0] = (out[outf + 0] << 5) + in[inf + i]; + out[outf + 0] = (out[outf + 0] << 4) + (in[inf + 4] >>> 1); + out[outf + 1] = (out[outf + 1] << 1) + ((in[inf + 4] << 31) >>> 31); + for (int i = 0; i < 14; i++) + out[outf + 1] = (out[outf + 1] << 2) + in[inf + 5 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode38(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + for (int i = 0; i < 4; i++) + out[outf + 0] = (out[outf + 0] << 5) + in[inf + i]; + out[outf + 0] = (out[outf + 0] << 4) + (in[inf + 4] >>> 1); + out[outf + 1] = (out[outf + 1] << 1) + ((in[inf + 4] << 31) >>> 31); + for (int i = 0; i < 9; i++) + out[outf + 1] = (out[outf + 1] << 3) + in[inf + 5 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode39(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + for (int i = 0; i < 4; i++) + out[outf + 0] = (out[outf + 0] << 5) + in[inf + i]; + out[outf + 0] = (out[outf + 0] << 4) + (in[inf + 4] >>> 1); + out[outf + 1] = (out[outf + 1] << 1) + ((in[inf + 4] << 31) >>> 31); + for (int i = 0; i < 7; i++) + out[outf + 1] = (out[outf + 1] << 4) + in[inf + 5 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode40(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + for (int i = 0; i < 4; i++) + out[outf + 0] = (out[outf + 0] << 5) + in[inf + i]; + out[outf + 0] = (out[outf + 0] << 4) + (in[inf + 4] >>> 1); + out[outf + 1] = (out[outf + 1] << 1) + ((in[inf + 4] << 31) >>> 31); + for (int i = 0; i < 5; i++) + out[outf + 1] = (out[outf + 1] << 5) + in[inf + 5 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode41(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + for (int i = 0; i < 4; i++) + out[outf + 0] = (out[outf + 0] << 5) + in[inf + i]; + out[outf + 0] = (out[outf + 0] << 4) + (in[inf + 4] >>> 1); + out[outf + 1] = (out[outf + 1] << 1) + ((in[inf + 4] << 31) >>> 31); + for (int i = 0; i < 4; i++) + out[outf + 1] = (out[outf + 1] << 7) + in[inf + 5 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode42(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + for (int i = 0; i < 4; i++) + out[outf + 0] = (out[outf + 0] << 5) + in[inf + i]; + out[outf + 0] = (out[outf + 0] << 4) + (in[inf + 4] >>> 1); + out[outf + 1] = (out[outf + 1] << 1) + ((in[inf + 4] << 31) >>> 31); + for (int i = 0; i < 3; i++) + out[outf + 1] = (out[outf + 1] << 9) + in[inf + 5 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode43(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + for (int i = 0; i < 4; i++) + out[outf + 0] = (out[outf + 0] << 5) + in[inf + i]; + out[outf + 0] = (out[outf + 0] << 4) + (in[inf + 4] >>> 1); + out[outf + 1] = (out[outf + 1] << 1) + ((in[inf + 4] << 31) >>> 31); + for (int i = 0; i < 2; i++) + out[outf + 1] = (out[outf + 1] << 14) + in[inf + 5 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode44(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + for (int i = 0; i < 4; i++) + out[outf + 0] = (out[outf + 0] << 5) + in[inf + i]; + out[outf + 0] = (out[outf + 0] << 4) + (in[inf + 4] >>> 1); + out[outf + 1] = (out[outf + 1] << 1) + ((in[inf + 4] << 31) >>> 31); + for (int i = 0; i < 1; i++) + out[outf + 1] = (out[outf + 1] << 28) + in[inf + 5 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode45(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + for (int i = 0; i < 3; i++) + out[outf + 0] = (out[outf + 0] << 7) + in[inf + i]; + out[outf + 0] = (out[outf + 0] << 3) + (in[inf + 3] >>> 4); + out[outf + 1] = (out[outf + 1] << 4) + ((in[inf + 3] << 28) >>> 28); + for (int i = 0; i < 28; i++) + out[outf + 1] = (out[outf + 1] << 1) + in[inf + 4 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode46(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + for (int i = 0; i < 3; i++) + out[outf + 0] = (out[outf + 0] << 7) + in[inf + i]; + out[outf + 0] = (out[outf + 0] << 3) + (in[inf + 3] >>> 4); + out[outf + 1] = (out[outf + 1] << 4) + ((in[inf + 3] << 28) >>> 28); + for (int i = 0; i < 14; i++) + out[outf + 1] = (out[outf + 1] << 2) + in[inf + 4 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode47(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + for (int i = 0; i < 3; i++) + out[outf + 0] = (out[outf + 0] << 7) + in[inf + i]; + out[outf + 0] = (out[outf + 0] << 3) + (in[inf + 3] >>> 4); + out[outf + 1] = (out[outf + 1] << 4) + ((in[inf + 3] << 28) >>> 28); + for (int i = 0; i < 9; i++) + out[outf + 1] = (out[outf + 1] << 3) + in[inf + 4 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode48(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + for (int i = 0; i < 3; i++) + out[outf + 0] = (out[outf + 0] << 7) + in[inf + i]; + out[outf + 0] = (out[outf + 0] << 3) + (in[inf + 3] >>> 4); + out[outf + 1] = (out[outf + 1] << 4) + ((in[inf + 3] << 28) >>> 28); + for (int i = 0; i < 7; i++) + out[outf + 1] = (out[outf + 1] << 4) + in[inf + 4 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode49(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + for (int i = 0; i < 3; i++) + out[outf + 0] = (out[outf + 0] << 7) + in[inf + i]; + out[outf + 0] = (out[outf + 0] << 3) + (in[inf + 3] >>> 4); + out[outf + 1] = (out[outf + 1] << 4) + ((in[inf + 3] << 28) >>> 28); + for (int i = 0; i < 5; i++) + out[outf + 1] = (out[outf + 1] << 5) + in[inf + 4 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode50(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + for (int i = 0; i < 3; i++) + out[outf + 0] = (out[outf + 0] << 7) + in[inf + i]; + out[outf + 0] = (out[outf + 0] << 3) + (in[inf + 3] >>> 4); + out[outf + 1] = (out[outf + 1] << 4) + ((in[inf + 3] << 28) >>> 28); + for (int i = 0; i < 4; i++) + out[outf + 1] = (out[outf + 1] << 7) + in[inf + 4 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode51(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + for (int i = 0; i < 3; i++) + out[outf + 0] = (out[outf + 0] << 7) + in[inf + i]; + out[outf + 0] = (out[outf + 0] << 3) + (in[inf + 3] >>> 4); + out[outf + 1] = (out[outf + 1] << 4) + ((in[inf + 3] << 28) >>> 28); + for (int i = 0; i < 3; i++) + out[outf + 1] = (out[outf + 1] << 9) + in[inf + 4 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode52(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + for (int i = 0; i < 3; i++) + out[outf + 0] = (out[outf + 0] << 7) + in[inf + i]; + out[outf + 0] = (out[outf + 0] << 3) + (in[inf + 3] >>> 4); + out[outf + 1] = (out[outf + 1] << 4) + ((in[inf + 3] << 28) >>> 28); + for (int i = 0; i < 2; i++) + out[outf + 1] = (out[outf + 1] << 14) + in[inf + 4 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode53(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + for (int i = 0; i < 3; i++) + out[outf + 0] = (out[outf + 0] << 7) + in[inf + i]; + out[outf + 0] = (out[outf + 0] << 3) + (in[inf + 3] >>> 4); + out[outf + 1] = (out[outf + 1] << 4) + ((in[inf + 3] << 28) >>> 28); + for (int i = 0; i < 1; i++) + out[outf + 1] = (out[outf + 1] << 28) + in[inf + 4 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode54(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + for (int i = 0; i < 2; i++) + out[outf + 0] = (out[outf + 0] << 9) + in[inf + i]; + out[outf + 0] = (out[outf + 0] << 6) + (in[inf + 2] >>> 3); + out[outf + 1] = (out[outf + 1] << 3) + ((in[inf + 2] << 29) >>> 29); + for (int i = 0; i < 28; i++) + out[outf + 1] = (out[outf + 1] << 1) + in[inf + 3 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode55(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + for (int i = 0; i < 2; i++) + out[outf + 0] = (out[outf + 0] << 9) + in[inf + i]; + out[outf + 0] = (out[outf + 0] << 6) + (in[inf + 2] >>> 3); + out[outf + 1] = (out[outf + 1] << 3) + ((in[inf + 2] << 29) >>> 29); + for (int i = 0; i < 14; i++) + out[outf + 1] = (out[outf + 1] << 2) + in[inf + 3 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode56(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + for (int i = 0; i < 2; i++) + out[outf + 0] = (out[outf + 0] << 9) + in[inf + i]; + out[outf + 0] = (out[outf + 0] << 6) + (in[inf + 2] >>> 3); + out[outf + 1] = (out[outf + 1] << 3) + ((in[inf + 2] << 29) >>> 29); + for (int i = 0; i < 9; i++) + out[outf + 1] = (out[outf + 1] << 3) + in[inf + 3 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode57(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + for (int i = 0; i < 2; i++) + out[outf + 0] = (out[outf + 0] << 9) + in[inf + i]; + out[outf + 0] = (out[outf + 0] << 6) + (in[inf + 2] >>> 3); + out[outf + 1] = (out[outf + 1] << 3) + ((in[inf + 2] << 29) >>> 29); + for (int i = 0; i < 7; i++) + out[outf + 1] = (out[outf + 1] << 4) + in[inf + 3 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode58(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + for (int i = 0; i < 2; i++) + out[outf + 0] = (out[outf + 0] << 9) + in[inf + i]; + out[outf + 0] = (out[outf + 0] << 6) + (in[inf + 2] >>> 3); + out[outf + 1] = (out[outf + 1] << 3) + ((in[inf + 2] << 29) >>> 29); + for (int i = 0; i < 5; i++) + out[outf + 1] = (out[outf + 1] << 5) + in[inf + 3 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode59(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + for (int i = 0; i < 2; i++) + out[outf + 0] = (out[outf + 0] << 9) + in[inf + i]; + out[outf + 0] = (out[outf + 0] << 6) + (in[inf + 2] >>> 3); + out[outf + 1] = (out[outf + 1] << 3) + ((in[inf + 2] << 29) >>> 29); + for (int i = 0; i < 4; i++) + out[outf + 1] = (out[outf + 1] << 7) + in[inf + 3 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode60(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + for (int i = 0; i < 2; i++) + out[outf + 0] = (out[outf + 0] << 9) + in[inf + i]; + out[outf + 0] = (out[outf + 0] << 6) + (in[inf + 2] >>> 3); + out[outf + 1] = (out[outf + 1] << 3) + ((in[inf + 2] << 29) >>> 29); + for (int i = 0; i < 3; i++) + out[outf + 1] = (out[outf + 1] << 9) + in[inf + 3 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode61(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + for (int i = 0; i < 2; i++) + out[outf + 0] = (out[outf + 0] << 9) + in[inf + i]; + out[outf + 0] = (out[outf + 0] << 6) + (in[inf + 2] >>> 3); + out[outf + 1] = (out[outf + 1] << 3) + ((in[inf + 2] << 29) >>> 29); + for (int i = 0; i < 2; i++) + out[outf + 1] = (out[outf + 1] << 14) + in[inf + 3 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode62(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + for (int i = 0; i < 2; i++) + out[outf + 0] = (out[outf + 0] << 9) + in[inf + i]; + out[outf + 0] = (out[outf + 0] << 6) + (in[inf + 2] >>> 3); + out[outf + 1] = (out[outf + 1] << 3) + ((in[inf + 2] << 29) >>> 29); + for (int i = 0; i < 1; i++) + out[outf + 1] = (out[outf + 1] << 28) + in[inf + 3 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode63(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + + out[outf + 0] = (out[outf + 0] << 14) + in[inf]; + out[outf + 0] = (out[outf + 0] << 10) + (in[inf + 1] >>> 4); + out[outf + 1] = (out[outf + 1] << 4) + ((in[inf + 1] << 28) >>> 28); + for (int i = 0; i < 28; i++) + out[outf + 1] = (out[outf + 1] << 1) + in[inf + 2 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode64(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + out[outf + 0] = (out[outf + 0] << 14) + in[inf]; + out[outf + 0] = (out[outf + 0] << 10) + (in[inf + 1] >>> 4); + out[outf + 1] = (out[outf + 1] << 4) + ((in[inf + 1] << 28) >>> 28); + for (int i = 0; i < 14; i++) + out[outf + 1] = (out[outf + 1] << 2) + in[inf + 2 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode65(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + out[outf + 0] = (out[outf + 0] << 14) + in[inf]; + out[outf + 0] = (out[outf + 0] << 10) + (in[inf + 1] >>> 4); + out[outf + 1] = (out[outf + 1] << 4) + ((in[inf + 1] << 28) >>> 28); + for (int i = 0; i < 9; i++) + out[outf + 1] = (out[outf + 1] << 3) + in[inf + 2 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode66(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + out[outf + 0] = (out[outf + 0] << 14) + in[inf]; + out[outf + 0] = (out[outf + 0] << 10) + (in[inf + 1] >>> 4); + out[outf + 1] = (out[outf + 1] << 4) + ((in[inf + 1] << 28) >>> 28); + for (int i = 0; i < 7; i++) + out[outf + 1] = (out[outf + 1] << 4) + in[inf + 2 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode67(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + out[outf + 0] = (out[outf + 0] << 14) + in[inf]; + out[outf + 0] = (out[outf + 0] << 10) + (in[inf + 1] >>> 4); + out[outf + 1] = (out[outf + 1] << 4) + ((in[inf + 1] << 28) >>> 28); + for (int i = 0; i < 5; i++) + out[outf + 1] = (out[outf + 1] << 5) + in[inf + 2 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode68(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + out[outf + 0] = (out[outf + 0] << 14) + in[inf]; + out[outf + 0] = (out[outf + 0] << 10) + (in[inf + 1] >>> 4); + out[outf + 1] = (out[outf + 1] << 4) + ((in[inf + 1] << 28) >>> 28); + for (int i = 0; i < 4; i++) + out[outf + 1] = (out[outf + 1] << 7) + in[inf + 2 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode69(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + out[outf + 0] = (out[outf + 0] << 14) + in[inf]; + out[outf + 0] = (out[outf + 0] << 10) + (in[inf + 1] >>> 4); + out[outf + 1] = (out[outf + 1] << 4) + ((in[inf + 1] << 28) >>> 28); + for (int i = 0; i < 3; i++) + out[outf + 1] = (out[outf + 1] << 9) + in[inf + 2 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode70(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + out[outf + 0] = (out[outf + 0] << 14) + in[inf]; + out[outf + 0] = (out[outf + 0] << 10) + (in[inf + 1] >>> 4); + out[outf + 1] = (out[outf + 1] << 4) + ((in[inf + 1] << 28) >>> 28); + for (int i = 0; i < 2; i++) + out[outf + 1] = (out[outf + 1] << 14) + in[inf + 2 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode71(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + out[outf + 0] = (out[outf + 0] << 14) + in[inf]; + out[outf + 0] = (out[outf + 0] << 10) + (in[inf + 1] >>> 4); + out[outf + 1] = (out[outf + 1] << 4) + ((in[inf + 1] << 28) >>> 28); + for (int i = 0; i < 1; i++) + out[outf + 1] = (out[outf + 1] << 28) + in[inf + 2 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode72(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + + out[outf + 0] = (out[outf + 0] << 24) + (in[inf] >>> 4); + out[outf + 1] = (out[outf + 1] << 4) + ((in[inf] << 28) >>> 28); + for (int i = 0; i < 28; i++) + out[outf + 1] = (out[outf + 1] << 1) + in[inf + 1 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode73(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + out[outf + 0] = (out[outf + 0] << 24) + (in[inf] >>> 4); + out[outf + 1] = (out[outf + 1] << 4) + ((in[inf] << 28) >>> 28); + for (int i = 0; i < 14; i++) + out[outf + 1] = (out[outf + 1] << 2) + in[inf + 1 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode74(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + out[outf + 0] = (out[outf + 0] << 24) + (in[inf] >>> 4); + out[outf + 1] = (out[outf + 1] << 4) + ((in[inf] << 28) >>> 28); + for (int i = 0; i < 9; i++) + out[outf + 1] = (out[outf + 1] << 3) + in[inf + 1 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode75(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + out[outf + 0] = (out[outf + 0] << 24) + (in[inf] >>> 4); + out[outf + 1] = (out[outf + 1] << 4) + ((in[inf] << 28) >>> 28); + for (int i = 0; i < 7; i++) + out[outf + 1] = (out[outf + 1] << 4) + in[inf + 1 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode76(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + out[outf + 0] = (out[outf + 0] << 24) + (in[inf] >>> 4); + out[outf + 1] = (out[outf + 1] << 4) + ((in[inf] << 28) >>> 28); + for (int i = 0; i < 5; i++) + out[outf + 1] = (out[outf + 1] << 5) + in[inf + 1 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode77(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + out[outf + 0] = (out[outf + 0] << 24) + (in[inf] >>> 4); + out[outf + 1] = (out[outf + 1] << 4) + ((in[inf] << 28) >>> 28); + for (int i = 0; i < 4; i++) + out[outf + 1] = (out[outf + 1] << 7) + in[inf + 1 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode78(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + out[outf + 0] = (out[outf + 0] << 24) + (in[inf] >>> 4); + out[outf + 1] = (out[outf + 1] << 4) + ((in[inf] << 28) >>> 28); + for (int i = 0; i < 3; i++) + out[outf + 1] = (out[outf + 1] << 9) + in[inf + 1 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode79(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + out[outf + 0] = (out[outf + 0] << 24) + (in[inf] >>> 4); + out[outf + 1] = (out[outf + 1] << 4) + ((in[inf] << 28) >>> 28); + for (int i = 0; i < 2; i++) + out[outf + 1] = (out[outf + 1] << 14) + in[inf + 1 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + private void encode80(final int[] in, final int inf, final int code, final int[] out, + final int outf) { + out[outf + 0] = (out[outf + 0] << 24) + (in[inf] >>> 4); + out[outf + 1] = (out[outf + 1] << 4) + ((in[inf] << 28) >>> 28); + for (int i = 0; i < 1; i++) + out[outf + 1] = (out[outf + 1] << 28) + in[inf + 1 + i]; + out[outf + 0] = code << 24 | out[outf + 0]; + + } + + @Override + public void uncompress(int[] in, IntWrapper inpos, int inlength, int[] out, IntWrapper outpos) { + if (inlength == 0) + return; + final int outlength = in[inpos.get()]; + inpos.increment(); + headlessUncompress(in, inpos, inlength, out, outpos, outlength); + } + + + + private void decode80(int val, int valn, int[] out, int currentPos) { + // number : 1, bitwidth : 28 + out[currentPos++] = (val << 8) >>> 4 | (valn >>> 28); + // number : 1, bitwidth : 28 + out[currentPos++] = (valn << 4) >>> 4; + } + + private void decode79(int val, int valn, int[] out, int currentPos) { + // number : 1, bitwidth : 28 + out[currentPos++] = (val << 8) >>> 4 | (valn >>> 28); + // number :2, bitwidth : 14 + out[currentPos++] = (valn << 4) >>> 18; + out[currentPos++] = (valn << 18) >>> 18; + } + + private void decode78(int val, int valn, int[] out, int currentPos) { + // number : 1, bitwidth : 28 + out[currentPos++] = (val << 8) >>> 4 | (valn >>> 27); + // number : 3, bitwidth :9 + out[currentPos++] = (valn << 5) >>> 23; + out[currentPos++] = (valn << 14) >>> 23; + out[currentPos++] = (valn << 23) >>> 23; + } + + private void decode77(int val, int valn, int[] out, int currentPos) { + // number : 1, bitwidth : 28 + out[currentPos++] = (val << 8) >>> 4 | (valn >>> 28); + // number : 4, bitwidth : 7 + out[currentPos++] = (valn << 4) >>> 25; + out[currentPos++] = (valn << 11) >>> 25; + out[currentPos++] = (valn << 18) >>> 25; + out[currentPos++] = (valn << 25) >>> 25; + } + + private void decode76(int val, int valn, int[] out, int currentPos) { + // number : 5, bitwidth : 5 + out[currentPos++] = (val << 8) >>> 4 | (valn >>> 25); + // number : 14, bitwidth : 2 + out[currentPos++] = (valn << 7) >>> 27; + out[currentPos++] = (valn << 12) >>> 27; + out[currentPos++] = (valn << 17) >>> 27; + out[currentPos++] = (valn << 22) >>> 27; + out[currentPos++] = (valn << 27) >>> 27; + } + + private void decode75(int val, int valn, int[] out, int currentPos) { + // number : 1, bitwidth : 28 + out[currentPos++] = (val << 8) >>> 4 | (valn >>> 28); + // number : 7, bitwidth : 4 + out[currentPos++] = (valn << 4) >>> 28; + out[currentPos++] = (valn << 8) >>> 28; + out[currentPos++] = (valn << 12) >>> 28; + out[currentPos++] = (valn << 16) >>> 28; + out[currentPos++] = (valn << 20) >>> 28; + out[currentPos++] = (valn << 24) >>> 28; + out[currentPos++] = (valn << 28) >>> 28; + } + + private void decode74(int val, int valn, int[] out, int currentPos) { + // number : 1, bitwidth : 28 + out[currentPos++] = (val << 8) >>> 4 | (valn >>> 27); + // number : 9, bitwidth : 3 + out[currentPos++] = (valn << 5) >>> 29; + out[currentPos++] = (valn << 8) >>> 29; + out[currentPos++] = (valn << 11) >>> 29; + out[currentPos++] = (valn << 14) >>> 29; + out[currentPos++] = (valn << 17) >>> 29; + out[currentPos++] = (valn << 20) >>> 29; + out[currentPos++] = (valn << 23) >>> 29; + out[currentPos++] = (valn << 26) >>> 29; + out[currentPos++] = (valn << 29) >>> 29; + } + + private void decode73(int val, int valn, int[] out, int currentPos) { + // number : 1, bitwidth : 28 + out[currentPos++] = (val << 8) >>> 4 | (valn >>> 28); + // number : 14, bitwidth : 2 + out[currentPos++] = (valn << 4) >>> 30; + out[currentPos++] = (valn << 6) >>> 30; + out[currentPos++] = (valn << 8) >>> 30; + out[currentPos++] = (valn << 10) >>> 30; + out[currentPos++] = (valn << 12) >>> 30; + out[currentPos++] = (valn << 14) >>> 30; + out[currentPos++] = (valn << 16) >>> 30; + out[currentPos++] = (valn << 18) >>> 30; + out[currentPos++] = (valn << 20) >>> 30; + out[currentPos++] = (valn << 22) >>> 30; // 10 + out[currentPos++] = (valn << 24) >>> 30; + out[currentPos++] = (valn << 26) >>> 30; + out[currentPos++] = (valn << 28) >>> 30; + out[currentPos++] = (valn << 30) >>> 30; + } + + private void decode72(int val, int valn, int[] out, int currentPos) { + // number : 1, bitwidth : 28 + out[currentPos++] = (val << 8) >>> 4 | (valn >>> 28); + // number : 28, bitwidth : 1 + out[currentPos++] = (valn << 4) >>> 31; + out[currentPos++] = (valn << 5) >>> 31; + out[currentPos++] = (valn << 6) >>> 31; + out[currentPos++] = (valn << 7) >>> 31; + out[currentPos++] = (valn << 8) >>> 31; + out[currentPos++] = (valn << 9) >>> 31; + out[currentPos++] = (valn << 10) >>> 31; + out[currentPos++] = (valn << 11) >>> 31; + out[currentPos++] = (valn << 12) >>> 31; + out[currentPos++] = (valn << 13) >>> 31; // 10 + out[currentPos++] = (valn << 14) >>> 31; + out[currentPos++] = (valn << 15) >>> 31; + out[currentPos++] = (valn << 16) >>> 31; + out[currentPos++] = (valn << 17) >>> 31; + out[currentPos++] = (valn << 18) >>> 31; + out[currentPos++] = (valn << 19) >>> 31; + out[currentPos++] = (valn << 20) >>> 31; + out[currentPos++] = (valn << 21) >>> 31; + out[currentPos++] = (valn << 22) >>> 31; + out[currentPos++] = (valn << 23) >>> 31; // 20 + out[currentPos++] = (valn << 24) >>> 31; + out[currentPos++] = (valn << 25) >>> 31; + out[currentPos++] = (valn << 26) >>> 31; + out[currentPos++] = (valn << 27) >>> 31; + out[currentPos++] = (valn << 28) >>> 31; + out[currentPos++] = (valn << 29) >>> 31; + out[currentPos++] = (valn << 30) >>> 31; + out[currentPos++] = (valn << 31) >>> 31; + } + + private void decode71(int val, int valn, int[] out, int currentPos) { + // number : 2, bitwidth : 14 + out[currentPos++] = (val << 8) >>> 18; + out[currentPos++] = (val << 22) >>> 18 | (valn >>> 28); + // number : 1, bitwidth : 28 + out[currentPos++] = (valn << 4) >>> 4; + } + + private void decode70(int val, int valn, int[] out, int currentPos) { + // number : 2, bitwidth : 14 + out[currentPos++] = (val << 8) >>> 18; + out[currentPos++] = (val << 22) >>> 18 | (valn >>> 28); + // number : 2, bitwidth : 14 + out[currentPos++] = (valn << 4) >>> 18; + out[currentPos++] = (valn << 18) >>> 18; + } + + private void decode69(int val, int valn, int[] out, int currentPos) { + // number : 2, bitwidth : 14 + out[currentPos++] = (val << 8) >>> 18; + out[currentPos++] = (val << 22) >>> 18 | (valn >>> 27); + // number : 3, bitwidth : 9 + out[currentPos++] = (valn << 5) >>> 23; + out[currentPos++] = (valn << 14) >>> 23; + out[currentPos++] = (valn << 23) >>> 23; + } + + private void decode68(int val, int valn, int[] out, int currentPos) { + // number : 2, bitwidth : 14 + out[currentPos++] = (val << 8) >>> 18; + out[currentPos++] = (val << 22) >>> 18 | (valn >>> 28); + // number : 4, bitwidth : 7 + out[currentPos++] = (valn << 4) >>> 25; + out[currentPos++] = (valn << 11) >>> 25; + out[currentPos++] = (valn << 18) >>> 25; + out[currentPos++] = (valn << 25) >>> 25; + } + + private void decode67(int val, int valn, int[] out, int currentPos) { + // number : 2, bitwidth : 14 + out[currentPos++] = (val << 8) >>> 18; + out[currentPos++] = (val << 22) >>> 18 | (valn >>> 25); + // number : 5, bitwidth : 5 + out[currentPos++] = (valn << 7) >>> 27; + out[currentPos++] = (valn << 12) >>> 27; + out[currentPos++] = (valn << 17) >>> 27; + out[currentPos++] = (valn << 22) >>> 27; + out[currentPos++] = (valn << 27) >>> 27; + } + + private void decode66(int val, int valn, int[] out, int currentPos) { + // number : 2, bitwidth : 14 + out[currentPos++] = (val << 8) >>> 18; + out[currentPos++] = (val << 22) >>> 18 | (valn >>> 28); + // number : 7, bitwidth : 4 + out[currentPos++] = (valn << 4) >>> 28; + out[currentPos++] = (valn << 8) >>> 28; + out[currentPos++] = (valn << 12) >>> 28; + out[currentPos++] = (valn << 16) >>> 28; + out[currentPos++] = (valn << 20) >>> 28; + out[currentPos++] = (valn << 24) >>> 28; + out[currentPos++] = (valn << 28) >>> 28; + } + + private void decode65(int val, int valn, int[] out, int currentPos) { + // number : 2, bitwidth : 14 + out[currentPos++] = (val << 8) >>> 18; + out[currentPos++] = (val << 22) >>> 18 | (valn >>> 27); + // number : 9, bitwidth : 3 + out[currentPos++] = (valn << 5) >>> 29; + out[currentPos++] = (valn << 8) >>> 29; + out[currentPos++] = (valn << 11) >>> 29; + out[currentPos++] = (valn << 14) >>> 29; + out[currentPos++] = (valn << 17) >>> 29; + out[currentPos++] = (valn << 20) >>> 29; + out[currentPos++] = (valn << 23) >>> 29; + out[currentPos++] = (valn << 26) >>> 29; + out[currentPos++] = (valn << 29) >>> 29; + } + + private void decode64(int val, int valn, int[] out, int currentPos) { + // number : 2, bitwidth : 14 + out[currentPos++] = (val << 8) >>> 18; + out[currentPos++] = (val << 22) >>> 18 | (valn >>> 28); + // number : 14, bitwidth : 2 + out[currentPos++] = (valn << 4) >>> 30; + out[currentPos++] = (valn << 6) >>> 30; + out[currentPos++] = (valn << 8) >>> 30; + out[currentPos++] = (valn << 10) >>> 30; + out[currentPos++] = (valn << 12) >>> 30; + out[currentPos++] = (valn << 14) >>> 30; + out[currentPos++] = (valn << 16) >>> 30; + out[currentPos++] = (valn << 18) >>> 30; + out[currentPos++] = (valn << 20) >>> 30; + out[currentPos++] = (valn << 22) >>> 30; // 10 + out[currentPos++] = (valn << 24) >>> 30; + out[currentPos++] = (valn << 26) >>> 30; + out[currentPos++] = (valn << 28) >>> 30; + out[currentPos++] = (valn << 30) >>> 30; + } + + private void decode63(int val, int valn, int[] out, int currentPos) { + // number : 2, bitwidth : 14 + out[currentPos++] = (val << 8) >>> 18; + out[currentPos++] = (val << 22) >>> 18 | (valn >>> 28); + // number : 28, bitwidth : 1 + out[currentPos++] = (valn << 4) >>> 31; + out[currentPos++] = (valn << 5) >>> 31; + out[currentPos++] = (valn << 6) >>> 31; + out[currentPos++] = (valn << 7) >>> 31; + out[currentPos++] = (valn << 8) >>> 31; + out[currentPos++] = (valn << 9) >>> 31; + out[currentPos++] = (valn << 10) >>> 31; + out[currentPos++] = (valn << 11) >>> 31; + out[currentPos++] = (valn << 12) >>> 31; + out[currentPos++] = (valn << 13) >>> 31; // 10 + out[currentPos++] = (valn << 14) >>> 31; + out[currentPos++] = (valn << 15) >>> 31; + out[currentPos++] = (valn << 16) >>> 31; + out[currentPos++] = (valn << 17) >>> 31; + out[currentPos++] = (valn << 18) >>> 31; + out[currentPos++] = (valn << 19) >>> 31; + out[currentPos++] = (valn << 20) >>> 31; + out[currentPos++] = (valn << 21) >>> 31; + out[currentPos++] = (valn << 22) >>> 31; + out[currentPos++] = (valn << 23) >>> 31; // 20 + out[currentPos++] = (valn << 24) >>> 31; + out[currentPos++] = (valn << 25) >>> 31; + out[currentPos++] = (valn << 26) >>> 31; + out[currentPos++] = (valn << 27) >>> 31; + out[currentPos++] = (valn << 28) >>> 31; + out[currentPos++] = (valn << 29) >>> 31; + out[currentPos++] = (valn << 30) >>> 31; + out[currentPos++] = (valn << 31) >>> 31; + } + + private void decode62(int val, int valn, int[] out, int currentPos) { + // number : 3, bitwidth : 9 + out[currentPos++] = (val << 8) >>> 23; + out[currentPos++] = (val << 17) >>> 23; + out[currentPos++] = (val << 26) >>> 23 | (valn >>> 28); + // number : 1, bitwidth : 28 + out[currentPos++] = (valn << 4) >>> 4; + } + + private void decode61(int val, int valn, int[] out, int currentPos) { + // number : 3, bitwidth : 9 + out[currentPos++] = (val << 8) >>> 23; + out[currentPos++] = (val << 17) >>> 23; + out[currentPos++] = (val << 26) >>> 23 | (valn >>> 28); + // number : 2, bitwidth : 14 + out[currentPos++] = (valn << 4) >>> 18; + out[currentPos++] = (valn << 18) >>> 18; + } + + private void decode60(int val, int valn, int[] out, int currentPos) { + // number : 3, bitwidth : 9 + out[currentPos++] = (val << 8) >>> 23; + out[currentPos++] = (val << 17) >>> 23; + out[currentPos++] = (val << 26) >>> 23 | (valn >>> 27); + // number : 3, bitwidth : 9 + out[currentPos++] = (valn << 5) >>> 23; + out[currentPos++] = (valn << 14) >>> 23; + out[currentPos++] = (valn << 23) >>> 23; + } + + private void decode59(int val, int valn, int[] out, int currentPos) { + // number : 3, bitwidth : 9 + out[currentPos++] = (val << 8) >>> 23; + out[currentPos++] = (val << 17) >>> 23; + out[currentPos++] = (val << 26) >>> 23 | (valn >>> 28); + // number : 4, bitwidth : 7 + out[currentPos++] = (valn << 4) >>> 25; + out[currentPos++] = (valn << 11) >>> 25; + out[currentPos++] = (valn << 18) >>> 25; + out[currentPos++] = (valn << 25) >>> 25; + } + + private void decode58(int val, int valn, int[] out, int currentPos) { + // number : 3, bitwidth : 9 + out[currentPos++] = (val << 8) >>> 23; + out[currentPos++] = (val << 17) >>> 23; + out[currentPos++] = (val << 26) >>> 23 | (valn >>> 25); + // number : 5, bitwidth : 5 + out[currentPos++] = (valn << 7) >>> 27; + out[currentPos++] = (valn << 12) >>> 27; + out[currentPos++] = (valn << 17) >>> 27; + out[currentPos++] = (valn << 22) >>> 27; + out[currentPos++] = (valn << 27) >>> 27; + } + + private void decode57(int val, int valn, int[] out, int currentPos) { + // number : 3, bitwidth : 9 + out[currentPos++] = (val << 8) >>> 23; + out[currentPos++] = (val << 17) >>> 23; + out[currentPos++] = (val << 26) >>> 23 | (valn >>> 28); + // number : 7, bitwidth : 4 + out[currentPos++] = (valn << 4) >>> 28; + out[currentPos++] = (valn << 8) >>> 28; + out[currentPos++] = (valn << 12) >>> 28; + out[currentPos++] = (valn << 16) >>> 28; + out[currentPos++] = (valn << 20) >>> 28; + out[currentPos++] = (valn << 24) >>> 28; + out[currentPos++] = (valn << 28) >>> 28; + } + + private void decode56(int val, int valn, int[] out, int currentPos) { + // number : 3, bitwidth : 9 + out[currentPos++] = (val << 8) >>> 23; + out[currentPos++] = (val << 17) >>> 23; + out[currentPos++] = (val << 26) >>> 23 | (valn >>> 27); + // number : 9, bitwidth : 3 + out[currentPos++] = (valn << 5) >>> 29; + out[currentPos++] = (valn << 8) >>> 29; + out[currentPos++] = (valn << 11) >>> 29; + out[currentPos++] = (valn << 14) >>> 29; + out[currentPos++] = (valn << 17) >>> 29; + out[currentPos++] = (valn << 20) >>> 29; + out[currentPos++] = (valn << 23) >>> 29; + out[currentPos++] = (valn << 26) >>> 29; + out[currentPos++] = (valn << 29) >>> 29; + } + + private void decode55(int val, int valn, int[] out, int currentPos) { + // number : 3, bitwidth : 9 + out[currentPos++] = (val << 8) >>> 23; + out[currentPos++] = (val << 17) >>> 23; + out[currentPos++] = (val << 26) >>> 23 | (valn >>> 28); + // number : 14, bitwidth : 2 + out[currentPos++] = (valn << 4) >>> 30; + out[currentPos++] = (valn << 6) >>> 30; + out[currentPos++] = (valn << 8) >>> 30; + out[currentPos++] = (valn << 10) >>> 30; + out[currentPos++] = (valn << 12) >>> 30; + out[currentPos++] = (valn << 14) >>> 30; + out[currentPos++] = (valn << 16) >>> 30; + out[currentPos++] = (valn << 18) >>> 30; + out[currentPos++] = (valn << 20) >>> 30; + out[currentPos++] = (valn << 22) >>> 30; // 10 + out[currentPos++] = (valn << 24) >>> 30; + out[currentPos++] = (valn << 26) >>> 30; + out[currentPos++] = (valn << 28) >>> 30; + out[currentPos++] = (valn << 30) >>> 30; + } + + private void decode54(int val, int valn, int[] out, int currentPos) { + // number : 3, bitwidth : 9 + out[currentPos++] = (val << 8) >>> 23; + out[currentPos++] = (val << 17) >>> 23; + out[currentPos++] = (val << 26) >>> 23 | (valn >>> 28); + // number : 28, bitwidth : 1 + out[currentPos++] = (valn << 4) >>> 31; + out[currentPos++] = (valn << 5) >>> 31; + out[currentPos++] = (valn << 6) >>> 31; + out[currentPos++] = (valn << 7) >>> 31; + out[currentPos++] = (valn << 8) >>> 31; + out[currentPos++] = (valn << 9) >>> 31; + out[currentPos++] = (valn << 10) >>> 31; + out[currentPos++] = (valn << 11) >>> 31; + out[currentPos++] = (valn << 12) >>> 31; + out[currentPos++] = (valn << 13) >>> 31; // 10 + out[currentPos++] = (valn << 14) >>> 31; + out[currentPos++] = (valn << 15) >>> 31; + out[currentPos++] = (valn << 16) >>> 31; + out[currentPos++] = (valn << 17) >>> 31; + out[currentPos++] = (valn << 18) >>> 31; + out[currentPos++] = (valn << 19) >>> 31; + out[currentPos++] = (valn << 20) >>> 31; + out[currentPos++] = (valn << 21) >>> 31; + out[currentPos++] = (valn << 22) >>> 31; + out[currentPos++] = (valn << 23) >>> 31; // 20 + out[currentPos++] = (valn << 24) >>> 31; + out[currentPos++] = (valn << 25) >>> 31; + out[currentPos++] = (valn << 26) >>> 31; + out[currentPos++] = (valn << 27) >>> 31; + out[currentPos++] = (valn << 28) >>> 31; + out[currentPos++] = (valn << 29) >>> 31; + out[currentPos++] = (valn << 30) >>> 31; + out[currentPos++] = (valn << 31) >>> 31; + } + + private void decode53(int val, int valn, int[] out, int currentPos) { + // number : 4, bitwidth : 7 + out[currentPos++] = (val << 8) >>> 25; + out[currentPos++] = (val << 15) >>> 25; + out[currentPos++] = (val << 22) >>> 25; + out[currentPos++] = (val << 29) >>> 25 | (valn >>> 28); + // number : 1, bitwidth : 28 + out[currentPos++] = (valn << 4) >>> 4; + } + + private void decode52(int val, int valn, int[] out, int currentPos) { + // number : 4, bitwidth : 7 + out[currentPos++] = (val << 8) >>> 25; + out[currentPos++] = (val << 15) >>> 25; + out[currentPos++] = (val << 22) >>> 25; + out[currentPos++] = (val << 29) >>> 25 | (valn >>> 28); + // number : 2, bitwidth : 14 + out[currentPos++] = (valn << 4) >>> 18; + out[currentPos++] = (valn << 18) >>> 18; + } + + private void decode51(int val, int valn, int[] out, int currentPos) { + // number : 4, bitwidth : 7 + out[currentPos++] = (val << 8) >>> 25; + out[currentPos++] = (val << 15) >>> 25; + out[currentPos++] = (val << 22) >>> 25; + out[currentPos++] = (val << 29) >>> 25 | (valn >>> 27); + // number : 3, bitwidth : 9 + out[currentPos++] = (valn << 5) >>> 23; + out[currentPos++] = (valn << 14) >>> 23; + out[currentPos++] = (valn << 23) >>> 23; + } + + private void decode50(int val, int valn, int[] out, int currentPos) { + // number : 4, bitwidth : 7 + out[currentPos++] = (val << 8) >>> 25; + out[currentPos++] = (val << 15) >>> 25; + out[currentPos++] = (val << 22) >>> 25; + out[currentPos++] = (val << 29) >>> 25 | (valn >>> 28); + // number : 4, bitwidth : 7 + out[currentPos++] = (valn << 4) >>> 25; + out[currentPos++] = (valn << 11) >>> 25; + out[currentPos++] = (valn << 18) >>> 25; + out[currentPos++] = (valn << 25) >>> 25; + } + + private void decode49(int val, int valn, int[] out, int currentPos) { + // number : 4, bitwidth : 7 + out[currentPos++] = (val << 8) >>> 25; + out[currentPos++] = (val << 15) >>> 25; + out[currentPos++] = (val << 22) >>> 25; + out[currentPos++] = (val << 29) >>> 25 | (valn >>> 25); + // number : 5, bitwidth : 5 + out[currentPos++] = (valn << 7) >>> 27; + out[currentPos++] = (valn << 12) >>> 27; + out[currentPos++] = (valn << 17) >>> 27; + out[currentPos++] = (valn << 22) >>> 27; + out[currentPos++] = (valn << 27) >>> 27; + } + + private void decode48(int val, int valn, int[] out, int currentPos) { + // number : 4, bitwidth : 7 + out[currentPos++] = (val << 8) >>> 25; + out[currentPos++] = (val << 15) >>> 25; + out[currentPos++] = (val << 22) >>> 25; + out[currentPos++] = (val << 29) >>> 25 | (valn >>> 28); + // number : 7, bitwidth : 4 + out[currentPos++] = (valn << 4) >>> 28; + out[currentPos++] = (valn << 8) >>> 28; + out[currentPos++] = (valn << 12) >>> 28; + out[currentPos++] = (valn << 16) >>> 28; + out[currentPos++] = (valn << 20) >>> 28; + out[currentPos++] = (valn << 24) >>> 28; + out[currentPos++] = (valn << 28) >>> 28; + } + + private void decode47(int val, int valn, int[] out, int currentPos) { + // number : 4, bitwidth : 7 + out[currentPos++] = (val << 8) >>> 25; + out[currentPos++] = (val << 15) >>> 25; + out[currentPos++] = (val << 22) >>> 25; + out[currentPos++] = (val << 29) >>> 25 | (valn >>> 27); + // number : 9, bitwidth : 3 + out[currentPos++] = (valn << 5) >>> 29; + out[currentPos++] = (valn << 8) >>> 29; + out[currentPos++] = (valn << 11) >>> 29; + out[currentPos++] = (valn << 14) >>> 29; + out[currentPos++] = (valn << 17) >>> 29; + out[currentPos++] = (valn << 20) >>> 29; + out[currentPos++] = (valn << 23) >>> 29; + out[currentPos++] = (valn << 26) >>> 29; + out[currentPos++] = (valn << 29) >>> 29; + } + + private void decode46(int val, int valn, int[] out, int currentPos) { + // number : 4, bitwidth : 7 + out[currentPos++] = (val << 8) >>> 25; + out[currentPos++] = (val << 15) >>> 25; + out[currentPos++] = (val << 22) >>> 25; + out[currentPos++] = (val << 29) >>> 25 | (valn >>> 28); + // number : 14, bitwidth : 2 + out[currentPos++] = (valn << 4) >>> 30; + out[currentPos++] = (valn << 6) >>> 30; + out[currentPos++] = (valn << 8) >>> 30; + out[currentPos++] = (valn << 10) >>> 30; + out[currentPos++] = (valn << 12) >>> 30; + out[currentPos++] = (valn << 14) >>> 30; + out[currentPos++] = (valn << 16) >>> 30; + out[currentPos++] = (valn << 18) >>> 30; + out[currentPos++] = (valn << 20) >>> 30; + out[currentPos++] = (valn << 22) >>> 30; // 10 + out[currentPos++] = (valn << 24) >>> 30; + out[currentPos++] = (valn << 26) >>> 30; + out[currentPos++] = (valn << 28) >>> 30; + out[currentPos++] = (valn << 30) >>> 30; + } + + private void decode45(int val, int valn, int[] out, int currentPos) { + // number : 4, bitwidth : 7 + out[currentPos++] = (val << 8) >>> 25; + out[currentPos++] = (val << 15) >>> 25; + out[currentPos++] = (val << 22) >>> 25; + out[currentPos++] = (val << 29) >>> 25 | (valn >>> 28); + // number : 28, bitwidth : 1 + out[currentPos++] = (valn << 4) >>> 31; + out[currentPos++] = (valn << 5) >>> 31; + out[currentPos++] = (valn << 6) >>> 31; + out[currentPos++] = (valn << 7) >>> 31; + out[currentPos++] = (valn << 8) >>> 31; + out[currentPos++] = (valn << 9) >>> 31; + out[currentPos++] = (valn << 10) >>> 31; + out[currentPos++] = (valn << 11) >>> 31; + out[currentPos++] = (valn << 12) >>> 31; + out[currentPos++] = (valn << 13) >>> 31; // 10 + out[currentPos++] = (valn << 14) >>> 31; + out[currentPos++] = (valn << 15) >>> 31; + out[currentPos++] = (valn << 16) >>> 31; + out[currentPos++] = (valn << 17) >>> 31; + out[currentPos++] = (valn << 18) >>> 31; + out[currentPos++] = (valn << 19) >>> 31; + out[currentPos++] = (valn << 20) >>> 31; + out[currentPos++] = (valn << 21) >>> 31; + out[currentPos++] = (valn << 22) >>> 31; + out[currentPos++] = (valn << 23) >>> 31; // 20 + out[currentPos++] = (valn << 24) >>> 31; + out[currentPos++] = (valn << 25) >>> 31; + out[currentPos++] = (valn << 26) >>> 31; + out[currentPos++] = (valn << 27) >>> 31; + out[currentPos++] = (valn << 28) >>> 31; + out[currentPos++] = (valn << 29) >>> 31; + out[currentPos++] = (valn << 30) >>> 31; + out[currentPos++] = (valn << 31) >>> 31; + } + + private void decode44(int val, int valn, int[] out, int currentPos) { + // number : 5, bitwidth : 5 + out[currentPos++] = (val << 8) >>> 27; + out[currentPos++] = (val << 13) >>> 27; + out[currentPos++] = (val << 18) >>> 27; + out[currentPos++] = (val << 23) >>> 27; + out[currentPos++] = (val << 28) >>> 27 | (valn >>> 28); + // number : 1, bitwidth : 28 + out[currentPos++] = (valn << 4) >>> 4; + } + + private void decode43(int val, int valn, int[] out, int currentPos) { + // number : 5, bitwidth : 5 + out[currentPos++] = (val << 8) >>> 27; + out[currentPos++] = (val << 13) >>> 27; + out[currentPos++] = (val << 18) >>> 27; + out[currentPos++] = (val << 23) >>> 27; + out[currentPos++] = (val << 28) >>> 27 | (valn >>> 28); + // number : 2, bitwidth : 14 + out[currentPos++] = (valn << 4) >>> 18; + out[currentPos++] = (valn << 18) >>> 18; + } + + private void decode42(int val, int valn, int[] out, int currentPos) { + // number : 5, bitwidth : 5 + out[currentPos++] = (val << 8) >>> 27; + out[currentPos++] = (val << 13) >>> 27; + out[currentPos++] = (val << 18) >>> 27; + out[currentPos++] = (val << 23) >>> 27; + out[currentPos++] = (val << 28) >>> 27 | (valn >>> 27); + // number : 3, bitwidth : 9 + out[currentPos++] = (valn << 5) >>> 23; + out[currentPos++] = (valn << 14) >>> 23; + out[currentPos++] = (valn << 23) >>> 23; + } + + private void decode41(int val, int valn, int[] out, int currentPos) { + // number : 5, bitwidth : 5 + out[currentPos++] = (val << 8) >>> 27; + out[currentPos++] = (val << 13) >>> 27; + out[currentPos++] = (val << 18) >>> 27; + out[currentPos++] = (val << 23) >>> 27; + out[currentPos++] = (val << 28) >>> 27 | (valn >>> 28); + // number : 4, bitwidth : 7 + out[currentPos++] = (valn << 4) >>> 25; + out[currentPos++] = (valn << 11) >>> 25; + out[currentPos++] = (valn << 18) >>> 25; + out[currentPos++] = (valn << 25) >>> 25; + } + + private void decode40(int val, int valn, int[] out, int currentPos) { + // number : 5, bitwidth : 5 + out[currentPos++] = (val << 8) >>> 27; + out[currentPos++] = (val << 13) >>> 27; + out[currentPos++] = (val << 18) >>> 27; + out[currentPos++] = (val << 23) >>> 27; + out[currentPos++] = (val << 28) >>> 27 | (valn >>> 25); + // number : 5, bitwidth : 5 + out[currentPos++] = (valn << 7) >>> 27; + out[currentPos++] = (valn << 12) >>> 27; + out[currentPos++] = (valn << 17) >>> 27; + out[currentPos++] = (valn << 22) >>> 27; + out[currentPos++] = (valn << 27) >>> 27; + } + + private void decode39(int val, int valn, int[] out, int currentPos) { + // number : 5, bitwidth : 5 + out[currentPos++] = (val << 8) >>> 27; + out[currentPos++] = (val << 13) >>> 27; + out[currentPos++] = (val << 18) >>> 27; + out[currentPos++] = (val << 23) >>> 27; + out[currentPos++] = (val << 28) >>> 27 | (valn >>> 28); + // number : 7, bitwidth : 4 + out[currentPos++] = (valn << 4) >>> 28; + out[currentPos++] = (valn << 8) >>> 28; + out[currentPos++] = (valn << 12) >>> 28; + out[currentPos++] = (valn << 16) >>> 28; + out[currentPos++] = (valn << 20) >>> 28; + out[currentPos++] = (valn << 24) >>> 28; + out[currentPos++] = (valn << 28) >>> 28; + } + + private void decode38(int val, int valn, int[] out, int currentPos) { + // number : 5, bitwidth : 5 + out[currentPos++] = (val << 8) >>> 27; + out[currentPos++] = (val << 13) >>> 27; + out[currentPos++] = (val << 18) >>> 27; + out[currentPos++] = (val << 23) >>> 27; + out[currentPos++] = (val << 28) >>> 27 | (valn >>> 27); + // number : 9, bitwidth : 3 + out[currentPos++] = (valn << 5) >>> 29; + out[currentPos++] = (valn << 8) >>> 29; + out[currentPos++] = (valn << 11) >>> 29; + out[currentPos++] = (valn << 14) >>> 29; + out[currentPos++] = (valn << 17) >>> 29; + out[currentPos++] = (valn << 20) >>> 29; + out[currentPos++] = (valn << 23) >>> 29; + out[currentPos++] = (valn << 26) >>> 29; + out[currentPos++] = (valn << 29) >>> 29; + } + + private void decode37(int val, int valn, int[] out, int currentPos) { + // number : 5, bitwidth : 5 + out[currentPos++] = (val << 8) >>> 27; + out[currentPos++] = (val << 13) >>> 27; + out[currentPos++] = (val << 18) >>> 27; + out[currentPos++] = (val << 23) >>> 27; + out[currentPos++] = (val << 28) >>> 27 | (valn >>> 28); + // number : 14, bitwidth : 2 + out[currentPos++] = (valn << 4) >>> 30; + out[currentPos++] = (valn << 6) >>> 30; + out[currentPos++] = (valn << 8) >>> 30; + out[currentPos++] = (valn << 10) >>> 30; + out[currentPos++] = (valn << 12) >>> 30; + out[currentPos++] = (valn << 14) >>> 30; + out[currentPos++] = (valn << 16) >>> 30; + out[currentPos++] = (valn << 18) >>> 30; + out[currentPos++] = (valn << 20) >>> 30; + out[currentPos++] = (valn << 22) >>> 30; // 10 + out[currentPos++] = (valn << 24) >>> 30; + out[currentPos++] = (valn << 26) >>> 30; + out[currentPos++] = (valn << 28) >>> 30; + out[currentPos++] = (valn << 30) >>> 30; + } + + private void decode36(int val, int valn, int[] out, int currentPos) { + // number : 5, bitwidth : 5 + out[currentPos++] = (val << 8) >>> 27; + out[currentPos++] = (val << 13) >>> 27; + out[currentPos++] = (val << 18) >>> 27; + out[currentPos++] = (val << 23) >>> 27; + out[currentPos++] = (val << 28) >>> 27 | (valn >>> 28); + // number : 28, bitwidth : 1 + out[currentPos++] = (valn << 4) >>> 31; + out[currentPos++] = (valn << 5) >>> 31; + out[currentPos++] = (valn << 6) >>> 31; + out[currentPos++] = (valn << 7) >>> 31; + out[currentPos++] = (valn << 8) >>> 31; + out[currentPos++] = (valn << 9) >>> 31; + out[currentPos++] = (valn << 10) >>> 31; + out[currentPos++] = (valn << 11) >>> 31; + out[currentPos++] = (valn << 12) >>> 31; + out[currentPos++] = (valn << 13) >>> 31; // 10 + out[currentPos++] = (valn << 14) >>> 31; + out[currentPos++] = (valn << 15) >>> 31; + out[currentPos++] = (valn << 16) >>> 31; + out[currentPos++] = (valn << 17) >>> 31; + out[currentPos++] = (valn << 18) >>> 31; + out[currentPos++] = (valn << 19) >>> 31; + out[currentPos++] = (valn << 20) >>> 31; + out[currentPos++] = (valn << 21) >>> 31; + out[currentPos++] = (valn << 22) >>> 31; + out[currentPos++] = (valn << 23) >>> 31; // 20 + out[currentPos++] = (valn << 24) >>> 31; + out[currentPos++] = (valn << 25) >>> 31; + out[currentPos++] = (valn << 26) >>> 31; + out[currentPos++] = (valn << 27) >>> 31; + out[currentPos++] = (valn << 28) >>> 31; + out[currentPos++] = (valn << 29) >>> 31; + out[currentPos++] = (valn << 30) >>> 31; + out[currentPos++] = (valn << 31) >>> 31; + } + + private void decode35(int val, int valn, int[] out, int currentPos) { + // number : 7, bitwidth : 4 + out[currentPos++] = (val << 8) >>> 28; + out[currentPos++] = (val << 12) >>> 28; + out[currentPos++] = (val << 16) >>> 28; + out[currentPos++] = (val << 20) >>> 28; + out[currentPos++] = (val << 24) >>> 28; + out[currentPos++] = (val << 28) >>> 28; + out[currentPos++] = (valn << 0) >>> 28; + // number : 1, bitwidth : 28 + out[currentPos++] = (valn << 4) >>> 4; + } + + private void decode34(int val, int valn, int[] out, int currentPos) { + // number : 7, bitwidth : 4 + out[currentPos++] = (val << 8) >>> 28; + out[currentPos++] = (val << 12) >>> 28; + out[currentPos++] = (val << 16) >>> 28; + out[currentPos++] = (val << 20) >>> 28; + out[currentPos++] = (val << 24) >>> 28; + out[currentPos++] = (val << 28) >>> 28; + out[currentPos++] = (valn << 0) >>> 28; + // number : 2, bitwidth : 14 + out[currentPos++] = (valn << 4) >>> 18; + out[currentPos++] = (valn << 18) >>> 18; + } + + private void decode33(int val, int valn, int[] out, int currentPos) { + // number : 7, bitwidth : 4 + out[currentPos++] = (val << 8) >>> 28; + out[currentPos++] = (val << 12) >>> 28; + out[currentPos++] = (val << 16) >>> 28; + out[currentPos++] = (val << 20) >>> 28; + out[currentPos++] = (val << 24) >>> 28; + out[currentPos++] = (val << 28) >>> 28; + out[currentPos++] = (valn << 1) >>> 28; + // number : 3, bitwidth : 9 + out[currentPos++] = (valn << 5) >>> 23; + out[currentPos++] = (valn << 14) >>> 23; + out[currentPos++] = (valn << 23) >>> 23; + } + + private void decode32(int val, int valn, int[] out, int currentPos) { + // number : 7, bitwidth : 4 + out[currentPos++] = (val << 8) >>> 28; + out[currentPos++] = (val << 12) >>> 28; + out[currentPos++] = (val << 16) >>> 28; + out[currentPos++] = (val << 20) >>> 28; + out[currentPos++] = (val << 24) >>> 28; + out[currentPos++] = (val << 28) >>> 28; + out[currentPos++] = (valn << 0) >>> 28; + // number : 4, bitwidth : 7 + out[currentPos++] = (valn << 4) >>> 25; + out[currentPos++] = (valn << 11) >>> 25; + out[currentPos++] = (valn << 18) >>> 25; + out[currentPos++] = (valn << 25) >>> 25; + } + + private void decode31(int val, int valn, int[] out, int currentPos) { + // number : 7, bitwidth : 4 + out[currentPos++] = (val << 8) >>> 28; + out[currentPos++] = (val << 12) >>> 28; + out[currentPos++] = (val << 16) >>> 28; + out[currentPos++] = (val << 20) >>> 28; + out[currentPos++] = (val << 24) >>> 28; + out[currentPos++] = (val << 28) >>> 28; + out[currentPos++] = (valn << 3) >>> 28; + // number : 5, bitwidth : 5 + out[currentPos++] = (valn << 7) >>> 27; + out[currentPos++] = (valn << 12) >>> 27; + out[currentPos++] = (valn << 17) >>> 27; + out[currentPos++] = (valn << 22) >>> 27; + out[currentPos++] = (valn << 27) >>> 27; + } + + private void decode30(int val, int valn, int[] out, int currentPos) { + // number : 7, bitwidth : 4 + out[currentPos++] = (val << 8) >>> 28; + out[currentPos++] = (val << 12) >>> 28; + out[currentPos++] = (val << 16) >>> 28; + out[currentPos++] = (val << 20) >>> 28; + out[currentPos++] = (val << 24) >>> 28; + out[currentPos++] = (val << 28) >>> 28; + out[currentPos++] = (valn << 0) >>> 28; + // number : 7, bitwidth : 4 + out[currentPos++] = (valn << 4) >>> 28; + out[currentPos++] = (valn << 8) >>> 28; + out[currentPos++] = (valn << 12) >>> 28; + out[currentPos++] = (valn << 16) >>> 28; + out[currentPos++] = (valn << 20) >>> 28; + out[currentPos++] = (valn << 24) >>> 28; + out[currentPos++] = (valn << 28) >>> 28; + } + + private void decode29(int val, int valn, int[] out, int currentPos) { + // number : 7, bitwidth : 4 + out[currentPos++] = (val << 8) >>> 28; + out[currentPos++] = (val << 12) >>> 28; + out[currentPos++] = (val << 16) >>> 28; + out[currentPos++] = (val << 20) >>> 28; + out[currentPos++] = (val << 24) >>> 28; + out[currentPos++] = (val << 28) >>> 28; + out[currentPos++] = (valn << 1) >>> 28; + // number : 9, bitwidth : 3 + out[currentPos++] = (valn << 5) >>> 29; + out[currentPos++] = (valn << 8) >>> 29; + out[currentPos++] = (valn << 11) >>> 29; + out[currentPos++] = (valn << 14) >>> 29; + out[currentPos++] = (valn << 17) >>> 29; + out[currentPos++] = (valn << 20) >>> 29; + out[currentPos++] = (valn << 23) >>> 29; + out[currentPos++] = (valn << 26) >>> 29; + out[currentPos++] = (valn << 29) >>> 29; + } + + private void decode28(int val, int valn, int[] out, int currentPos) { + // number : 7, bitwidth : 4 + out[currentPos++] = (val << 8) >>> 28; + out[currentPos++] = (val << 12) >>> 28; + out[currentPos++] = (val << 16) >>> 28; + out[currentPos++] = (val << 20) >>> 28; + out[currentPos++] = (val << 24) >>> 28; + out[currentPos++] = (val << 28) >>> 28; + out[currentPos++] = (valn << 0) >>> 28; + // number : 14, bitwidth : 2 + out[currentPos++] = (valn << 4) >>> 30; + out[currentPos++] = (valn << 6) >>> 30; + out[currentPos++] = (valn << 8) >>> 30; + out[currentPos++] = (valn << 10) >>> 30; + out[currentPos++] = (valn << 12) >>> 30; + out[currentPos++] = (valn << 14) >>> 30; + out[currentPos++] = (valn << 16) >>> 30; + out[currentPos++] = (valn << 18) >>> 30; + out[currentPos++] = (valn << 20) >>> 30; + out[currentPos++] = (valn << 22) >>> 30; // 10 + out[currentPos++] = (valn << 24) >>> 30; + out[currentPos++] = (valn << 26) >>> 30; + out[currentPos++] = (valn << 28) >>> 30; + out[currentPos++] = (valn << 30) >>> 30; + } + + private void decode27(int val, int valn, int[] out, int currentPos) { + // number : 7, bitwidth : 4 + out[currentPos++] = (val << 8) >>> 28; + out[currentPos++] = (val << 12) >>> 28; + out[currentPos++] = (val << 16) >>> 28; + out[currentPos++] = (val << 20) >>> 28; + out[currentPos++] = (val << 24) >>> 28; + out[currentPos++] = (val << 28) >>> 28; + out[currentPos++] = (valn << 0) >>> 28; + // number : 28, bitwidth : 1 + out[currentPos++] = (valn << 4) >>> 31; + out[currentPos++] = (valn << 5) >>> 31; + out[currentPos++] = (valn << 6) >>> 31; + out[currentPos++] = (valn << 7) >>> 31; + out[currentPos++] = (valn << 8) >>> 31; + out[currentPos++] = (valn << 9) >>> 31; + out[currentPos++] = (valn << 10) >>> 31; + out[currentPos++] = (valn << 11) >>> 31; + out[currentPos++] = (valn << 12) >>> 31; + out[currentPos++] = (valn << 13) >>> 31; // 10 + out[currentPos++] = (valn << 14) >>> 31; + out[currentPos++] = (valn << 15) >>> 31; + out[currentPos++] = (valn << 16) >>> 31; + out[currentPos++] = (valn << 17) >>> 31; + out[currentPos++] = (valn << 18) >>> 31; + out[currentPos++] = (valn << 19) >>> 31; + out[currentPos++] = (valn << 20) >>> 31; + out[currentPos++] = (valn << 21) >>> 31; + out[currentPos++] = (valn << 22) >>> 31; + out[currentPos++] = (valn << 23) >>> 31; // 20 + out[currentPos++] = (valn << 24) >>> 31; + out[currentPos++] = (valn << 25) >>> 31; + out[currentPos++] = (valn << 26) >>> 31; + out[currentPos++] = (valn << 27) >>> 31; + out[currentPos++] = (valn << 28) >>> 31; + out[currentPos++] = (valn << 29) >>> 31; + out[currentPos++] = (valn << 30) >>> 31; + out[currentPos++] = (valn << 31) >>> 31; + } + + private void decode26(int val, int valn, int[] out, int currentPos) { + // number : 9, bitwidth : 3 + out[currentPos++] = (val << 8) >>> 29; + out[currentPos++] = (val << 11) >>> 29; + out[currentPos++] = (val << 14) >>> 29; + out[currentPos++] = (val << 17) >>> 29; + out[currentPos++] = (val << 20) >>> 29; + out[currentPos++] = (val << 23) >>> 29; + out[currentPos++] = (val << 26) >>> 29; + out[currentPos++] = (val << 29) >>> 29; + out[currentPos++] = (valn << 1) >>> 29; + // number : 1, bitwidth : 28 + out[currentPos++] = (valn << 4) >>> 4; + } + + private void decode25(int val, int valn, int[] out, int currentPos) { + // number : 9, bitwidth : 3 + out[currentPos++] = (val << 8) >>> 29; + out[currentPos++] = (val << 11) >>> 29; + out[currentPos++] = (val << 14) >>> 29; + out[currentPos++] = (val << 17) >>> 29; + out[currentPos++] = (val << 20) >>> 29; + out[currentPos++] = (val << 23) >>> 29; + out[currentPos++] = (val << 26) >>> 29; + out[currentPos++] = (val << 29) >>> 29; + out[currentPos++] = (valn << 1) >>> 29; + // number : 2, bitwidth : 14 + out[currentPos++] = (valn << 4) >>> 18; + out[currentPos++] = (valn << 18) >>> 18; + } + + private void decode24(int val, int valn, int[] out, int currentPos) { + // number : 9, bitwidth : 3 + out[currentPos++] = (val << 8) >>> 29; + out[currentPos++] = (val << 11) >>> 29; + out[currentPos++] = (val << 14) >>> 29; + out[currentPos++] = (val << 17) >>> 29; + out[currentPos++] = (val << 20) >>> 29; + out[currentPos++] = (val << 23) >>> 29; + out[currentPos++] = (val << 26) >>> 29; + out[currentPos++] = (val << 29) >>> 29; + out[currentPos++] = (valn << 2) >>> 29; + // number : 3, bitwidth : 9 + out[currentPos++] = (valn << 5) >>> 23; + out[currentPos++] = (valn << 14) >>> 23; + out[currentPos++] = (valn << 23) >>> 23; + } + + private void decode23(int val, int valn, int[] out, int currentPos) { + // number : 9, bitwidth : 3 + out[currentPos++] = (val << 8) >>> 29; + out[currentPos++] = (val << 11) >>> 29; + out[currentPos++] = (val << 14) >>> 29; + out[currentPos++] = (val << 17) >>> 29; + out[currentPos++] = (val << 20) >>> 29; + out[currentPos++] = (val << 23) >>> 29; + out[currentPos++] = (val << 26) >>> 29; + out[currentPos++] = (val << 29) >>> 29; + out[currentPos++] = (valn << 1) >>> 29; + // number : 4, bitwidth : 7 + out[currentPos++] = (valn << 4) >>> 25; + out[currentPos++] = (valn << 11) >>> 25; + out[currentPos++] = (valn << 18) >>> 25; + out[currentPos++] = (valn << 25) >>> 25; + } + + private void decode22(int val, int valn, int[] out, int currentPos) { + // number : 9, bitwidth : 3 + out[currentPos++] = (val << 8) >>> 29; + out[currentPos++] = (val << 11) >>> 29; + out[currentPos++] = (val << 14) >>> 29; + out[currentPos++] = (val << 17) >>> 29; + out[currentPos++] = (val << 20) >>> 29; + out[currentPos++] = (val << 23) >>> 29; + out[currentPos++] = (val << 26) >>> 29; + out[currentPos++] = (val << 29) >>> 29; + out[currentPos++] = (valn << 4) >>> 29; + // number : 5, bitwidth : 5 + out[currentPos++] = (valn << 7) >>> 27; + out[currentPos++] = (valn << 12) >>> 27; + out[currentPos++] = (valn << 17) >>> 27; + out[currentPos++] = (valn << 22) >>> 27; + out[currentPos++] = (valn << 27) >>> 27; + } + + private void decode21(int val, int valn, int[] out, int currentPos) { + // number : 9, bitwidth : 3 + out[currentPos++] = (val << 8) >>> 29; + out[currentPos++] = (val << 11) >>> 29; + out[currentPos++] = (val << 14) >>> 29; + out[currentPos++] = (val << 17) >>> 29; + out[currentPos++] = (val << 20) >>> 29; + out[currentPos++] = (val << 23) >>> 29; + out[currentPos++] = (val << 26) >>> 29; + out[currentPos++] = (val << 29) >>> 29; + out[currentPos++] = (valn << 1) >>> 29; + // number : 7, bitwidth : 4 + out[currentPos++] = (valn << 4) >>> 28; + out[currentPos++] = (valn << 8) >>> 28; + out[currentPos++] = (valn << 12) >>> 28; + out[currentPos++] = (valn << 16) >>> 28; + out[currentPos++] = (valn << 20) >>> 28; + out[currentPos++] = (valn << 24) >>> 28; + out[currentPos++] = (valn << 28) >>> 28; + } + + private void decode20(int val, int valn, int[] out, int currentPos) { + // number : 9, bitwidth : 3 + out[currentPos++] = (val << 8) >>> 29; + out[currentPos++] = (val << 11) >>> 29; + out[currentPos++] = (val << 14) >>> 29; + out[currentPos++] = (val << 17) >>> 29; + out[currentPos++] = (val << 20) >>> 29; + out[currentPos++] = (val << 23) >>> 29; + out[currentPos++] = (val << 26) >>> 29; + out[currentPos++] = (val << 29) >>> 29; + out[currentPos++] = (valn << 2) >>> 29; + // number : 9, bitwidth : 3 + out[currentPos++] = (valn << 5) >>> 29; + out[currentPos++] = (valn << 8) >>> 29; + out[currentPos++] = (valn << 11) >>> 29; + out[currentPos++] = (valn << 14) >>> 29; + out[currentPos++] = (valn << 17) >>> 29; + out[currentPos++] = (valn << 20) >>> 29; + out[currentPos++] = (valn << 23) >>> 29; + out[currentPos++] = (valn << 26) >>> 29; + out[currentPos++] = (valn << 29) >>> 29; + } + + private void decode19(int val, int valn, int[] out, int currentPos) { + // number : 9, bitwidth : 3 + out[currentPos++] = (val << 8) >>> 29; + out[currentPos++] = (val << 11) >>> 29; + out[currentPos++] = (val << 14) >>> 29; + out[currentPos++] = (val << 17) >>> 29; + out[currentPos++] = (val << 20) >>> 29; + out[currentPos++] = (val << 23) >>> 29; + out[currentPos++] = (val << 26) >>> 29; + out[currentPos++] = (val << 29) >>> 29; + out[currentPos++] = (valn << 1) >>> 29; + // number : 14, bitwidth : 2 + out[currentPos++] = (valn << 4) >>> 30; + out[currentPos++] = (valn << 6) >>> 30; + out[currentPos++] = (valn << 8) >>> 30; + out[currentPos++] = (valn << 10) >>> 30; + out[currentPos++] = (valn << 12) >>> 30; + out[currentPos++] = (valn << 14) >>> 30; + out[currentPos++] = (valn << 16) >>> 30; + out[currentPos++] = (valn << 18) >>> 30; + out[currentPos++] = (valn << 20) >>> 30; + out[currentPos++] = (valn << 22) >>> 30; // 10 + out[currentPos++] = (valn << 24) >>> 30; + out[currentPos++] = (valn << 26) >>> 30; + out[currentPos++] = (valn << 28) >>> 30; + out[currentPos++] = (valn << 30) >>> 30; + } + + private void decode18(int val, int valn, int[] out, int currentPos) { + // number : 9, bitwidth : 3 + out[currentPos++] = (val << 8) >>> 29; + out[currentPos++] = (val << 11) >>> 29; + out[currentPos++] = (val << 14) >>> 29; + out[currentPos++] = (val << 17) >>> 29; + out[currentPos++] = (val << 20) >>> 29; + out[currentPos++] = (val << 23) >>> 29; + out[currentPos++] = (val << 26) >>> 29; + out[currentPos++] = (val << 29) >>> 29; + out[currentPos++] = (valn << 1) >>> 29; + // number : 28, bitwidth : 1 + out[currentPos++] = (valn << 4) >>> 31; + out[currentPos++] = (valn << 5) >>> 31; + out[currentPos++] = (valn << 6) >>> 31; + out[currentPos++] = (valn << 7) >>> 31; + out[currentPos++] = (valn << 8) >>> 31; + out[currentPos++] = (valn << 9) >>> 31; + out[currentPos++] = (valn << 10) >>> 31; + out[currentPos++] = (valn << 11) >>> 31; + out[currentPos++] = (valn << 12) >>> 31; + out[currentPos++] = (valn << 13) >>> 31; // 10 + out[currentPos++] = (valn << 14) >>> 31; + out[currentPos++] = (valn << 15) >>> 31; + out[currentPos++] = (valn << 16) >>> 31; + out[currentPos++] = (valn << 17) >>> 31; + out[currentPos++] = (valn << 18) >>> 31; + out[currentPos++] = (valn << 19) >>> 31; + out[currentPos++] = (valn << 20) >>> 31; + out[currentPos++] = (valn << 21) >>> 31; + out[currentPos++] = (valn << 22) >>> 31; + out[currentPos++] = (valn << 23) >>> 31; // 20 + out[currentPos++] = (valn << 24) >>> 31; + out[currentPos++] = (valn << 25) >>> 31; + out[currentPos++] = (valn << 26) >>> 31; + out[currentPos++] = (valn << 27) >>> 31; + out[currentPos++] = (valn << 28) >>> 31; + out[currentPos++] = (valn << 29) >>> 31; + out[currentPos++] = (valn << 30) >>> 31; + out[currentPos++] = (valn << 31) >>> 31; + } + + private void decode17(int val, int valn, int[] out, int currentPos) { + // number : 14, bitwidth : 2 + out[currentPos++] = (val << 8) >>> 30; + out[currentPos++] = (val << 10) >>> 30; + out[currentPos++] = (val << 12) >>> 30; + out[currentPos++] = (val << 14) >>> 30; + out[currentPos++] = (val << 16) >>> 30; + out[currentPos++] = (val << 18) >>> 30; + out[currentPos++] = (val << 20) >>> 30; + out[currentPos++] = (val << 22) >>> 30; // 10 + out[currentPos++] = (val << 24) >>> 30; + out[currentPos++] = (val << 26) >>> 30; + out[currentPos++] = (val << 28) >>> 30; + out[currentPos++] = (val << 30) >>> 30; + out[currentPos++] = (valn << 0) >>> 30; + out[currentPos++] = (valn << 2) >>> 30; + // number : 1, bitwidth : 28 + out[currentPos++] = (valn << 4) >>> 4; + } + + private void decode16(int val, int valn, int[] out, int currentPos) { + // number : 14, bitwidth : 2 + out[currentPos++] = (val << 8) >>> 30; + out[currentPos++] = (val << 10) >>> 30; + out[currentPos++] = (val << 12) >>> 30; + out[currentPos++] = (val << 14) >>> 30; + out[currentPos++] = (val << 16) >>> 30; + out[currentPos++] = (val << 18) >>> 30; + out[currentPos++] = (val << 20) >>> 30; + out[currentPos++] = (val << 22) >>> 30; // 10 + out[currentPos++] = (val << 24) >>> 30; + out[currentPos++] = (val << 26) >>> 30; + out[currentPos++] = (val << 28) >>> 30; + out[currentPos++] = (val << 30) >>> 30; + out[currentPos++] = (valn << 0) >>> 30; + out[currentPos++] = (valn << 2) >>> 30; + // number : 2, bitwidth : 14 + out[currentPos++] = (valn << 4) >>> 18; + out[currentPos++] = (valn << 18) >>> 18; + } + + private void decode15(int val, int valn, int[] out, int currentPos) { + // number : 14, bitwidth : 2 + out[currentPos++] = (val << 8) >>> 30; + out[currentPos++] = (val << 10) >>> 30; + out[currentPos++] = (val << 12) >>> 30; + out[currentPos++] = (val << 14) >>> 30; + out[currentPos++] = (val << 16) >>> 30; + out[currentPos++] = (val << 18) >>> 30; + out[currentPos++] = (val << 20) >>> 30; + out[currentPos++] = (val << 22) >>> 30; // 10 + out[currentPos++] = (val << 24) >>> 30; + out[currentPos++] = (val << 26) >>> 30; + out[currentPos++] = (val << 28) >>> 30; + out[currentPos++] = (val << 30) >>> 30; + out[currentPos++] = (valn << 1) >>> 30; + out[currentPos++] = (valn << 3) >>> 30; + // number : 3, bitwidth : 9 + out[currentPos++] = (valn << 5) >>> 23; + out[currentPos++] = (valn << 14) >>> 23; + out[currentPos++] = (valn << 23) >>> 23; + } + + private void decode14(int val, int valn, int[] out, int currentPos) { + // number : 14, bitwidth : 2 + out[currentPos++] = (val << 8) >>> 30; + out[currentPos++] = (val << 10) >>> 30; + out[currentPos++] = (val << 12) >>> 30; + out[currentPos++] = (val << 14) >>> 30; + out[currentPos++] = (val << 16) >>> 30; + out[currentPos++] = (val << 18) >>> 30; + out[currentPos++] = (val << 20) >>> 30; + out[currentPos++] = (val << 22) >>> 30; // 10 + out[currentPos++] = (val << 24) >>> 30; + out[currentPos++] = (val << 26) >>> 30; + out[currentPos++] = (val << 28) >>> 30; + out[currentPos++] = (val << 30) >>> 30; + out[currentPos++] = (valn << 0) >>> 30; + out[currentPos++] = (valn << 2) >>> 30; + // number : 4, bitwidth : 7 + out[currentPos++] = (valn << 4) >>> 25; + out[currentPos++] = (valn << 11) >>> 25; + out[currentPos++] = (valn << 18) >>> 25; + out[currentPos++] = (valn << 25) >>> 25; + } + + private void decode13(int val, int valn, int[] out, int currentPos) { + // number : 14, bitwidth : 2 + out[currentPos++] = (val << 8) >>> 30; + out[currentPos++] = (val << 10) >>> 30; + out[currentPos++] = (val << 12) >>> 30; + out[currentPos++] = (val << 14) >>> 30; + out[currentPos++] = (val << 16) >>> 30; + out[currentPos++] = (val << 18) >>> 30; + out[currentPos++] = (val << 20) >>> 30; + out[currentPos++] = (val << 22) >>> 30; // 10 + out[currentPos++] = (val << 24) >>> 30; + out[currentPos++] = (val << 26) >>> 30; + out[currentPos++] = (val << 28) >>> 30; + out[currentPos++] = (val << 30) >>> 30; + out[currentPos++] = (valn << 3) >>> 30; + out[currentPos++] = (valn << 5) >>> 30; + // number : 5, bitwidth : 5 + out[currentPos++] = (valn << 7) >>> 27; + out[currentPos++] = (valn << 12) >>> 27; + out[currentPos++] = (valn << 17) >>> 27; + out[currentPos++] = (valn << 22) >>> 27; + out[currentPos++] = (valn << 27) >>> 27; + + } + + private void decode12(int val, int valn, int[] out, int currentPos) { + // number : 14, bitwidth : 2 + out[currentPos++] = (val << 8) >>> 30; + out[currentPos++] = (val << 10) >>> 30; + out[currentPos++] = (val << 12) >>> 30; + out[currentPos++] = (val << 14) >>> 30; + out[currentPos++] = (val << 16) >>> 30; + out[currentPos++] = (val << 18) >>> 30; + out[currentPos++] = (val << 20) >>> 30; + out[currentPos++] = (val << 22) >>> 30; // 10 + out[currentPos++] = (val << 24) >>> 30; + out[currentPos++] = (val << 26) >>> 30; + out[currentPos++] = (val << 28) >>> 30; + out[currentPos++] = (val << 30) >>> 30; + out[currentPos++] = (valn << 0) >>> 30; + out[currentPos++] = (valn << 2) >>> 30; + // number : 7, bitwidth : 4 + out[currentPos++] = (valn << 4) >>> 28; + out[currentPos++] = (valn << 8) >>> 28; + out[currentPos++] = (valn << 12) >>> 28; + out[currentPos++] = (valn << 16) >>> 28; + out[currentPos++] = (valn << 20) >>> 28; + out[currentPos++] = (valn << 24) >>> 28; + out[currentPos++] = (valn << 28) >>> 28; + + } + + private void decode11(int val, int valn, int[] out, int currentPos) { + // number : 14, bitwidth : 2 + out[currentPos++] = (val << 8) >>> 30; + out[currentPos++] = (val << 10) >>> 30; + out[currentPos++] = (val << 12) >>> 30; + out[currentPos++] = (val << 14) >>> 30; + out[currentPos++] = (val << 16) >>> 30; + out[currentPos++] = (val << 18) >>> 30; + out[currentPos++] = (val << 20) >>> 30; + out[currentPos++] = (val << 22) >>> 30; // 10 + out[currentPos++] = (val << 24) >>> 30; + out[currentPos++] = (val << 26) >>> 30; + out[currentPos++] = (val << 28) >>> 30; + out[currentPos++] = (val << 30) >>> 30; + out[currentPos++] = (valn << 1) >>> 30; + out[currentPos++] = (valn << 3) >>> 30; + // number : 9, bitwidth : 3 + out[currentPos++] = (valn << 5) >>> 29; + out[currentPos++] = (valn << 8) >>> 29; + out[currentPos++] = (valn << 11) >>> 29; + out[currentPos++] = (valn << 14) >>> 29; + out[currentPos++] = (valn << 17) >>> 29; + out[currentPos++] = (valn << 20) >>> 29; + out[currentPos++] = (valn << 23) >>> 29; + out[currentPos++] = (valn << 26) >>> 29; + out[currentPos++] = (valn << 29) >>> 29; + + } + + private void decode10(int val, int valn, int[] out, int currentPos) { + // number : 14, bitwidth : 2 + out[currentPos++] = (val << 8) >>> 30; + out[currentPos++] = (val << 10) >>> 30; + out[currentPos++] = (val << 12) >>> 30; + out[currentPos++] = (val << 14) >>> 30; + out[currentPos++] = (val << 16) >>> 30; + out[currentPos++] = (val << 18) >>> 30; + out[currentPos++] = (val << 20) >>> 30; + out[currentPos++] = (val << 22) >>> 30; // 10 + out[currentPos++] = (val << 24) >>> 30; + out[currentPos++] = (val << 26) >>> 30; + out[currentPos++] = (val << 28) >>> 30; + out[currentPos++] = (val << 30) >>> 30; + out[currentPos++] = (valn << 0) >>> 30; + out[currentPos++] = (valn << 2) >>> 30; + // number : 14, bitwidth : 2 + out[currentPos++] = (valn << 4) >>> 30; + out[currentPos++] = (valn << 6) >>> 30; + out[currentPos++] = (valn << 8) >>> 30; + out[currentPos++] = (valn << 10) >>> 30; + out[currentPos++] = (valn << 12) >>> 30; + out[currentPos++] = (valn << 14) >>> 30; + out[currentPos++] = (valn << 16) >>> 30; + out[currentPos++] = (valn << 18) >>> 30; + out[currentPos++] = (valn << 20) >>> 30; + out[currentPos++] = (valn << 22) >>> 30; // 10 + out[currentPos++] = (valn << 24) >>> 30; + out[currentPos++] = (valn << 26) >>> 30; + out[currentPos++] = (valn << 28) >>> 30; + out[currentPos++] = (valn << 30) >>> 30; + } + + private void decode9(int val, int valn, int[] out, int currentPos) { + // number : 14, bitwidth : 2 + out[currentPos++] = (val << 8) >>> 30; + out[currentPos++] = (val << 10) >>> 30; + out[currentPos++] = (val << 12) >>> 30; + out[currentPos++] = (val << 14) >>> 30; + out[currentPos++] = (val << 16) >>> 30; + out[currentPos++] = (val << 18) >>> 30; + out[currentPos++] = (val << 20) >>> 30; + out[currentPos++] = (val << 22) >>> 30; // 10 + out[currentPos++] = (val << 24) >>> 30; + out[currentPos++] = (val << 26) >>> 30; + out[currentPos++] = (val << 28) >>> 30; + out[currentPos++] = (val << 30) >>> 30; + out[currentPos++] = (valn << 0) >>> 30; + out[currentPos++] = (valn << 2) >>> 30; + // number : 28, bitwidth : 1 + out[currentPos++] = (valn << 4) >>> 31; + out[currentPos++] = (valn << 5) >>> 31; + out[currentPos++] = (valn << 6) >>> 31; + out[currentPos++] = (valn << 7) >>> 31; + out[currentPos++] = (valn << 8) >>> 31; + out[currentPos++] = (valn << 9) >>> 31; + out[currentPos++] = (valn << 10) >>> 31; + out[currentPos++] = (valn << 11) >>> 31; + out[currentPos++] = (valn << 12) >>> 31; + out[currentPos++] = (valn << 13) >>> 31; // 10 + out[currentPos++] = (valn << 14) >>> 31; + out[currentPos++] = (valn << 15) >>> 31; + out[currentPos++] = (valn << 16) >>> 31; + out[currentPos++] = (valn << 17) >>> 31; + out[currentPos++] = (valn << 18) >>> 31; + out[currentPos++] = (valn << 19) >>> 31; + out[currentPos++] = (valn << 20) >>> 31; + out[currentPos++] = (valn << 21) >>> 31; + out[currentPos++] = (valn << 22) >>> 31; + out[currentPos++] = (valn << 23) >>> 31; // 20 + out[currentPos++] = (valn << 24) >>> 31; + out[currentPos++] = (valn << 25) >>> 31; + out[currentPos++] = (valn << 26) >>> 31; + out[currentPos++] = (valn << 27) >>> 31; + out[currentPos++] = (valn << 28) >>> 31; + out[currentPos++] = (valn << 29) >>> 31; + out[currentPos++] = (valn << 30) >>> 31; + out[currentPos++] = (valn << 31) >>> 31; + } + + private void decode8(int val, int valn, int[] out, int currentPos) { + // number : 28, bitwidth : 1 + out[currentPos++] = (val << 8) >>> 31; + out[currentPos++] = (val << 9) >>> 31; + out[currentPos++] = (val << 10) >>> 31; + out[currentPos++] = (val << 11) >>> 31; + out[currentPos++] = (val << 12) >>> 31; + out[currentPos++] = (val << 13) >>> 31; // 10 + out[currentPos++] = (val << 14) >>> 31; + out[currentPos++] = (val << 15) >>> 31; + out[currentPos++] = (val << 16) >>> 31; + out[currentPos++] = (val << 17) >>> 31; + out[currentPos++] = (val << 18) >>> 31; + out[currentPos++] = (val << 19) >>> 31; + out[currentPos++] = (val << 20) >>> 31; + out[currentPos++] = (val << 21) >>> 31; + out[currentPos++] = (val << 22) >>> 31; + out[currentPos++] = (val << 23) >>> 31; // 20 + out[currentPos++] = (val << 24) >>> 31; + out[currentPos++] = (val << 25) >>> 31; + out[currentPos++] = (val << 26) >>> 31; + out[currentPos++] = (val << 27) >>> 31; + out[currentPos++] = (val << 28) >>> 31; + out[currentPos++] = (val << 29) >>> 31; + out[currentPos++] = (val << 30) >>> 31; + out[currentPos++] = (val << 31) >>> 31; + out[currentPos++] = valn >>> 31; + out[currentPos++] = (valn << 1) >>> 31; + out[currentPos++] = (valn << 2) >>> 31; + out[currentPos++] = (valn << 3) >>> 31; + // number : 1, bitwidth : 28 + out[currentPos++] = (valn << 4) >>> 4; + } + + private void decode7(int val, int valn, int[] out, int currentPos) { + // number : 28, bitwidth : 1 + out[currentPos++] = (val << 8) >>> 31; + out[currentPos++] = (val << 9) >>> 31; + out[currentPos++] = (val << 10) >>> 31; + out[currentPos++] = (val << 11) >>> 31; + out[currentPos++] = (val << 12) >>> 31; + out[currentPos++] = (val << 13) >>> 31; // 10 + out[currentPos++] = (val << 14) >>> 31; + out[currentPos++] = (val << 15) >>> 31; + out[currentPos++] = (val << 16) >>> 31; + out[currentPos++] = (val << 17) >>> 31; + out[currentPos++] = (val << 18) >>> 31; + out[currentPos++] = (val << 19) >>> 31; + out[currentPos++] = (val << 20) >>> 31; + out[currentPos++] = (val << 21) >>> 31; + out[currentPos++] = (val << 22) >>> 31; + out[currentPos++] = (val << 23) >>> 31; // 20 + out[currentPos++] = (val << 24) >>> 31; + out[currentPos++] = (val << 25) >>> 31; + out[currentPos++] = (val << 26) >>> 31; + out[currentPos++] = (val << 27) >>> 31; + out[currentPos++] = (val << 28) >>> 31; + out[currentPos++] = (val << 29) >>> 31; + out[currentPos++] = (val << 30) >>> 31; + out[currentPos++] = (val << 31) >>> 31; + out[currentPos++] = valn >>> 31; + out[currentPos++] = (valn << 1) >>> 31; + out[currentPos++] = (valn << 2) >>> 31; + out[currentPos++] = (valn << 3) >>> 31; + // number : 2, bitwidth : 14 + out[currentPos++] = (valn << 4) >>> 18; + out[currentPos++] = (valn << 18) >>> 18; + } + + private void decode6(int val, int valn, int[] out, int currentPos) { + // number : 28, bitwidth : 1 + out[currentPos++] = (val << 8) >>> 31; + out[currentPos++] = (val << 9) >>> 31; + out[currentPos++] = (val << 10) >>> 31; + out[currentPos++] = (val << 11) >>> 31; + out[currentPos++] = (val << 12) >>> 31; + out[currentPos++] = (val << 13) >>> 31; // 10 + out[currentPos++] = (val << 14) >>> 31; + out[currentPos++] = (val << 15) >>> 31; + out[currentPos++] = (val << 16) >>> 31; + out[currentPos++] = (val << 17) >>> 31; + out[currentPos++] = (val << 18) >>> 31; + out[currentPos++] = (val << 19) >>> 31; + out[currentPos++] = (val << 20) >>> 31; + out[currentPos++] = (val << 21) >>> 31; + out[currentPos++] = (val << 22) >>> 31; + out[currentPos++] = (val << 23) >>> 31; // 20 + out[currentPos++] = (val << 24) >>> 31; + out[currentPos++] = (val << 25) >>> 31; + out[currentPos++] = (val << 26) >>> 31; + out[currentPos++] = (val << 27) >>> 31; + out[currentPos++] = (val << 28) >>> 31; + out[currentPos++] = (val << 29) >>> 31; + out[currentPos++] = (val << 30) >>> 31; + out[currentPos++] = (val << 31) >>> 31; + out[currentPos++] = (valn << 1) >>> 31; + out[currentPos++] = (valn << 2) >>> 31; + out[currentPos++] = (valn << 3) >>> 31; + out[currentPos++] = (valn << 4) >>> 31; + // number : 3, bitwidth : 9 + out[currentPos++] = (valn << 5) >>> 23; + out[currentPos++] = (valn << 14) >>> 23; + out[currentPos++] = (valn << 23) >>> 23; + } + + private void decode5(int val, int valn, int[] out, int currentPos) { + // number : 28, bitwidth : 1 + out[currentPos++] = (val << 8) >>> 31; + out[currentPos++] = (val << 9) >>> 31; + out[currentPos++] = (val << 10) >>> 31; + out[currentPos++] = (val << 11) >>> 31; + out[currentPos++] = (val << 12) >>> 31; + out[currentPos++] = (val << 13) >>> 31; // 10 + out[currentPos++] = (val << 14) >>> 31; + out[currentPos++] = (val << 15) >>> 31; + out[currentPos++] = (val << 16) >>> 31; + out[currentPos++] = (val << 17) >>> 31; + out[currentPos++] = (val << 18) >>> 31; + out[currentPos++] = (val << 19) >>> 31; + out[currentPos++] = (val << 20) >>> 31; + out[currentPos++] = (val << 21) >>> 31; + out[currentPos++] = (val << 22) >>> 31; + out[currentPos++] = (val << 23) >>> 31; // 20 + out[currentPos++] = (val << 24) >>> 31; + out[currentPos++] = (val << 25) >>> 31; + out[currentPos++] = (val << 26) >>> 31; + out[currentPos++] = (val << 27) >>> 31; + out[currentPos++] = (val << 28) >>> 31; + out[currentPos++] = (val << 29) >>> 31; + out[currentPos++] = (val << 30) >>> 31; + out[currentPos++] = (val << 31) >>> 31; + out[currentPos++] = valn >>> 31; + out[currentPos++] = (valn << 1) >>> 31; + out[currentPos++] = (valn << 2) >>> 31; + out[currentPos++] = (valn << 3) >>> 31; + // number : 4, bitwidth : 7 + out[currentPos++] = (valn << 4) >>> 25; + out[currentPos++] = (valn << 11) >>> 25; + out[currentPos++] = (valn << 18) >>> 25; + out[currentPos++] = (valn << 25) >>> 25; + } + + private void decode4(int val, int valn, int[] out, int currentPos) { + // number : 28, bitwidth : 1 + out[currentPos++] = (val << 8) >>> 31; + out[currentPos++] = (val << 9) >>> 31; + out[currentPos++] = (val << 10) >>> 31; + out[currentPos++] = (val << 11) >>> 31; + out[currentPos++] = (val << 12) >>> 31; + out[currentPos++] = (val << 13) >>> 31; // 10 + out[currentPos++] = (val << 14) >>> 31; + out[currentPos++] = (val << 15) >>> 31; + out[currentPos++] = (val << 16) >>> 31; + out[currentPos++] = (val << 17) >>> 31; + out[currentPos++] = (val << 18) >>> 31; + out[currentPos++] = (val << 19) >>> 31; + out[currentPos++] = (val << 20) >>> 31; + out[currentPos++] = (val << 21) >>> 31; + out[currentPos++] = (val << 22) >>> 31; + out[currentPos++] = (val << 23) >>> 31; // 20 + out[currentPos++] = (val << 24) >>> 31; + out[currentPos++] = (val << 25) >>> 31; + out[currentPos++] = (val << 26) >>> 31; + out[currentPos++] = (val << 27) >>> 31; + out[currentPos++] = (val << 28) >>> 31; + out[currentPos++] = (val << 29) >>> 31; + out[currentPos++] = (val << 30) >>> 31; + out[currentPos++] = (val << 31) >>> 31; + out[currentPos++] = (valn << 3) >>> 31;// 头部3bit + out[currentPos++] = (valn << 4) >>> 31; + out[currentPos++] = (valn << 5) >>> 31; + out[currentPos++] = (valn << 6) >>> 31; + // number : 5, bitwidth : 5 + out[currentPos++] = (valn << 7) >>> 27; + out[currentPos++] = (valn << 12) >>> 27; + out[currentPos++] = (valn << 17) >>> 27; + out[currentPos++] = (valn << 22) >>> 27; + out[currentPos++] = (valn << 27) >>> 27; + } + + private void decode3(int val, int valn, int[] out, int currentPos) { + // number : 28, bitwidth : 1 + out[currentPos++] = (val << 8) >>> 31; + out[currentPos++] = (val << 9) >>> 31; + out[currentPos++] = (val << 10) >>> 31; + out[currentPos++] = (val << 11) >>> 31; + out[currentPos++] = (val << 12) >>> 31; + out[currentPos++] = (val << 13) >>> 31; // 10 + out[currentPos++] = (val << 14) >>> 31; + out[currentPos++] = (val << 15) >>> 31; + out[currentPos++] = (val << 16) >>> 31; + out[currentPos++] = (val << 17) >>> 31; + out[currentPos++] = (val << 18) >>> 31; + out[currentPos++] = (val << 19) >>> 31; + out[currentPos++] = (val << 20) >>> 31; + out[currentPos++] = (val << 21) >>> 31; + out[currentPos++] = (val << 22) >>> 31; + out[currentPos++] = (val << 23) >>> 31; // 20 + out[currentPos++] = (val << 24) >>> 31; + out[currentPos++] = (val << 25) >>> 31; + out[currentPos++] = (val << 26) >>> 31; + out[currentPos++] = (val << 27) >>> 31; + out[currentPos++] = (val << 28) >>> 31; + out[currentPos++] = (val << 29) >>> 31; + out[currentPos++] = (val << 30) >>> 31; + out[currentPos++] = (val << 31) >>> 31; + out[currentPos++] = valn >>> 31; + out[currentPos++] = (valn << 1) >>> 31; + out[currentPos++] = (valn << 2) >>> 31; + out[currentPos++] = (valn << 3) >>> 31; + // number : 7, bitwidth : 4 + out[currentPos++] = (valn << 4) >>> 28; + out[currentPos++] = (valn << 8) >>> 28; + out[currentPos++] = (valn << 12) >>> 28; + out[currentPos++] = (valn << 16) >>> 28; + out[currentPos++] = (valn << 20) >>> 28; + out[currentPos++] = (valn << 24) >>> 28; + out[currentPos++] = (valn << 28) >>> 28; + } + + private void decode2(int val, int valn, int[] out, int currentPos) { + // number : 28, bitwidth : 1 + out[currentPos++] = (val << 8) >>> 31; + out[currentPos++] = (val << 9) >>> 31; + out[currentPos++] = (val << 10) >>> 31; + out[currentPos++] = (val << 11) >>> 31; + out[currentPos++] = (val << 12) >>> 31; + out[currentPos++] = (val << 13) >>> 31; // 10 + out[currentPos++] = (val << 14) >>> 31; + out[currentPos++] = (val << 15) >>> 31; + out[currentPos++] = (val << 16) >>> 31; + out[currentPos++] = (val << 17) >>> 31; + out[currentPos++] = (val << 18) >>> 31; + out[currentPos++] = (val << 19) >>> 31; + out[currentPos++] = (val << 20) >>> 31; + out[currentPos++] = (val << 21) >>> 31; + out[currentPos++] = (val << 22) >>> 31; + out[currentPos++] = (val << 23) >>> 31; // 20 + out[currentPos++] = (val << 24) >>> 31; + out[currentPos++] = (val << 25) >>> 31; + out[currentPos++] = (val << 26) >>> 31; + out[currentPos++] = (val << 27) >>> 31; + out[currentPos++] = (val << 28) >>> 31; + out[currentPos++] = (val << 29) >>> 31; + out[currentPos++] = (val << 30) >>> 31; + out[currentPos++] = (val << 31) >>> 31; + out[currentPos++] = (valn << 1) >>> 31;// 头部1bit + out[currentPos++] = (valn << 2) >>> 31; + out[currentPos++] = (valn << 3) >>> 31; + out[currentPos++] = (valn << 4) >>> 31; + // number : 9, bitwidth : 3 + out[currentPos++] = (valn << 5) >>> 29; + out[currentPos++] = (valn << 8) >>> 29; + out[currentPos++] = (valn << 11) >>> 29; + out[currentPos++] = (valn << 14) >>> 29; + out[currentPos++] = (valn << 17) >>> 29; + out[currentPos++] = (valn << 20) >>> 29; + out[currentPos++] = (valn << 23) >>> 29; + out[currentPos++] = (valn << 26) >>> 29; + out[currentPos++] = (valn << 29) >>> 29; + } + + private void decode1(int val, int valn, int[] out, int currentPos) { + // number : 28, bitwidth : 1 + out[currentPos++] = (val << 8) >>> 31; + out[currentPos++] = (val << 9) >>> 31; + out[currentPos++] = (val << 10) >>> 31; + out[currentPos++] = (val << 11) >>> 31; + out[currentPos++] = (val << 12) >>> 31; + out[currentPos++] = (val << 13) >>> 31; // 10 + out[currentPos++] = (val << 14) >>> 31; + out[currentPos++] = (val << 15) >>> 31; + out[currentPos++] = (val << 16) >>> 31; + out[currentPos++] = (val << 17) >>> 31; + out[currentPos++] = (val << 18) >>> 31; + out[currentPos++] = (val << 19) >>> 31; + out[currentPos++] = (val << 20) >>> 31; + out[currentPos++] = (val << 21) >>> 31; + out[currentPos++] = (val << 22) >>> 31; + out[currentPos++] = (val << 23) >>> 31;// 20 + out[currentPos++] = (val << 24) >>> 31; + out[currentPos++] = (val << 25) >>> 31; + out[currentPos++] = (val << 26) >>> 31; + out[currentPos++] = (val << 27) >>> 31; + out[currentPos++] = (val << 28) >>> 31; + out[currentPos++] = (val << 29) >>> 31; + out[currentPos++] = (val << 30) >>> 31; + out[currentPos++] = (val << 31) >>> 31; + out[currentPos++] = valn >>> 31; + out[currentPos++] = (valn << 1) >>> 31; + out[currentPos++] = (valn << 2) >>> 31; + out[currentPos++] = (valn << 3) >>> 31; + // number : 14, bitwidth : 2 + out[currentPos++] = (valn << 4) >>> 30; + out[currentPos++] = (valn << 6) >>> 30; + out[currentPos++] = (valn << 8) >>> 30; + out[currentPos++] = (valn << 10) >>> 30; + out[currentPos++] = (valn << 12) >>> 30; + out[currentPos++] = (valn << 14) >>> 30; + out[currentPos++] = (valn << 16) >>> 30; + out[currentPos++] = (valn << 18) >>> 30; + out[currentPos++] = (valn << 20) >>> 30; + out[currentPos++] = (valn << 22) >>> 30; // 10 + out[currentPos++] = (valn << 24) >>> 30; + out[currentPos++] = (valn << 26) >>> 30; + out[currentPos++] = (valn << 28) >>> 30; + out[currentPos++] = (valn << 30) >>> 30; + } + + private void decode0(int val, int valn, int[] out, int currentPos) { + // number : 28, bitwidth : 1 + out[currentPos++] = (val << 8) >>> 31; + out[currentPos++] = (val << 9) >>> 31; + out[currentPos++] = (val << 10) >>> 31; + out[currentPos++] = (val << 11) >>> 31; + out[currentPos++] = (val << 12) >>> 31; + out[currentPos++] = (val << 13) >>> 31; // 10 + out[currentPos++] = (val << 14) >>> 31; + out[currentPos++] = (val << 15) >>> 31; + out[currentPos++] = (val << 16) >>> 31; + out[currentPos++] = (val << 17) >>> 31; + out[currentPos++] = (val << 18) >>> 31; + out[currentPos++] = (val << 19) >>> 31; + out[currentPos++] = (val << 20) >>> 31; + out[currentPos++] = (val << 21) >>> 31; + out[currentPos++] = (val << 22) >>> 31; + out[currentPos++] = (val << 23) >>> 31; // 20 + out[currentPos++] = (val << 24) >>> 31; + out[currentPos++] = (val << 25) >>> 31; + out[currentPos++] = (val << 26) >>> 31; + out[currentPos++] = (val << 27) >>> 31; + out[currentPos++] = (val << 28) >>> 31; + out[currentPos++] = (val << 29) >>> 31; + out[currentPos++] = (val << 30) >>> 31; + out[currentPos++] = (val << 31) >>> 31; + out[currentPos++] = valn >>> 31; + out[currentPos++] = (valn << 1) >>> 31; + out[currentPos++] = (valn << 2) >>> 31; + out[currentPos++] = (valn << 3) >>> 31; + // number : 28, bitwidth : 1 + out[currentPos++] = (valn << 4) >>> 31; + out[currentPos++] = (valn << 5) >>> 31; + out[currentPos++] = (valn << 6) >>> 31; + out[currentPos++] = (valn << 7) >>> 31; + out[currentPos++] = (valn << 8) >>> 31; + out[currentPos++] = (valn << 9) >>> 31; + out[currentPos++] = (valn << 10) >>> 31; + out[currentPos++] = (valn << 11) >>> 31; + out[currentPos++] = (valn << 12) >>> 31; + out[currentPos++] = (valn << 13) >>> 31; // 10 + out[currentPos++] = (valn << 14) >>> 31; + out[currentPos++] = (valn << 15) >>> 31; + out[currentPos++] = (valn << 16) >>> 31; + out[currentPos++] = (valn << 17) >>> 31; + out[currentPos++] = (valn << 18) >>> 31; + out[currentPos++] = (valn << 19) >>> 31; + out[currentPos++] = (valn << 20) >>> 31; + out[currentPos++] = (valn << 21) >>> 31; + out[currentPos++] = (valn << 22) >>> 31; + out[currentPos++] = (valn << 23) >>> 31; // 20 + out[currentPos++] = (valn << 24) >>> 31; + out[currentPos++] = (valn << 25) >>> 31; + out[currentPos++] = (valn << 26) >>> 31; + out[currentPos++] = (valn << 27) >>> 31; + out[currentPos++] = (valn << 28) >>> 31; + out[currentPos++] = (valn << 29) >>> 31; + out[currentPos++] = (valn << 30) >>> 31; + out[currentPos++] = (valn << 31) >>> 31; + } + + + private final static int bitLength[] = { 1, 2, 3, 4, 5, 7, 9, 14, 28 }; + + private final static int codeNum[] = { 28, 14, 9, 7, 5, 4, 3, 2, 1 }; + + @Override + public String toString() { + return this.getClass().getSimpleName(); + } + + @Override + public void headlessCompress(int[] in, IntWrapper inpos, int inlength, int[] out, IntWrapper outpos) { + int tmpoutpos = outpos.get(); + int currentPos = inpos.get(); + int selector1 = 0; + int selector2 = 0; + final int finalin = currentPos + inlength; + while (currentPos < finalin - 28 * 2) { + int nextCurrentPos = currentPos; + mainloop1: for (selector1=0; selector1 <= 8; selector1++) { + int compressedNum = codeNum[selector1]; + //if (finalin <= nextCurrentPos + compressedNum - 1) + // compressedNum = finalin - nextCurrentPos; + int b = bitLength[selector1]; + int max = 1 << b; + int i = 0; + for (; i < compressedNum; i++) { + if (Util.smallerorequalthan(max, in[nextCurrentPos + i])) + continue mainloop1; + } + nextCurrentPos += compressedNum; + break; + } + mainloop2: for (selector2 = 0; selector2 <= 8; selector2++) { + int compressedNum = codeNum[selector2]; + //if (finalin <= nextCurrentPos + compressedNum - 1) + // compressedNum = finalin - nextCurrentPos; + int b = bitLength[selector2]; + int max = 1 << b; + int i = 0; + for (; i < compressedNum; i++) { + if (Util.smallerorequalthan(max, in[nextCurrentPos + i])) + continue mainloop2; + } + nextCurrentPos += compressedNum; + break; + } + int code = M[selector1][selector2]; + out[tmpoutpos] = 0; + out[tmpoutpos + 1] = 0; + switch (code) { + case 0: + encode0(in, currentPos, code, out, tmpoutpos); + break; + case 1: + encode1(in, currentPos, code, out, tmpoutpos); + break; + case 2: + encode2(in, currentPos, code, out, tmpoutpos); + break; + case 3: + encode3(in, currentPos, code, out, tmpoutpos); + break; + case 4: + encode4(in, currentPos, code, out, tmpoutpos); + break; + case 5: + encode5(in, currentPos, code, out, tmpoutpos); + break; + case 6: + encode6(in, currentPos, code, out, tmpoutpos); + break; + case 7: + encode7(in, currentPos, code, out, tmpoutpos); + break; + case 8: + encode8(in, currentPos, code, out, tmpoutpos); + break; + case 9: + encode9(in, currentPos, code, out, tmpoutpos); + break; + case 10: + encode10(in, currentPos, code, out, tmpoutpos); + break; + case 11: + encode11(in, currentPos, code, out, tmpoutpos); + break; + case 12: + encode12(in, currentPos, code, out, tmpoutpos); + break; + case 13: + encode13(in, currentPos, code, out, tmpoutpos); + break; + case 14: + encode14(in, currentPos, code, out, tmpoutpos); + break; + case 15: + encode15(in, currentPos, code, out, tmpoutpos); + break; + case 16: + encode16(in, currentPos, code, out, tmpoutpos); + break; + case 17: + encode17(in, currentPos, code, out, tmpoutpos); + break; + case 18: + encode18(in, currentPos, code, out, tmpoutpos); + break; + case 19: + encode19(in, currentPos, code, out, tmpoutpos); + break; + case 20: + encode20(in, currentPos, code, out, tmpoutpos); + break; + case 21: + encode21(in, currentPos, code, out, tmpoutpos); + break; + case 22: + encode22(in, currentPos, code, out, tmpoutpos); + break; + case 23: + encode23(in, currentPos, code, out, tmpoutpos); + break; + case 24: + encode24(in, currentPos, code, out, tmpoutpos); + break; + case 25: + encode25(in, currentPos, code, out, tmpoutpos); + break; + case 26: + encode26(in, currentPos, code, out, tmpoutpos); + break; + case 27: + encode27(in, currentPos, code, out, tmpoutpos); + break; + case 28: + encode28(in, currentPos, code, out, tmpoutpos); + break; + case 29: + encode29(in, currentPos, code, out, tmpoutpos); + break; + case 30: + encode30(in, currentPos, code, out, tmpoutpos); + break; + case 31: + encode31(in, currentPos, code, out, tmpoutpos); + break; + case 32: + encode32(in, currentPos, code, out, tmpoutpos); + break; + case 33: + encode33(in, currentPos, code, out, tmpoutpos); + break; + case 34: + encode34(in, currentPos, code, out, tmpoutpos); + break; + case 35: + encode35(in, currentPos, code, out, tmpoutpos); + break; + case 36: + encode36(in, currentPos, code, out, tmpoutpos); + break; + case 37: + encode37(in, currentPos, code, out, tmpoutpos); + break; + case 38: + encode38(in, currentPos, code, out, tmpoutpos); + break; + case 39: + encode39(in, currentPos, code, out, tmpoutpos); + break; + case 40: + encode40(in, currentPos, code, out, tmpoutpos); + break; + case 41: + encode41(in, currentPos, code, out, tmpoutpos); + break; + case 42: + encode42(in, currentPos, code, out, tmpoutpos); + break; + case 43: + encode43(in, currentPos, code, out, tmpoutpos); + break; + case 44: + encode44(in, currentPos, code, out, tmpoutpos); + break; + case 45: + encode45(in, currentPos, code, out, tmpoutpos); + break; + case 46: + encode46(in, currentPos, code, out, tmpoutpos); + break; + case 47: + encode47(in, currentPos, code, out, tmpoutpos); + break; + case 48: + encode48(in, currentPos, code, out, tmpoutpos); + break; + case 49: + encode49(in, currentPos, code, out, tmpoutpos); + break; + case 50: + encode50(in, currentPos, code, out, tmpoutpos); + break; + case 51: + encode51(in, currentPos, code, out, tmpoutpos); + break; + case 52: + encode52(in, currentPos, code, out, tmpoutpos); + break; + case 53: + encode53(in, currentPos, code, out, tmpoutpos); + break; + case 54: + encode54(in, currentPos, code, out, tmpoutpos); + break; + case 55: + encode55(in, currentPos, code, out, tmpoutpos); + break; + case 56: + encode56(in, currentPos, code, out, tmpoutpos); + break; + case 57: + encode57(in, currentPos, code, out, tmpoutpos); + break; + case 58: + encode58(in, currentPos, code, out, tmpoutpos); + break; + case 59: + encode59(in, currentPos, code, out, tmpoutpos); + break; + case 60: + encode60(in, currentPos, code, out, tmpoutpos); + break; + case 61: + encode61(in, currentPos, code, out, tmpoutpos); + break; + case 62: + encode62(in, currentPos, code, out, tmpoutpos); + break; + case 63: + encode63(in, currentPos, code, out, tmpoutpos); + break; + case 64: + encode64(in, currentPos, code, out, tmpoutpos); + break; + case 65: + encode65(in, currentPos, code, out, tmpoutpos); + break; + case 66: + encode66(in, currentPos, code, out, tmpoutpos); + break; + case 67: + encode67(in, currentPos, code, out, tmpoutpos); + break; + case 68: + encode68(in, currentPos, code, out, tmpoutpos); + break; + case 69: + encode69(in, currentPos, code, out, tmpoutpos); + break; + case 70: + encode70(in, currentPos, code, out, tmpoutpos); + break; + case 71: + encode71(in, currentPos, code, out, tmpoutpos); + break; + case 72: + encode72(in, currentPos, code, out, tmpoutpos); + break; + case 73: + encode73(in, currentPos, code, out, tmpoutpos); + break; + case 74: + encode74(in, currentPos, code, out, tmpoutpos); + break; + case 75: + encode75(in, currentPos, code, out, tmpoutpos); + break; + case 76: + encode76(in, currentPos, code, out, tmpoutpos); + break; + case 77: + encode77(in, currentPos, code, out, tmpoutpos); + break; + case 78: + encode78(in, currentPos, code, out, tmpoutpos); + break; + case 79: + encode79(in, currentPos, code, out, tmpoutpos); + break; + case 80: + encode80(in, currentPos, code, out, tmpoutpos); + break; + default: + throw new RuntimeException("unsupported code"); + }// end switch + tmpoutpos += 2; + currentPos = nextCurrentPos; + } + + outer: while (currentPos < finalin) { + mainloop: for (int selector = 0; selector < 8; selector++) { + int res = 0; + int compressedNum = codeNum[selector]; + if (finalin <= currentPos + compressedNum - 1) + compressedNum = finalin - currentPos; + int b = bitLength[selector]; + int max = 1 << b; + int i = 0; + for (; i < compressedNum; i++) { + if (Util.smallerorequalthan(max, in[currentPos + i])) + continue mainloop; + res = (res << b) + in[currentPos + i]; + } + if (compressedNum != codeNum[selector]) { + res <<= (codeNum[selector] - compressedNum) * b; + } + res |= selector << 28; + out[tmpoutpos++] = res; + + currentPos += compressedNum; + continue outer; + } + final int selector = 8; + out[tmpoutpos++] = in[currentPos++] | (selector << 28); + } + inpos.set(currentPos); + outpos.set(tmpoutpos); + } + + @Override + public void headlessUncompress(int[] in, IntWrapper inpos, int inlength, int[] out, IntWrapper outpos, int num) { + int currentPos = outpos.get(); + int tmpinpos = inpos.get(); + final int finalout = currentPos + num; + while (currentPos < finalout - 2 * 28) { + + int val = in[tmpinpos++]; + int valn = in[tmpinpos++]; + int header = val >>> 24; + switch (header) { + case 0: { + decode0(val, valn, out, currentPos); + currentPos+=56; + break; + } + case 1: { + decode1(val, valn, out, currentPos); + currentPos+=42; + break; + } + case 2: { + decode2(val, valn, out, currentPos); + currentPos+=37; + break; + } + case 3: { + decode3(val, valn, out, currentPos); + currentPos+=35; + break; + } + case 4: { + decode4(val, valn, out, currentPos); + currentPos+=33; + break; + } + case 5: { + decode5(val, valn, out, currentPos); + currentPos+=32; + break; + } + case 6: { + decode6(val, valn, out, currentPos); + currentPos+=31; + break; + } + case 7: { + decode7(val, valn, out, currentPos); + currentPos+=30; + break; + } + case 8: { + decode8(val, valn, out, currentPos); + currentPos+=29; + break; + } + case 9: { + decode9(val, valn, out, currentPos); + currentPos+=42; + break; + } + case 10: { + decode10(val, valn, out, currentPos); + currentPos+=28; + break; + } + case 11: { + decode11(val, valn, out, currentPos); + currentPos+=23; + break; + } + case 12: { + decode12(val, valn, out, currentPos); + currentPos+=21; + break; + } + case 13: { + decode13(val, valn, out, currentPos); + currentPos+=19; + break; + } + case 14: { + decode14(val, valn, out, currentPos); + currentPos+=18; + break; + } + case 15: { + decode15(val, valn, out, currentPos); + currentPos+=17; + break; + } + case 16: { + decode16(val, valn, out, currentPos); + currentPos+=16; + break; + } + case 17: { + decode17(val, valn, out, currentPos); + currentPos+=15; + break; + } + case 18: { + decode18(val, valn, out, currentPos); + currentPos+=37; + break; + } + case 19: { + decode19(val, valn, out, currentPos); + currentPos+=23; + break; + } + case 20: { + decode20(val, valn, out, currentPos); + currentPos+=18; + break; + } + case 21: { + decode21(val, valn, out, currentPos); + currentPos+=16; + break; + } + case 22: { + decode22(val, valn, out, currentPos); + currentPos+=14; + break; + } + case 23: { + decode23(val, valn, out, currentPos); + currentPos+=13; + break; + } + case 24: { + decode24(val, valn, out, currentPos); + currentPos+=12; + break; + } + case 25: { + decode25(val, valn, out, currentPos); + currentPos+=11; + break; + } + case 26: { + decode26(val, valn, out, currentPos); + currentPos+=10; + break; + } + case 27: { + decode27(val, valn, out, currentPos); + currentPos+=35; + break; + } + case 28: { + decode28(val, valn, out, currentPos); + currentPos+=21; + break; + } + case 29: { + decode29(val, valn, out, currentPos); + currentPos+=16; + break; + } + + case 30: { + decode30(val, valn, out, currentPos); + currentPos+=14; + break; + } + case 31: { + decode31(val, valn, out, currentPos); + currentPos+=12; + break; + } + case 32: { + decode32(val, valn, out, currentPos); + currentPos+=11; + break; + } + case 33: { + decode33(val, valn, out, currentPos); + currentPos+=10; + break; + } + case 34: { + decode34(val, valn, out, currentPos); + currentPos+=9; + break; + } + case 35: { + decode35(val, valn, out, currentPos); + currentPos+=8; + break; + } + case 36: { + decode36(val, valn, out, currentPos); + currentPos+=33; + break; + } + case 37: { + decode37(val, valn, out, currentPos); + currentPos+=19; + break; + } + case 38: { + decode38(val, valn, out, currentPos); + currentPos+=14; + break; + } + case 39: { + decode39(val, valn, out, currentPos); + currentPos+=12; + break; + } + case 40: { + decode40(val, valn, out, currentPos); + currentPos+=10; + break; + } + case 41: { + decode41(val, valn, out, currentPos); + currentPos+=9; + break; + } + case 42: { + decode42(val, valn, out, currentPos); + currentPos+=8; + break; + } + case 43: { + decode43(val, valn, out, currentPos); + currentPos+=7; + break; + } + case 44: { + decode44(val, valn, out, currentPos); + currentPos+=6; + break; + } + case 45: { + decode45(val, valn, out, currentPos); + currentPos+=32; + break; + } + case 46: { + decode46(val, valn, out, currentPos); + currentPos+=18; + break; + } + case 47: { + decode47(val, valn, out, currentPos); + currentPos+=13; + break; + } + case 48: { + decode48(val, valn, out, currentPos); + currentPos+=11; + break; + } + case 49: { + decode49(val, valn, out, currentPos); + currentPos+=9; + break; + } + case 50: { + decode50(val, valn, out, currentPos); + currentPos+=8; + break; + } + case 51: { + decode51(val, valn, out, currentPos); + currentPos+=7; + break; + } + case 52: { + decode52(val, valn, out, currentPos); + currentPos+=6; + break; + } + case 53: { + decode53(val, valn, out, currentPos); + currentPos+=5; + break; + } + case 54: { + decode54(val, valn, out, currentPos); + currentPos+=31; + break; + } + case 55: { + decode55(val, valn, out, currentPos); + currentPos+=17; + break; + } + case 56: { + decode56(val, valn, out, currentPos); + currentPos+=12; + break; + } + case 57: { + decode57(val, valn, out, currentPos); + currentPos+=10; + break; + } + case 58: { + decode58(val, valn, out, currentPos); + currentPos+=8; + break; + } + case 59: { + decode59(val, valn, out, currentPos); + currentPos+=7; + break; + } + case 60: { + decode60(val, valn, out, currentPos); + currentPos+=6; + break; + } + case 61: { + decode61(val, valn, out, currentPos); + currentPos+=5; + break; + } + case 62: { + decode62(val, valn, out, currentPos); + currentPos+=4; + break; + } + case 63: { + decode63(val, valn, out, currentPos); + currentPos+=30; + break; + } + case 64: { + decode64(val, valn, out, currentPos); + currentPos+=16; + break; + } + case 65: { + decode65(val, valn, out, currentPos); + currentPos+=11; + break; + } + case 66: { + decode66(val, valn, out, currentPos); + currentPos+=9; + break; + } + case 67: { + decode67(val, valn, out, currentPos); + currentPos+=7; + break; + } + case 68: { + decode68(val, valn, out, currentPos); + currentPos+=6; + break; + } + case 69: { + decode69(val, valn, out, currentPos); + currentPos+=5; + break; + } + case 70: { + decode70(val, valn, out, currentPos); + currentPos+=4; + break; + } + case 71: { + decode71(val, valn, out, currentPos); + currentPos+=3; + break; + } + case 72: { + decode72(val, valn, out, currentPos); + currentPos+=29; + break; + } + case 73: { + decode73(val, valn, out, currentPos); + currentPos+=15; + break; + } + case 74: { + decode74(val, valn, out, currentPos); + currentPos+=10; + break; + } + case 75: { + decode75(val, valn, out, currentPos); + currentPos+=8; + break; + } + case 76: { + decode76(val, valn, out, currentPos); + currentPos+=6; + break; + } + case 77: { + decode77(val, valn, out, currentPos); + currentPos+=5; + break; + } + case 78: { + decode78(val, valn, out, currentPos); + currentPos+=4; + break; + } + case 79: { + decode79(val, valn, out, currentPos); + currentPos+=3; + break; + } + case 80: { + decode80(val, valn, out, currentPos); + currentPos+=2; + break; + } + default: + throw new RuntimeException("Wrong code: " + header); + }// end switch + } // end while + + while (currentPos < finalout) { + int val = in[tmpinpos++]; + int header = val >>> 28; + switch (header) { + case 0: { // number : 28, bitwidth : 1 + final int howmany = finalout - currentPos < 28 ? finalout - currentPos : 28; + for (int k = 0; k < howmany; ++k) { + out[currentPos++] = (val << (k + 4)) >>> 31; + } + break; + } + case 1: { // number : 14, bitwidth : 2 + final int howmany = finalout - currentPos < 14 ? finalout - currentPos : 14; + for (int k = 0; k < howmany; ++k) { + out[currentPos++] = (val << (2 * k + 4)) >>> 30; + } + break; + } + case 2: { // number : 9, bitwidth : 3 + final int howmany = finalout - currentPos < 9 ? finalout - currentPos : 9; + for (int k = 0; k < howmany; ++k) { + out[currentPos++] = (val << (3 * k + 5)) >>> 29; + } + break; + } + case 3: { // number : 7, bitwidth : 4 + final int howmany = finalout - currentPos < 7 ? finalout - currentPos : 7; + for (int k = 0; k < howmany; ++k) { + out[currentPos++] = (val << (4 * k + 4)) >>> 28; + } + break; + } + case 4: { // number : 5, bitwidth : 5 + final int howmany = finalout - currentPos < 5 ? finalout - currentPos : 5; + for (int k = 0; k < howmany; ++k) { + out[currentPos++] = (val << (5 * k + 7)) >>> 27; + } + break; + } + case 5: { // number : 4, bitwidth : 7 + final int howmany = finalout - currentPos < 4 ? finalout - currentPos : 4; + for (int k = 0; k < howmany; ++k) { + out[currentPos++] = (val << (7 * k + 4)) >>> 25; + } + break; + } + case 6: { // number : 3, bitwidth : 9 + final int howmany = finalout - currentPos < 3 ? finalout - currentPos : 3; + for (int k = 0; k < howmany; ++k) { + out[currentPos++] = (val << (9 * k + 5)) >>> 23; + } + break; + } + case 7: { // number : 2, bitwidth : 14 + final int howmany = finalout - currentPos < 2 ? finalout - currentPos : 2; + for (int k = 0; k < howmany; ++k) { + out[currentPos++] = (val << (14 * k + 4)) >>> 18; + } + break; + } + case 8: { // number : 1, bitwidth : 28 + out[currentPos++] = (val << 4) >>> 4; + break; + } + default: { + throw new RuntimeException("shouldn't happen"); + } + } + } + + outpos.set(finalout); + inpos.set(tmpinpos); + + } + + @Override + public int maxHeadlessCompressedLength(IntWrapper compressedPositions, int inlength) { + compressedPositions.add(inlength); + return inlength; + } +} diff --git a/src/main/java/me/lemire/integercompression/IntCompressor.java b/src/main/java/me/lemire/integercompression/IntCompressor.java new file mode 100644 index 0000000..30f755c --- /dev/null +++ b/src/main/java/me/lemire/integercompression/IntCompressor.java @@ -0,0 +1,65 @@ +package me.lemire.integercompression; + +import java.util.Arrays; + +/** + * This is a convenience class that wraps a codec to provide + * a "friendly" API. + * + */ +public class IntCompressor { + + + SkippableIntegerCODEC codec; + /** + * Constructor wrapping a codec. + * + * @param c the underlying codec + */ + public IntCompressor(SkippableIntegerCODEC c) { + codec = c; + } + + /** + * Constructor with default codec. + */ + public IntCompressor() { + codec = new SkippableComposition(new BinaryPacking(), + new VariableByte()); + } + + /** + * Compress an array and returns the compressed result as a new array. + * + * @param input array to be compressed + * @return compressed array + */ + public int[] compress(int[] input) { + int maxCompressedLength = codec.maxHeadlessCompressedLength(new IntWrapper(0), input.length); + int[] compressed = new int[maxCompressedLength + 1]; // +1 to store the length of the input + // Store at index=0 the length of the input, hence enabling .headlessCompress + compressed[0] = input.length; + IntWrapper outpos = new IntWrapper(1); + codec.headlessCompress(input, new IntWrapper(0), input.length, compressed, outpos); + compressed = Arrays.copyOf(compressed,outpos.intValue()); + return compressed; + } + + /** + * Uncompress an array and returns the uncompressed result as a new array. + * + * @param compressed compressed array + * @return uncompressed array + */ + public int[] uncompress(int[] compressed) { + // Read at index=0 the length of the input, hence enabling .headlessUncompress + int[] decompressed = new int[compressed[0]]; + IntWrapper inpos = new IntWrapper(1); + codec.headlessUncompress(compressed, inpos, + compressed.length - inpos.intValue(), + decompressed, new IntWrapper(0), + decompressed.length); + return decompressed; + } + +} diff --git a/src/main/java/me/lemire/integercompression/IntWrapper.java b/src/main/java/me/lemire/integercompression/IntWrapper.java index d875eb4..6bd8f0b 100644 --- a/src/main/java/me/lemire/integercompression/IntWrapper.java +++ b/src/main/java/me/lemire/integercompression/IntWrapper.java @@ -12,76 +12,80 @@ * @author dwu */ public final class IntWrapper extends Number { - private static final long serialVersionUID = 1L; - private int value; + private static final long serialVersionUID = 1L; + private int value; - /** - * Constructor: value set to 0. - */ - public IntWrapper() { - this(0); - } + /** + * Constructor: value set to 0. + */ + public IntWrapper() { + this(0); + } - /** - * Construction: value set to provided argument. - * - * @param v value to wrap - */ - public IntWrapper(final int v) { - this.value = v; - } + /** + * Construction: value set to provided argument. + * + * @param v + * value to wrap + */ + public IntWrapper(final int v) { + this.value = v; + } - /** - * @param v - */ - public void add(int v) { - this.value += v; - } + /** + * add the provided value to the integer + * @param v value to add + */ + public void add(int v) { + this.value += v; + } - @Override - public double doubleValue() { - return this.value; - } + @Override + public double doubleValue() { + return this.value; + } - @Override - public float floatValue() { - return this.value; - } + @Override + public float floatValue() { + return this.value; + } - /** - * @return the integer value - */ - public int get() { - return this.value; - } + /** + * @return the integer value + */ + public int get() { + return this.value; + } - /** - * add 1 to the integer value - */ - public void increment() { - this.value++; - } + /** + * add 1 to the integer value + */ + public void increment() { + this.value++; + } - @Override - public int intValue() { - return this.value; - } + @Override + public int intValue() { + return this.value; + } - @Override - public long longValue() { - return this.value; - } + @Override + public long longValue() { + return this.value; + } - /** - * Set the value to that of the specified integer. - * @param value specified integer value - */ - public void set(final int value) { - this.value = value; - } + /** + * Set the value to that of the specified integer. + * + * @param value + * specified integer value + */ + public void set(final int value) { + this.value = value; + } - @Override - public String toString() { - return Integer.toString(this.value); - } + @Override + public String toString() { + return Integer.toString(this.value); + } } diff --git a/src/main/java/me/lemire/integercompression/IntegerCODEC.java b/src/main/java/me/lemire/integercompression/IntegerCODEC.java index 9a27f4a..1dd9a4c 100644 --- a/src/main/java/me/lemire/integercompression/IntegerCODEC.java +++ b/src/main/java/me/lemire/integercompression/IntegerCODEC.java @@ -7,43 +7,54 @@ package me.lemire.integercompression; - /** * Interface describing a standard CODEC to compress integers. * * @author Daniel Lemire - * + * */ public interface IntegerCODEC { - /** - * Compress data from an array to another array. - * - * Both inpos and outpos are modified to represent how much - * data was read and written to - * if 12 ints (inlength = 12) are compressed to 3 ints, then - * inpos will be incremented by 12 while outpos will be - * incremented by 3 - * we use IntWrapper to pass the values by reference. - * @param in input array - * @param inpos location in the input array - * @param inlength how many integers to compress - * @param out output array - * @param outpos where to write in the output array - */ - public void compress(int[] in, IntWrapper inpos, int inlength, int[] out, IntWrapper outpos); - - /** - * Uncompress data from an array to another array. - * - * Both inpos and outpos parameters are modified to indicate new positions after read/write. - * - * @param in array containing data in compressed form - * @param inpos where to start reading in the array - * @param inlength length of the compressed data (ignored by some schemes) - * @param out array where to write the compressed output - * @param outpos where to write the compressed output in out - */ - public void uncompress(int[] in, IntWrapper inpos, int inlength, int[] out, IntWrapper outpos); + /** + * Compress data from an array to another array. + * + * Both inpos and outpos are modified to represent how much data was + * read and written to. If 12 ints (inlength = 12) are compressed to 3 + * ints, then inpos will be incremented by 12 while outpos will be + * incremented by 3. We use IntWrapper to pass the values by reference. + * + * @param in + * input array + * @param inpos + * where to start reading in the array + * @param inlength + * how many integers to compress + * @param out + * output array + * @param outpos + * where to write in the output array + */ + public void compress(int[] in, IntWrapper inpos, int inlength, + int[] out, IntWrapper outpos); + /** + * Uncompress data from an array to another array. + * + * Both inpos and outpos parameters are modified to indicate new + * positions after read/write. + * + * @param in + * array containing data in compressed form + * @param inpos + * where to start reading in the array + * @param inlength + * length of the compressed data (ignored by some + * schemes) + * @param out + * array where to write the compressed output + * @param outpos + * where to start writing the uncompressed output in out + */ + public void uncompress(int[] in, IntWrapper inpos, int inlength, + int[] out, IntWrapper outpos); } diff --git a/src/main/java/me/lemire/integercompression/IntegratedBinaryPacking.java b/src/main/java/me/lemire/integercompression/IntegratedBinaryPacking.java deleted file mode 100644 index 4b058ae..0000000 --- a/src/main/java/me/lemire/integercompression/IntegratedBinaryPacking.java +++ /dev/null @@ -1,79 +0,0 @@ -/** - * This code is released under the - * Apache License Version 2.0 http://www.apache.org/licenses/. - * - * (c) Daniel Lemire, http://lemire.me/en/ - */ - -package me.lemire.integercompression; - -/** - * @author Daniel Lemire - * - */ -public class IntegratedBinaryPacking implements IntegratedIntegerCODEC { - - @Override - public void compress(int[] in, IntWrapper inpos, int inlength, int[] out, IntWrapper outpos) { - inlength = inlength / 128 * 128; - if(inlength == 0) return; - out[outpos.get()] = inlength; - outpos.increment(); - int tmpoutpos = outpos.get(); - int initoffset = 0; - for (int s = inpos.get(); s < inpos.get() + inlength; s += 32 * 4) { - final int mbits1 = Util.maxdiffbits(initoffset, in, s, 32); - int initoffset2 = in[s + 31]; - final int mbits2 = Util.maxdiffbits(initoffset2, in, s + 32, 32); - int initoffset3 = in[s + 32 + 31]; - final int mbits3 = Util.maxdiffbits(initoffset3, in, s + 2 * 32, 32); - int initoffset4 = in[s + 2 * 32 + 31]; - final int mbits4 = Util.maxdiffbits(initoffset4, in, s + 3 * 32, 32); - out[tmpoutpos++] = (mbits1 << 24) | (mbits2 << 16) | (mbits3 << 8) - | (mbits4); - IntegratedBitPacking.integratedpack(initoffset, in, s, out, tmpoutpos, mbits1); - tmpoutpos += mbits1; - IntegratedBitPacking.integratedpack(initoffset2, in, s + 32, out, tmpoutpos, mbits2); - tmpoutpos += mbits2; - IntegratedBitPacking.integratedpack(initoffset3, in, s + 2 * 32, out, tmpoutpos, mbits3); - tmpoutpos += mbits3; - IntegratedBitPacking.integratedpack(initoffset4, in, s + 3 * 32, out, tmpoutpos, mbits4); - tmpoutpos += mbits4; - initoffset = in[s + 3 * 32 + 31]; - } - inpos.add(inlength); - outpos.set(tmpoutpos); - } - - @Override - public void uncompress(int[] in, IntWrapper inpos, int inlength, int[] out, IntWrapper outpos) { - if(inlength == 0) return; - final int outlength = in[inpos.get()]; - inpos.increment(); - int tmpinpos = inpos.get(); - int initoffset = 0; - for (int s = outpos.get(); s < outpos.get() + outlength; s += 32 * 4) { - final int mbits1 = (in[tmpinpos] >>> 24); - final int mbits2 = (in[tmpinpos] >>> 16) & 0xFF; - final int mbits3 = (in[tmpinpos] >>> 8) & 0xFF; - final int mbits4 = (in[tmpinpos]) & 0xFF; - ++tmpinpos; - IntegratedBitPacking.integratedunpack(initoffset, in, tmpinpos, out, s, mbits1); - tmpinpos += mbits1; - initoffset = out[s + 31]; - IntegratedBitPacking.integratedunpack(initoffset, in, tmpinpos, out, s + 32, mbits2); - tmpinpos += mbits2; - initoffset = out[s + 32 + 31]; - IntegratedBitPacking.integratedunpack(initoffset, in, tmpinpos, out, s + 2 * 32, mbits3); - tmpinpos += mbits3; - initoffset = out[s + 2 * 32 + 31]; - IntegratedBitPacking.integratedunpack(initoffset, in, tmpinpos, out, s + 3 * 32, mbits4); - tmpinpos += mbits4; - initoffset = out[s + 3 * 32 + 31]; - } - outpos.add(outlength); - inpos.set(tmpinpos); - } - - -} diff --git a/src/main/java/me/lemire/integercompression/IntegratedBitPacking.java b/src/main/java/me/lemire/integercompression/IntegratedBitPacking.java deleted file mode 100644 index 7da8936..0000000 --- a/src/main/java/me/lemire/integercompression/IntegratedBitPacking.java +++ /dev/null @@ -1,4810 +0,0 @@ -/** - * This code is released under the - * Apache License Version 2.0 http://www.apache.org/licenses/. - * - * (c) Daniel Lemire, http://lemire.me/en/ - */ - -package me.lemire.integercompression; - -import java.util.Arrays; - -/** - * "Integrated" bit packing routines: they include - * both the bit packing and the differential coding. - * - * @author Daniel Lemire - * - */ -public final class IntegratedBitPacking { - - - protected static void integratedpack1(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (in[0 + inpos] - initoffset) - | ((in[1 + inpos] - in[1 + inpos - 1]) << 1) - | ((in[2 + inpos] - in[2 + inpos - 1]) << 2) - | ((in[3 + inpos] - in[3 + inpos - 1]) << 3) - | ((in[4 + inpos] - in[4 + inpos - 1]) << 4) - | ((in[5 + inpos] - in[5 + inpos - 1]) << 5) - | ((in[6 + inpos] - in[6 + inpos - 1]) << 6) - | ((in[7 + inpos] - in[7 + inpos - 1]) << 7) - | ((in[8 + inpos] - in[8 + inpos - 1]) << 8) - | ((in[9 + inpos] - in[9 + inpos - 1]) << 9) - | ((in[10 + inpos] - in[10 + inpos - 1]) << 10) - | ((in[11 + inpos] - in[11 + inpos - 1]) << 11) - | ((in[12 + inpos] - in[12 + inpos - 1]) << 12) - | ((in[13 + inpos] - in[13 + inpos - 1]) << 13) - | ((in[14 + inpos] - in[14 + inpos - 1]) << 14) - | ((in[15 + inpos] - in[15 + inpos - 1]) << 15) - | ((in[16 + inpos] - in[16 + inpos - 1]) << 16) - | ((in[17 + inpos] - in[17 + inpos - 1]) << 17) - | ((in[18 + inpos] - in[18 + inpos - 1]) << 18) - | ((in[19 + inpos] - in[19 + inpos - 1]) << 19) - | ((in[20 + inpos] - in[20 + inpos - 1]) << 20) - | ((in[21 + inpos] - in[21 + inpos - 1]) << 21) - | ((in[22 + inpos] - in[22 + inpos - 1]) << 22) - | ((in[23 + inpos] - in[23 + inpos - 1]) << 23) - | ((in[24 + inpos] - in[24 + inpos - 1]) << 24) - | ((in[25 + inpos] - in[25 + inpos - 1]) << 25) - | ((in[26 + inpos] - in[26 + inpos - 1]) << 26) - | ((in[27 + inpos] - in[27 + inpos - 1]) << 27) - | ((in[28 + inpos] - in[28 + inpos - 1]) << 28) - | ((in[29 + inpos] - in[29 + inpos - 1]) << 29) - | ((in[30 + inpos] - in[30 + inpos - 1]) << 30) - | ((in[31 + inpos] - in[31 + inpos - 1]) << 31) - ; - } - - - protected static void integratedpack2(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (in[0 + inpos] - initoffset) - | ((in[1 + inpos] - in[1 + inpos - 1]) << 2) - | ((in[2 + inpos] - in[2 + inpos - 1]) << 4) - | ((in[3 + inpos] - in[3 + inpos - 1]) << 6) - | ((in[4 + inpos] - in[4 + inpos - 1]) << 8) - | ((in[5 + inpos] - in[5 + inpos - 1]) << 10) - | ((in[6 + inpos] - in[6 + inpos - 1]) << 12) - | ((in[7 + inpos] - in[7 + inpos - 1]) << 14) - | ((in[8 + inpos] - in[8 + inpos - 1]) << 16) - | ((in[9 + inpos] - in[9 + inpos - 1]) << 18) - | ((in[10 + inpos] - in[10 + inpos - 1]) << 20) - | ((in[11 + inpos] - in[11 + inpos - 1]) << 22) - | ((in[12 + inpos] - in[12 + inpos - 1]) << 24) - | ((in[13 + inpos] - in[13 + inpos - 1]) << 26) - | ((in[14 + inpos] - in[14 + inpos - 1]) << 28) - | ((in[15 + inpos] - in[15 + inpos - 1]) << 30) - ; - out[1 + outpos] = (in[16 + inpos] - in[16 + inpos - 1]) - | ((in[17 + inpos] - in[17 + inpos - 1]) << 2) - | ((in[18 + inpos] - in[18 + inpos - 1]) << 4) - | ((in[19 + inpos] - in[19 + inpos - 1]) << 6) - | ((in[20 + inpos] - in[20 + inpos - 1]) << 8) - | ((in[21 + inpos] - in[21 + inpos - 1]) << 10) - | ((in[22 + inpos] - in[22 + inpos - 1]) << 12) - | ((in[23 + inpos] - in[23 + inpos - 1]) << 14) - | ((in[24 + inpos] - in[24 + inpos - 1]) << 16) - | ((in[25 + inpos] - in[25 + inpos - 1]) << 18) - | ((in[26 + inpos] - in[26 + inpos - 1]) << 20) - | ((in[27 + inpos] - in[27 + inpos - 1]) << 22) - | ((in[28 + inpos] - in[28 + inpos - 1]) << 24) - | ((in[29 + inpos] - in[29 + inpos - 1]) << 26) - | ((in[30 + inpos] - in[30 + inpos - 1]) << 28) - | ((in[31 + inpos] - in[31 + inpos - 1]) << 30) - ; - } - - - protected static void integratedpack3(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (in[0 + inpos] - initoffset) - | ((in[1 + inpos] - in[1 + inpos - 1]) << 3) - | ((in[2 + inpos] - in[2 + inpos - 1]) << 6) - | ((in[3 + inpos] - in[3 + inpos - 1]) << 9) - | ((in[4 + inpos] - in[4 + inpos - 1]) << 12) - | ((in[5 + inpos] - in[5 + inpos - 1]) << 15) - | ((in[6 + inpos] - in[6 + inpos - 1]) << 18) - | ((in[7 + inpos] - in[7 + inpos - 1]) << 21) - | ((in[8 + inpos] - in[8 + inpos - 1]) << 24) - | ((in[9 + inpos] - in[9 + inpos - 1]) << 27) - | ((in[10 + inpos] - in[10 + inpos - 1]) << 30) - ; - out[1 + outpos] = (in[10 + inpos] - in[10 + inpos - 1]) >>> (3 - 1) - | ((in[11 + inpos] - in[11 + inpos - 1]) << 1) - | ((in[12 + inpos] - in[12 + inpos - 1]) << 4) - | ((in[13 + inpos] - in[13 + inpos - 1]) << 7) - | ((in[14 + inpos] - in[14 + inpos - 1]) << 10) - | ((in[15 + inpos] - in[15 + inpos - 1]) << 13) - | ((in[16 + inpos] - in[16 + inpos - 1]) << 16) - | ((in[17 + inpos] - in[17 + inpos - 1]) << 19) - | ((in[18 + inpos] - in[18 + inpos - 1]) << 22) - | ((in[19 + inpos] - in[19 + inpos - 1]) << 25) - | ((in[20 + inpos] - in[20 + inpos - 1]) << 28) - | ((in[21 + inpos] - in[21 + inpos - 1]) << 31) - ; - out[2 + outpos] = (in[21 + inpos] - in[21 + inpos - 1]) >>> (3 - 2) - | ((in[22 + inpos] - in[22 + inpos - 1]) << 2) - | ((in[23 + inpos] - in[23 + inpos - 1]) << 5) - | ((in[24 + inpos] - in[24 + inpos - 1]) << 8) - | ((in[25 + inpos] - in[25 + inpos - 1]) << 11) - | ((in[26 + inpos] - in[26 + inpos - 1]) << 14) - | ((in[27 + inpos] - in[27 + inpos - 1]) << 17) - | ((in[28 + inpos] - in[28 + inpos - 1]) << 20) - | ((in[29 + inpos] - in[29 + inpos - 1]) << 23) - | ((in[30 + inpos] - in[30 + inpos - 1]) << 26) - | ((in[31 + inpos] - in[31 + inpos - 1]) << 29) - ; - } - - - protected static void integratedpack4(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (in[0 + inpos] - initoffset) - | ((in[1 + inpos] - in[1 + inpos - 1]) << 4) - | ((in[2 + inpos] - in[2 + inpos - 1]) << 8) - | ((in[3 + inpos] - in[3 + inpos - 1]) << 12) - | ((in[4 + inpos] - in[4 + inpos - 1]) << 16) - | ((in[5 + inpos] - in[5 + inpos - 1]) << 20) - | ((in[6 + inpos] - in[6 + inpos - 1]) << 24) - | ((in[7 + inpos] - in[7 + inpos - 1]) << 28) - ; - out[1 + outpos] = (in[8 + inpos] - in[8 + inpos - 1]) - | ((in[9 + inpos] - in[9 + inpos - 1]) << 4) - | ((in[10 + inpos] - in[10 + inpos - 1]) << 8) - | ((in[11 + inpos] - in[11 + inpos - 1]) << 12) - | ((in[12 + inpos] - in[12 + inpos - 1]) << 16) - | ((in[13 + inpos] - in[13 + inpos - 1]) << 20) - | ((in[14 + inpos] - in[14 + inpos - 1]) << 24) - | ((in[15 + inpos] - in[15 + inpos - 1]) << 28) - ; - out[2 + outpos] = (in[16 + inpos] - in[16 + inpos - 1]) - | ((in[17 + inpos] - in[17 + inpos - 1]) << 4) - | ((in[18 + inpos] - in[18 + inpos - 1]) << 8) - | ((in[19 + inpos] - in[19 + inpos - 1]) << 12) - | ((in[20 + inpos] - in[20 + inpos - 1]) << 16) - | ((in[21 + inpos] - in[21 + inpos - 1]) << 20) - | ((in[22 + inpos] - in[22 + inpos - 1]) << 24) - | ((in[23 + inpos] - in[23 + inpos - 1]) << 28) - ; - out[3 + outpos] = (in[24 + inpos] - in[24 + inpos - 1]) - | ((in[25 + inpos] - in[25 + inpos - 1]) << 4) - | ((in[26 + inpos] - in[26 + inpos - 1]) << 8) - | ((in[27 + inpos] - in[27 + inpos - 1]) << 12) - | ((in[28 + inpos] - in[28 + inpos - 1]) << 16) - | ((in[29 + inpos] - in[29 + inpos - 1]) << 20) - | ((in[30 + inpos] - in[30 + inpos - 1]) << 24) - | ((in[31 + inpos] - in[31 + inpos - 1]) << 28) - ; - } - - - protected static void integratedpack5(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (in[0 + inpos] - initoffset) - | ((in[1 + inpos] - in[1 + inpos - 1]) << 5) - | ((in[2 + inpos] - in[2 + inpos - 1]) << 10) - | ((in[3 + inpos] - in[3 + inpos - 1]) << 15) - | ((in[4 + inpos] - in[4 + inpos - 1]) << 20) - | ((in[5 + inpos] - in[5 + inpos - 1]) << 25) - | ((in[6 + inpos] - in[6 + inpos - 1]) << 30) - ; - out[1 + outpos] = (in[6 + inpos] - in[6 + inpos - 1]) >>> (5 - 3) - | ((in[7 + inpos] - in[7 + inpos - 1]) << 3) - | ((in[8 + inpos] - in[8 + inpos - 1]) << 8) - | ((in[9 + inpos] - in[9 + inpos - 1]) << 13) - | ((in[10 + inpos] - in[10 + inpos - 1]) << 18) - | ((in[11 + inpos] - in[11 + inpos - 1]) << 23) - | ((in[12 + inpos] - in[12 + inpos - 1]) << 28) - ; - out[2 + outpos] = (in[12 + inpos] - in[12 + inpos - 1]) >>> (5 - 1) - | ((in[13 + inpos] - in[13 + inpos - 1]) << 1) - | ((in[14 + inpos] - in[14 + inpos - 1]) << 6) - | ((in[15 + inpos] - in[15 + inpos - 1]) << 11) - | ((in[16 + inpos] - in[16 + inpos - 1]) << 16) - | ((in[17 + inpos] - in[17 + inpos - 1]) << 21) - | ((in[18 + inpos] - in[18 + inpos - 1]) << 26) - | ((in[19 + inpos] - in[19 + inpos - 1]) << 31) - ; - out[3 + outpos] = (in[19 + inpos] - in[19 + inpos - 1]) >>> (5 - 4) - | ((in[20 + inpos] - in[20 + inpos - 1]) << 4) - | ((in[21 + inpos] - in[21 + inpos - 1]) << 9) - | ((in[22 + inpos] - in[22 + inpos - 1]) << 14) - | ((in[23 + inpos] - in[23 + inpos - 1]) << 19) - | ((in[24 + inpos] - in[24 + inpos - 1]) << 24) - | ((in[25 + inpos] - in[25 + inpos - 1]) << 29) - ; - out[4 + outpos] = (in[25 + inpos] - in[25 + inpos - 1]) >>> (5 - 2) - | ((in[26 + inpos] - in[26 + inpos - 1]) << 2) - | ((in[27 + inpos] - in[27 + inpos - 1]) << 7) - | ((in[28 + inpos] - in[28 + inpos - 1]) << 12) - | ((in[29 + inpos] - in[29 + inpos - 1]) << 17) - | ((in[30 + inpos] - in[30 + inpos - 1]) << 22) - | ((in[31 + inpos] - in[31 + inpos - 1]) << 27) - ; - } - - - protected static void integratedpack6(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (in[0 + inpos] - initoffset) - | ((in[1 + inpos] - in[1 + inpos - 1]) << 6) - | ((in[2 + inpos] - in[2 + inpos - 1]) << 12) - | ((in[3 + inpos] - in[3 + inpos - 1]) << 18) - | ((in[4 + inpos] - in[4 + inpos - 1]) << 24) - | ((in[5 + inpos] - in[5 + inpos - 1]) << 30) - ; - out[1 + outpos] = (in[5 + inpos] - in[5 + inpos - 1]) >>> (6 - 4) - | ((in[6 + inpos] - in[6 + inpos - 1]) << 4) - | ((in[7 + inpos] - in[7 + inpos - 1]) << 10) - | ((in[8 + inpos] - in[8 + inpos - 1]) << 16) - | ((in[9 + inpos] - in[9 + inpos - 1]) << 22) - | ((in[10 + inpos] - in[10 + inpos - 1]) << 28) - ; - out[2 + outpos] = (in[10 + inpos] - in[10 + inpos - 1]) >>> (6 - 2) - | ((in[11 + inpos] - in[11 + inpos - 1]) << 2) - | ((in[12 + inpos] - in[12 + inpos - 1]) << 8) - | ((in[13 + inpos] - in[13 + inpos - 1]) << 14) - | ((in[14 + inpos] - in[14 + inpos - 1]) << 20) - | ((in[15 + inpos] - in[15 + inpos - 1]) << 26) - ; - out[3 + outpos] = (in[16 + inpos] - in[16 + inpos - 1]) - | ((in[17 + inpos] - in[17 + inpos - 1]) << 6) - | ((in[18 + inpos] - in[18 + inpos - 1]) << 12) - | ((in[19 + inpos] - in[19 + inpos - 1]) << 18) - | ((in[20 + inpos] - in[20 + inpos - 1]) << 24) - | ((in[21 + inpos] - in[21 + inpos - 1]) << 30) - ; - out[4 + outpos] = (in[21 + inpos] - in[21 + inpos - 1]) >>> (6 - 4) - | ((in[22 + inpos] - in[22 + inpos - 1]) << 4) - | ((in[23 + inpos] - in[23 + inpos - 1]) << 10) - | ((in[24 + inpos] - in[24 + inpos - 1]) << 16) - | ((in[25 + inpos] - in[25 + inpos - 1]) << 22) - | ((in[26 + inpos] - in[26 + inpos - 1]) << 28) - ; - out[5 + outpos] = (in[26 + inpos] - in[26 + inpos - 1]) >>> (6 - 2) - | ((in[27 + inpos] - in[27 + inpos - 1]) << 2) - | ((in[28 + inpos] - in[28 + inpos - 1]) << 8) - | ((in[29 + inpos] - in[29 + inpos - 1]) << 14) - | ((in[30 + inpos] - in[30 + inpos - 1]) << 20) - | ((in[31 + inpos] - in[31 + inpos - 1]) << 26) - ; - } - - - protected static void integratedpack7(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (in[0 + inpos] - initoffset) - | ((in[1 + inpos] - in[1 + inpos - 1]) << 7) - | ((in[2 + inpos] - in[2 + inpos - 1]) << 14) - | ((in[3 + inpos] - in[3 + inpos - 1]) << 21) - | ((in[4 + inpos] - in[4 + inpos - 1]) << 28) - ; - out[1 + outpos] = (in[4 + inpos] - in[4 + inpos - 1]) >>> (7 - 3) - | ((in[5 + inpos] - in[5 + inpos - 1]) << 3) - | ((in[6 + inpos] - in[6 + inpos - 1]) << 10) - | ((in[7 + inpos] - in[7 + inpos - 1]) << 17) - | ((in[8 + inpos] - in[8 + inpos - 1]) << 24) - | ((in[9 + inpos] - in[9 + inpos - 1]) << 31) - ; - out[2 + outpos] = (in[9 + inpos] - in[9 + inpos - 1]) >>> (7 - 6) - | ((in[10 + inpos] - in[10 + inpos - 1]) << 6) - | ((in[11 + inpos] - in[11 + inpos - 1]) << 13) - | ((in[12 + inpos] - in[12 + inpos - 1]) << 20) - | ((in[13 + inpos] - in[13 + inpos - 1]) << 27) - ; - out[3 + outpos] = (in[13 + inpos] - in[13 + inpos - 1]) >>> (7 - 2) - | ((in[14 + inpos] - in[14 + inpos - 1]) << 2) - | ((in[15 + inpos] - in[15 + inpos - 1]) << 9) - | ((in[16 + inpos] - in[16 + inpos - 1]) << 16) - | ((in[17 + inpos] - in[17 + inpos - 1]) << 23) - | ((in[18 + inpos] - in[18 + inpos - 1]) << 30) - ; - out[4 + outpos] = (in[18 + inpos] - in[18 + inpos - 1]) >>> (7 - 5) - | ((in[19 + inpos] - in[19 + inpos - 1]) << 5) - | ((in[20 + inpos] - in[20 + inpos - 1]) << 12) - | ((in[21 + inpos] - in[21 + inpos - 1]) << 19) - | ((in[22 + inpos] - in[22 + inpos - 1]) << 26) - ; - out[5 + outpos] = (in[22 + inpos] - in[22 + inpos - 1]) >>> (7 - 1) - | ((in[23 + inpos] - in[23 + inpos - 1]) << 1) - | ((in[24 + inpos] - in[24 + inpos - 1]) << 8) - | ((in[25 + inpos] - in[25 + inpos - 1]) << 15) - | ((in[26 + inpos] - in[26 + inpos - 1]) << 22) - | ((in[27 + inpos] - in[27 + inpos - 1]) << 29) - ; - out[6 + outpos] = (in[27 + inpos] - in[27 + inpos - 1]) >>> (7 - 4) - | ((in[28 + inpos] - in[28 + inpos - 1]) << 4) - | ((in[29 + inpos] - in[29 + inpos - 1]) << 11) - | ((in[30 + inpos] - in[30 + inpos - 1]) << 18) - | ((in[31 + inpos] - in[31 + inpos - 1]) << 25) - ; - } - - - protected static void integratedpack8(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (in[0 + inpos] - initoffset) - | ((in[1 + inpos] - in[1 + inpos - 1]) << 8) - | ((in[2 + inpos] - in[2 + inpos - 1]) << 16) - | ((in[3 + inpos] - in[3 + inpos - 1]) << 24) - ; - out[1 + outpos] = (in[4 + inpos] - in[4 + inpos - 1]) - | ((in[5 + inpos] - in[5 + inpos - 1]) << 8) - | ((in[6 + inpos] - in[6 + inpos - 1]) << 16) - | ((in[7 + inpos] - in[7 + inpos - 1]) << 24) - ; - out[2 + outpos] = (in[8 + inpos] - in[8 + inpos - 1]) - | ((in[9 + inpos] - in[9 + inpos - 1]) << 8) - | ((in[10 + inpos] - in[10 + inpos - 1]) << 16) - | ((in[11 + inpos] - in[11 + inpos - 1]) << 24) - ; - out[3 + outpos] = (in[12 + inpos] - in[12 + inpos - 1]) - | ((in[13 + inpos] - in[13 + inpos - 1]) << 8) - | ((in[14 + inpos] - in[14 + inpos - 1]) << 16) - | ((in[15 + inpos] - in[15 + inpos - 1]) << 24) - ; - out[4 + outpos] = (in[16 + inpos] - in[16 + inpos - 1]) - | ((in[17 + inpos] - in[17 + inpos - 1]) << 8) - | ((in[18 + inpos] - in[18 + inpos - 1]) << 16) - | ((in[19 + inpos] - in[19 + inpos - 1]) << 24) - ; - out[5 + outpos] = (in[20 + inpos] - in[20 + inpos - 1]) - | ((in[21 + inpos] - in[21 + inpos - 1]) << 8) - | ((in[22 + inpos] - in[22 + inpos - 1]) << 16) - | ((in[23 + inpos] - in[23 + inpos - 1]) << 24) - ; - out[6 + outpos] = (in[24 + inpos] - in[24 + inpos - 1]) - | ((in[25 + inpos] - in[25 + inpos - 1]) << 8) - | ((in[26 + inpos] - in[26 + inpos - 1]) << 16) - | ((in[27 + inpos] - in[27 + inpos - 1]) << 24) - ; - out[7 + outpos] = (in[28 + inpos] - in[28 + inpos - 1]) - | ((in[29 + inpos] - in[29 + inpos - 1]) << 8) - | ((in[30 + inpos] - in[30 + inpos - 1]) << 16) - | ((in[31 + inpos] - in[31 + inpos - 1]) << 24) - ; - } - - - protected static void integratedpack9(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (in[0 + inpos] - initoffset) - | ((in[1 + inpos] - in[1 + inpos - 1]) << 9) - | ((in[2 + inpos] - in[2 + inpos - 1]) << 18) - | ((in[3 + inpos] - in[3 + inpos - 1]) << 27) - ; - out[1 + outpos] = (in[3 + inpos] - in[3 + inpos - 1]) >>> (9 - 4) - | ((in[4 + inpos] - in[4 + inpos - 1]) << 4) - | ((in[5 + inpos] - in[5 + inpos - 1]) << 13) - | ((in[6 + inpos] - in[6 + inpos - 1]) << 22) - | ((in[7 + inpos] - in[7 + inpos - 1]) << 31) - ; - out[2 + outpos] = (in[7 + inpos] - in[7 + inpos - 1]) >>> (9 - 8) - | ((in[8 + inpos] - in[8 + inpos - 1]) << 8) - | ((in[9 + inpos] - in[9 + inpos - 1]) << 17) - | ((in[10 + inpos] - in[10 + inpos - 1]) << 26) - ; - out[3 + outpos] = (in[10 + inpos] - in[10 + inpos - 1]) >>> (9 - 3) - | ((in[11 + inpos] - in[11 + inpos - 1]) << 3) - | ((in[12 + inpos] - in[12 + inpos - 1]) << 12) - | ((in[13 + inpos] - in[13 + inpos - 1]) << 21) - | ((in[14 + inpos] - in[14 + inpos - 1]) << 30) - ; - out[4 + outpos] = (in[14 + inpos] - in[14 + inpos - 1]) >>> (9 - 7) - | ((in[15 + inpos] - in[15 + inpos - 1]) << 7) - | ((in[16 + inpos] - in[16 + inpos - 1]) << 16) - | ((in[17 + inpos] - in[17 + inpos - 1]) << 25) - ; - out[5 + outpos] = (in[17 + inpos] - in[17 + inpos - 1]) >>> (9 - 2) - | ((in[18 + inpos] - in[18 + inpos - 1]) << 2) - | ((in[19 + inpos] - in[19 + inpos - 1]) << 11) - | ((in[20 + inpos] - in[20 + inpos - 1]) << 20) - | ((in[21 + inpos] - in[21 + inpos - 1]) << 29) - ; - out[6 + outpos] = (in[21 + inpos] - in[21 + inpos - 1]) >>> (9 - 6) - | ((in[22 + inpos] - in[22 + inpos - 1]) << 6) - | ((in[23 + inpos] - in[23 + inpos - 1]) << 15) - | ((in[24 + inpos] - in[24 + inpos - 1]) << 24) - ; - out[7 + outpos] = (in[24 + inpos] - in[24 + inpos - 1]) >>> (9 - 1) - | ((in[25 + inpos] - in[25 + inpos - 1]) << 1) - | ((in[26 + inpos] - in[26 + inpos - 1]) << 10) - | ((in[27 + inpos] - in[27 + inpos - 1]) << 19) - | ((in[28 + inpos] - in[28 + inpos - 1]) << 28) - ; - out[8 + outpos] = (in[28 + inpos] - in[28 + inpos - 1]) >>> (9 - 5) - | ((in[29 + inpos] - in[29 + inpos - 1]) << 5) - | ((in[30 + inpos] - in[30 + inpos - 1]) << 14) - | ((in[31 + inpos] - in[31 + inpos - 1]) << 23) - ; - } - - - protected static void integratedpack10(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (in[0 + inpos] - initoffset) - | ((in[1 + inpos] - in[1 + inpos - 1]) << 10) - | ((in[2 + inpos] - in[2 + inpos - 1]) << 20) - | ((in[3 + inpos] - in[3 + inpos - 1]) << 30) - ; - out[1 + outpos] = (in[3 + inpos] - in[3 + inpos - 1]) >>> (10 - 8) - | ((in[4 + inpos] - in[4 + inpos - 1]) << 8) - | ((in[5 + inpos] - in[5 + inpos - 1]) << 18) - | ((in[6 + inpos] - in[6 + inpos - 1]) << 28) - ; - out[2 + outpos] = (in[6 + inpos] - in[6 + inpos - 1]) >>> (10 - 6) - | ((in[7 + inpos] - in[7 + inpos - 1]) << 6) - | ((in[8 + inpos] - in[8 + inpos - 1]) << 16) - | ((in[9 + inpos] - in[9 + inpos - 1]) << 26) - ; - out[3 + outpos] = (in[9 + inpos] - in[9 + inpos - 1]) >>> (10 - 4) - | ((in[10 + inpos] - in[10 + inpos - 1]) << 4) - | ((in[11 + inpos] - in[11 + inpos - 1]) << 14) - | ((in[12 + inpos] - in[12 + inpos - 1]) << 24) - ; - out[4 + outpos] = (in[12 + inpos] - in[12 + inpos - 1]) >>> (10 - 2) - | ((in[13 + inpos] - in[13 + inpos - 1]) << 2) - | ((in[14 + inpos] - in[14 + inpos - 1]) << 12) - | ((in[15 + inpos] - in[15 + inpos - 1]) << 22) - ; - out[5 + outpos] = (in[16 + inpos] - in[16 + inpos - 1]) - | ((in[17 + inpos] - in[17 + inpos - 1]) << 10) - | ((in[18 + inpos] - in[18 + inpos - 1]) << 20) - | ((in[19 + inpos] - in[19 + inpos - 1]) << 30) - ; - out[6 + outpos] = (in[19 + inpos] - in[19 + inpos - 1]) >>> (10 - 8) - | ((in[20 + inpos] - in[20 + inpos - 1]) << 8) - | ((in[21 + inpos] - in[21 + inpos - 1]) << 18) - | ((in[22 + inpos] - in[22 + inpos - 1]) << 28) - ; - out[7 + outpos] = (in[22 + inpos] - in[22 + inpos - 1]) >>> (10 - 6) - | ((in[23 + inpos] - in[23 + inpos - 1]) << 6) - | ((in[24 + inpos] - in[24 + inpos - 1]) << 16) - | ((in[25 + inpos] - in[25 + inpos - 1]) << 26) - ; - out[8 + outpos] = (in[25 + inpos] - in[25 + inpos - 1]) >>> (10 - 4) - | ((in[26 + inpos] - in[26 + inpos - 1]) << 4) - | ((in[27 + inpos] - in[27 + inpos - 1]) << 14) - | ((in[28 + inpos] - in[28 + inpos - 1]) << 24) - ; - out[9 + outpos] = (in[28 + inpos] - in[28 + inpos - 1]) >>> (10 - 2) - | ((in[29 + inpos] - in[29 + inpos - 1]) << 2) - | ((in[30 + inpos] - in[30 + inpos - 1]) << 12) - | ((in[31 + inpos] - in[31 + inpos - 1]) << 22) - ; - } - - - protected static void integratedpack11(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (in[0 + inpos] - initoffset) - | ((in[1 + inpos] - in[1 + inpos - 1]) << 11) - | ((in[2 + inpos] - in[2 + inpos - 1]) << 22) - ; - out[1 + outpos] = (in[2 + inpos] - in[2 + inpos - 1]) >>> (11 - 1) - | ((in[3 + inpos] - in[3 + inpos - 1]) << 1) - | ((in[4 + inpos] - in[4 + inpos - 1]) << 12) - | ((in[5 + inpos] - in[5 + inpos - 1]) << 23) - ; - out[2 + outpos] = (in[5 + inpos] - in[5 + inpos - 1]) >>> (11 - 2) - | ((in[6 + inpos] - in[6 + inpos - 1]) << 2) - | ((in[7 + inpos] - in[7 + inpos - 1]) << 13) - | ((in[8 + inpos] - in[8 + inpos - 1]) << 24) - ; - out[3 + outpos] = (in[8 + inpos] - in[8 + inpos - 1]) >>> (11 - 3) - | ((in[9 + inpos] - in[9 + inpos - 1]) << 3) - | ((in[10 + inpos] - in[10 + inpos - 1]) << 14) - | ((in[11 + inpos] - in[11 + inpos - 1]) << 25) - ; - out[4 + outpos] = (in[11 + inpos] - in[11 + inpos - 1]) >>> (11 - 4) - | ((in[12 + inpos] - in[12 + inpos - 1]) << 4) - | ((in[13 + inpos] - in[13 + inpos - 1]) << 15) - | ((in[14 + inpos] - in[14 + inpos - 1]) << 26) - ; - out[5 + outpos] = (in[14 + inpos] - in[14 + inpos - 1]) >>> (11 - 5) - | ((in[15 + inpos] - in[15 + inpos - 1]) << 5) - | ((in[16 + inpos] - in[16 + inpos - 1]) << 16) - | ((in[17 + inpos] - in[17 + inpos - 1]) << 27) - ; - out[6 + outpos] = (in[17 + inpos] - in[17 + inpos - 1]) >>> (11 - 6) - | ((in[18 + inpos] - in[18 + inpos - 1]) << 6) - | ((in[19 + inpos] - in[19 + inpos - 1]) << 17) - | ((in[20 + inpos] - in[20 + inpos - 1]) << 28) - ; - out[7 + outpos] = (in[20 + inpos] - in[20 + inpos - 1]) >>> (11 - 7) - | ((in[21 + inpos] - in[21 + inpos - 1]) << 7) - | ((in[22 + inpos] - in[22 + inpos - 1]) << 18) - | ((in[23 + inpos] - in[23 + inpos - 1]) << 29) - ; - out[8 + outpos] = (in[23 + inpos] - in[23 + inpos - 1]) >>> (11 - 8) - | ((in[24 + inpos] - in[24 + inpos - 1]) << 8) - | ((in[25 + inpos] - in[25 + inpos - 1]) << 19) - | ((in[26 + inpos] - in[26 + inpos - 1]) << 30) - ; - out[9 + outpos] = (in[26 + inpos] - in[26 + inpos - 1]) >>> (11 - 9) - | ((in[27 + inpos] - in[27 + inpos - 1]) << 9) - | ((in[28 + inpos] - in[28 + inpos - 1]) << 20) - | ((in[29 + inpos] - in[29 + inpos - 1]) << 31) - ; - out[10 + outpos] = (in[29 + inpos] - in[29 + inpos - 1]) >>> (11 - 10) - | ((in[30 + inpos] - in[30 + inpos - 1]) << 10) - | ((in[31 + inpos] - in[31 + inpos - 1]) << 21) - ; - } - - - protected static void integratedpack12(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (in[0 + inpos] - initoffset) - | ((in[1 + inpos] - in[1 + inpos - 1]) << 12) - | ((in[2 + inpos] - in[2 + inpos - 1]) << 24) - ; - out[1 + outpos] = (in[2 + inpos] - in[2 + inpos - 1]) >>> (12 - 4) - | ((in[3 + inpos] - in[3 + inpos - 1]) << 4) - | ((in[4 + inpos] - in[4 + inpos - 1]) << 16) - | ((in[5 + inpos] - in[5 + inpos - 1]) << 28) - ; - out[2 + outpos] = (in[5 + inpos] - in[5 + inpos - 1]) >>> (12 - 8) - | ((in[6 + inpos] - in[6 + inpos - 1]) << 8) - | ((in[7 + inpos] - in[7 + inpos - 1]) << 20) - ; - out[3 + outpos] = (in[8 + inpos] - in[8 + inpos - 1]) - | ((in[9 + inpos] - in[9 + inpos - 1]) << 12) - | ((in[10 + inpos] - in[10 + inpos - 1]) << 24) - ; - out[4 + outpos] = (in[10 + inpos] - in[10 + inpos - 1]) >>> (12 - 4) - | ((in[11 + inpos] - in[11 + inpos - 1]) << 4) - | ((in[12 + inpos] - in[12 + inpos - 1]) << 16) - | ((in[13 + inpos] - in[13 + inpos - 1]) << 28) - ; - out[5 + outpos] = (in[13 + inpos] - in[13 + inpos - 1]) >>> (12 - 8) - | ((in[14 + inpos] - in[14 + inpos - 1]) << 8) - | ((in[15 + inpos] - in[15 + inpos - 1]) << 20) - ; - out[6 + outpos] = (in[16 + inpos] - in[16 + inpos - 1]) - | ((in[17 + inpos] - in[17 + inpos - 1]) << 12) - | ((in[18 + inpos] - in[18 + inpos - 1]) << 24) - ; - out[7 + outpos] = (in[18 + inpos] - in[18 + inpos - 1]) >>> (12 - 4) - | ((in[19 + inpos] - in[19 + inpos - 1]) << 4) - | ((in[20 + inpos] - in[20 + inpos - 1]) << 16) - | ((in[21 + inpos] - in[21 + inpos - 1]) << 28) - ; - out[8 + outpos] = (in[21 + inpos] - in[21 + inpos - 1]) >>> (12 - 8) - | ((in[22 + inpos] - in[22 + inpos - 1]) << 8) - | ((in[23 + inpos] - in[23 + inpos - 1]) << 20) - ; - out[9 + outpos] = (in[24 + inpos] - in[24 + inpos - 1]) - | ((in[25 + inpos] - in[25 + inpos - 1]) << 12) - | ((in[26 + inpos] - in[26 + inpos - 1]) << 24) - ; - out[10 + outpos] = (in[26 + inpos] - in[26 + inpos - 1]) >>> (12 - 4) - | ((in[27 + inpos] - in[27 + inpos - 1]) << 4) - | ((in[28 + inpos] - in[28 + inpos - 1]) << 16) - | ((in[29 + inpos] - in[29 + inpos - 1]) << 28) - ; - out[11 + outpos] = (in[29 + inpos] - in[29 + inpos - 1]) >>> (12 - 8) - | ((in[30 + inpos] - in[30 + inpos - 1]) << 8) - | ((in[31 + inpos] - in[31 + inpos - 1]) << 20) - ; - } - - - protected static void integratedpack13(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (in[0 + inpos] - initoffset) - | ((in[1 + inpos] - in[1 + inpos - 1]) << 13) - | ((in[2 + inpos] - in[2 + inpos - 1]) << 26) - ; - out[1 + outpos] = (in[2 + inpos] - in[2 + inpos - 1]) >>> (13 - 7) - | ((in[3 + inpos] - in[3 + inpos - 1]) << 7) - | ((in[4 + inpos] - in[4 + inpos - 1]) << 20) - ; - out[2 + outpos] = (in[4 + inpos] - in[4 + inpos - 1]) >>> (13 - 1) - | ((in[5 + inpos] - in[5 + inpos - 1]) << 1) - | ((in[6 + inpos] - in[6 + inpos - 1]) << 14) - | ((in[7 + inpos] - in[7 + inpos - 1]) << 27) - ; - out[3 + outpos] = (in[7 + inpos] - in[7 + inpos - 1]) >>> (13 - 8) - | ((in[8 + inpos] - in[8 + inpos - 1]) << 8) - | ((in[9 + inpos] - in[9 + inpos - 1]) << 21) - ; - out[4 + outpos] = (in[9 + inpos] - in[9 + inpos - 1]) >>> (13 - 2) - | ((in[10 + inpos] - in[10 + inpos - 1]) << 2) - | ((in[11 + inpos] - in[11 + inpos - 1]) << 15) - | ((in[12 + inpos] - in[12 + inpos - 1]) << 28) - ; - out[5 + outpos] = (in[12 + inpos] - in[12 + inpos - 1]) >>> (13 - 9) - | ((in[13 + inpos] - in[13 + inpos - 1]) << 9) - | ((in[14 + inpos] - in[14 + inpos - 1]) << 22) - ; - out[6 + outpos] = (in[14 + inpos] - in[14 + inpos - 1]) >>> (13 - 3) - | ((in[15 + inpos] - in[15 + inpos - 1]) << 3) - | ((in[16 + inpos] - in[16 + inpos - 1]) << 16) - | ((in[17 + inpos] - in[17 + inpos - 1]) << 29) - ; - out[7 + outpos] = (in[17 + inpos] - in[17 + inpos - 1]) >>> (13 - 10) - | ((in[18 + inpos] - in[18 + inpos - 1]) << 10) - | ((in[19 + inpos] - in[19 + inpos - 1]) << 23) - ; - out[8 + outpos] = (in[19 + inpos] - in[19 + inpos - 1]) >>> (13 - 4) - | ((in[20 + inpos] - in[20 + inpos - 1]) << 4) - | ((in[21 + inpos] - in[21 + inpos - 1]) << 17) - | ((in[22 + inpos] - in[22 + inpos - 1]) << 30) - ; - out[9 + outpos] = (in[22 + inpos] - in[22 + inpos - 1]) >>> (13 - 11) - | ((in[23 + inpos] - in[23 + inpos - 1]) << 11) - | ((in[24 + inpos] - in[24 + inpos - 1]) << 24) - ; - out[10 + outpos] = (in[24 + inpos] - in[24 + inpos - 1]) >>> (13 - 5) - | ((in[25 + inpos] - in[25 + inpos - 1]) << 5) - | ((in[26 + inpos] - in[26 + inpos - 1]) << 18) - | ((in[27 + inpos] - in[27 + inpos - 1]) << 31) - ; - out[11 + outpos] = (in[27 + inpos] - in[27 + inpos - 1]) >>> (13 - 12) - | ((in[28 + inpos] - in[28 + inpos - 1]) << 12) - | ((in[29 + inpos] - in[29 + inpos - 1]) << 25) - ; - out[12 + outpos] = (in[29 + inpos] - in[29 + inpos - 1]) >>> (13 - 6) - | ((in[30 + inpos] - in[30 + inpos - 1]) << 6) - | ((in[31 + inpos] - in[31 + inpos - 1]) << 19) - ; - } - - - protected static void integratedpack14(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (in[0 + inpos] - initoffset) - | ((in[1 + inpos] - in[1 + inpos - 1]) << 14) - | ((in[2 + inpos] - in[2 + inpos - 1]) << 28) - ; - out[1 + outpos] = (in[2 + inpos] - in[2 + inpos - 1]) >>> (14 - 10) - | ((in[3 + inpos] - in[3 + inpos - 1]) << 10) - | ((in[4 + inpos] - in[4 + inpos - 1]) << 24) - ; - out[2 + outpos] = (in[4 + inpos] - in[4 + inpos - 1]) >>> (14 - 6) - | ((in[5 + inpos] - in[5 + inpos - 1]) << 6) - | ((in[6 + inpos] - in[6 + inpos - 1]) << 20) - ; - out[3 + outpos] = (in[6 + inpos] - in[6 + inpos - 1]) >>> (14 - 2) - | ((in[7 + inpos] - in[7 + inpos - 1]) << 2) - | ((in[8 + inpos] - in[8 + inpos - 1]) << 16) - | ((in[9 + inpos] - in[9 + inpos - 1]) << 30) - ; - out[4 + outpos] = (in[9 + inpos] - in[9 + inpos - 1]) >>> (14 - 12) - | ((in[10 + inpos] - in[10 + inpos - 1]) << 12) - | ((in[11 + inpos] - in[11 + inpos - 1]) << 26) - ; - out[5 + outpos] = (in[11 + inpos] - in[11 + inpos - 1]) >>> (14 - 8) - | ((in[12 + inpos] - in[12 + inpos - 1]) << 8) - | ((in[13 + inpos] - in[13 + inpos - 1]) << 22) - ; - out[6 + outpos] = (in[13 + inpos] - in[13 + inpos - 1]) >>> (14 - 4) - | ((in[14 + inpos] - in[14 + inpos - 1]) << 4) - | ((in[15 + inpos] - in[15 + inpos - 1]) << 18) - ; - out[7 + outpos] = (in[16 + inpos] - in[16 + inpos - 1]) - | ((in[17 + inpos] - in[17 + inpos - 1]) << 14) - | ((in[18 + inpos] - in[18 + inpos - 1]) << 28) - ; - out[8 + outpos] = (in[18 + inpos] - in[18 + inpos - 1]) >>> (14 - 10) - | ((in[19 + inpos] - in[19 + inpos - 1]) << 10) - | ((in[20 + inpos] - in[20 + inpos - 1]) << 24) - ; - out[9 + outpos] = (in[20 + inpos] - in[20 + inpos - 1]) >>> (14 - 6) - | ((in[21 + inpos] - in[21 + inpos - 1]) << 6) - | ((in[22 + inpos] - in[22 + inpos - 1]) << 20) - ; - out[10 + outpos] = (in[22 + inpos] - in[22 + inpos - 1]) >>> (14 - 2) - | ((in[23 + inpos] - in[23 + inpos - 1]) << 2) - | ((in[24 + inpos] - in[24 + inpos - 1]) << 16) - | ((in[25 + inpos] - in[25 + inpos - 1]) << 30) - ; - out[11 + outpos] = (in[25 + inpos] - in[25 + inpos - 1]) >>> (14 - 12) - | ((in[26 + inpos] - in[26 + inpos - 1]) << 12) - | ((in[27 + inpos] - in[27 + inpos - 1]) << 26) - ; - out[12 + outpos] = (in[27 + inpos] - in[27 + inpos - 1]) >>> (14 - 8) - | ((in[28 + inpos] - in[28 + inpos - 1]) << 8) - | ((in[29 + inpos] - in[29 + inpos - 1]) << 22) - ; - out[13 + outpos] = (in[29 + inpos] - in[29 + inpos - 1]) >>> (14 - 4) - | ((in[30 + inpos] - in[30 + inpos - 1]) << 4) - | ((in[31 + inpos] - in[31 + inpos - 1]) << 18) - ; - } - - - protected static void integratedpack15(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (in[0 + inpos] - initoffset) - | ((in[1 + inpos] - in[1 + inpos - 1]) << 15) - | ((in[2 + inpos] - in[2 + inpos - 1]) << 30) - ; - out[1 + outpos] = (in[2 + inpos] - in[2 + inpos - 1]) >>> (15 - 13) - | ((in[3 + inpos] - in[3 + inpos - 1]) << 13) - | ((in[4 + inpos] - in[4 + inpos - 1]) << 28) - ; - out[2 + outpos] = (in[4 + inpos] - in[4 + inpos - 1]) >>> (15 - 11) - | ((in[5 + inpos] - in[5 + inpos - 1]) << 11) - | ((in[6 + inpos] - in[6 + inpos - 1]) << 26) - ; - out[3 + outpos] = (in[6 + inpos] - in[6 + inpos - 1]) >>> (15 - 9) - | ((in[7 + inpos] - in[7 + inpos - 1]) << 9) - | ((in[8 + inpos] - in[8 + inpos - 1]) << 24) - ; - out[4 + outpos] = (in[8 + inpos] - in[8 + inpos - 1]) >>> (15 - 7) - | ((in[9 + inpos] - in[9 + inpos - 1]) << 7) - | ((in[10 + inpos] - in[10 + inpos - 1]) << 22) - ; - out[5 + outpos] = (in[10 + inpos] - in[10 + inpos - 1]) >>> (15 - 5) - | ((in[11 + inpos] - in[11 + inpos - 1]) << 5) - | ((in[12 + inpos] - in[12 + inpos - 1]) << 20) - ; - out[6 + outpos] = (in[12 + inpos] - in[12 + inpos - 1]) >>> (15 - 3) - | ((in[13 + inpos] - in[13 + inpos - 1]) << 3) - | ((in[14 + inpos] - in[14 + inpos - 1]) << 18) - ; - out[7 + outpos] = (in[14 + inpos] - in[14 + inpos - 1]) >>> (15 - 1) - | ((in[15 + inpos] - in[15 + inpos - 1]) << 1) - | ((in[16 + inpos] - in[16 + inpos - 1]) << 16) - | ((in[17 + inpos] - in[17 + inpos - 1]) << 31) - ; - out[8 + outpos] = (in[17 + inpos] - in[17 + inpos - 1]) >>> (15 - 14) - | ((in[18 + inpos] - in[18 + inpos - 1]) << 14) - | ((in[19 + inpos] - in[19 + inpos - 1]) << 29) - ; - out[9 + outpos] = (in[19 + inpos] - in[19 + inpos - 1]) >>> (15 - 12) - | ((in[20 + inpos] - in[20 + inpos - 1]) << 12) - | ((in[21 + inpos] - in[21 + inpos - 1]) << 27) - ; - out[10 + outpos] = (in[21 + inpos] - in[21 + inpos - 1]) >>> (15 - 10) - | ((in[22 + inpos] - in[22 + inpos - 1]) << 10) - | ((in[23 + inpos] - in[23 + inpos - 1]) << 25) - ; - out[11 + outpos] = (in[23 + inpos] - in[23 + inpos - 1]) >>> (15 - 8) - | ((in[24 + inpos] - in[24 + inpos - 1]) << 8) - | ((in[25 + inpos] - in[25 + inpos - 1]) << 23) - ; - out[12 + outpos] = (in[25 + inpos] - in[25 + inpos - 1]) >>> (15 - 6) - | ((in[26 + inpos] - in[26 + inpos - 1]) << 6) - | ((in[27 + inpos] - in[27 + inpos - 1]) << 21) - ; - out[13 + outpos] = (in[27 + inpos] - in[27 + inpos - 1]) >>> (15 - 4) - | ((in[28 + inpos] - in[28 + inpos - 1]) << 4) - | ((in[29 + inpos] - in[29 + inpos - 1]) << 19) - ; - out[14 + outpos] = (in[29 + inpos] - in[29 + inpos - 1]) >>> (15 - 2) - | ((in[30 + inpos] - in[30 + inpos - 1]) << 2) - | ((in[31 + inpos] - in[31 + inpos - 1]) << 17) - ; - } - - - protected static void integratedpack16(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (in[0 + inpos] - initoffset) - | ((in[1 + inpos] - in[1 + inpos - 1]) << 16) - ; - out[1 + outpos] = (in[2 + inpos] - in[2 + inpos - 1]) - | ((in[3 + inpos] - in[3 + inpos - 1]) << 16) - ; - out[2 + outpos] = (in[4 + inpos] - in[4 + inpos - 1]) - | ((in[5 + inpos] - in[5 + inpos - 1]) << 16) - ; - out[3 + outpos] = (in[6 + inpos] - in[6 + inpos - 1]) - | ((in[7 + inpos] - in[7 + inpos - 1]) << 16) - ; - out[4 + outpos] = (in[8 + inpos] - in[8 + inpos - 1]) - | ((in[9 + inpos] - in[9 + inpos - 1]) << 16) - ; - out[5 + outpos] = (in[10 + inpos] - in[10 + inpos - 1]) - | ((in[11 + inpos] - in[11 + inpos - 1]) << 16) - ; - out[6 + outpos] = (in[12 + inpos] - in[12 + inpos - 1]) - | ((in[13 + inpos] - in[13 + inpos - 1]) << 16) - ; - out[7 + outpos] = (in[14 + inpos] - in[14 + inpos - 1]) - | ((in[15 + inpos] - in[15 + inpos - 1]) << 16) - ; - out[8 + outpos] = (in[16 + inpos] - in[16 + inpos - 1]) - | ((in[17 + inpos] - in[17 + inpos - 1]) << 16) - ; - out[9 + outpos] = (in[18 + inpos] - in[18 + inpos - 1]) - | ((in[19 + inpos] - in[19 + inpos - 1]) << 16) - ; - out[10 + outpos] = (in[20 + inpos] - in[20 + inpos - 1]) - | ((in[21 + inpos] - in[21 + inpos - 1]) << 16) - ; - out[11 + outpos] = (in[22 + inpos] - in[22 + inpos - 1]) - | ((in[23 + inpos] - in[23 + inpos - 1]) << 16) - ; - out[12 + outpos] = (in[24 + inpos] - in[24 + inpos - 1]) - | ((in[25 + inpos] - in[25 + inpos - 1]) << 16) - ; - out[13 + outpos] = (in[26 + inpos] - in[26 + inpos - 1]) - | ((in[27 + inpos] - in[27 + inpos - 1]) << 16) - ; - out[14 + outpos] = (in[28 + inpos] - in[28 + inpos - 1]) - | ((in[29 + inpos] - in[29 + inpos - 1]) << 16) - ; - out[15 + outpos] = (in[30 + inpos] - in[30 + inpos - 1]) - | ((in[31 + inpos] - in[31 + inpos - 1]) << 16) - ; - } - - - protected static void integratedpack17(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (in[0 + inpos] - initoffset) - | ((in[1 + inpos] - in[1 + inpos - 1]) << 17) - ; - out[1 + outpos] = (in[1 + inpos] - in[1 + inpos - 1]) >>> (17 - 2) - | ((in[2 + inpos] - in[2 + inpos - 1]) << 2) - | ((in[3 + inpos] - in[3 + inpos - 1]) << 19) - ; - out[2 + outpos] = (in[3 + inpos] - in[3 + inpos - 1]) >>> (17 - 4) - | ((in[4 + inpos] - in[4 + inpos - 1]) << 4) - | ((in[5 + inpos] - in[5 + inpos - 1]) << 21) - ; - out[3 + outpos] = (in[5 + inpos] - in[5 + inpos - 1]) >>> (17 - 6) - | ((in[6 + inpos] - in[6 + inpos - 1]) << 6) - | ((in[7 + inpos] - in[7 + inpos - 1]) << 23) - ; - out[4 + outpos] = (in[7 + inpos] - in[7 + inpos - 1]) >>> (17 - 8) - | ((in[8 + inpos] - in[8 + inpos - 1]) << 8) - | ((in[9 + inpos] - in[9 + inpos - 1]) << 25) - ; - out[5 + outpos] = (in[9 + inpos] - in[9 + inpos - 1]) >>> (17 - 10) - | ((in[10 + inpos] - in[10 + inpos - 1]) << 10) - | ((in[11 + inpos] - in[11 + inpos - 1]) << 27) - ; - out[6 + outpos] = (in[11 + inpos] - in[11 + inpos - 1]) >>> (17 - 12) - | ((in[12 + inpos] - in[12 + inpos - 1]) << 12) - | ((in[13 + inpos] - in[13 + inpos - 1]) << 29) - ; - out[7 + outpos] = (in[13 + inpos] - in[13 + inpos - 1]) >>> (17 - 14) - | ((in[14 + inpos] - in[14 + inpos - 1]) << 14) - | ((in[15 + inpos] - in[15 + inpos - 1]) << 31) - ; - out[8 + outpos] = (in[15 + inpos] - in[15 + inpos - 1]) >>> (17 - 16) - | ((in[16 + inpos] - in[16 + inpos - 1]) << 16) - ; - out[9 + outpos] = (in[16 + inpos] - in[16 + inpos - 1]) >>> (17 - 1) - | ((in[17 + inpos] - in[17 + inpos - 1]) << 1) - | ((in[18 + inpos] - in[18 + inpos - 1]) << 18) - ; - out[10 + outpos] = (in[18 + inpos] - in[18 + inpos - 1]) >>> (17 - 3) - | ((in[19 + inpos] - in[19 + inpos - 1]) << 3) - | ((in[20 + inpos] - in[20 + inpos - 1]) << 20) - ; - out[11 + outpos] = (in[20 + inpos] - in[20 + inpos - 1]) >>> (17 - 5) - | ((in[21 + inpos] - in[21 + inpos - 1]) << 5) - | ((in[22 + inpos] - in[22 + inpos - 1]) << 22) - ; - out[12 + outpos] = (in[22 + inpos] - in[22 + inpos - 1]) >>> (17 - 7) - | ((in[23 + inpos] - in[23 + inpos - 1]) << 7) - | ((in[24 + inpos] - in[24 + inpos - 1]) << 24) - ; - out[13 + outpos] = (in[24 + inpos] - in[24 + inpos - 1]) >>> (17 - 9) - | ((in[25 + inpos] - in[25 + inpos - 1]) << 9) - | ((in[26 + inpos] - in[26 + inpos - 1]) << 26) - ; - out[14 + outpos] = (in[26 + inpos] - in[26 + inpos - 1]) >>> (17 - 11) - | ((in[27 + inpos] - in[27 + inpos - 1]) << 11) - | ((in[28 + inpos] - in[28 + inpos - 1]) << 28) - ; - out[15 + outpos] = (in[28 + inpos] - in[28 + inpos - 1]) >>> (17 - 13) - | ((in[29 + inpos] - in[29 + inpos - 1]) << 13) - | ((in[30 + inpos] - in[30 + inpos - 1]) << 30) - ; - out[16 + outpos] = (in[30 + inpos] - in[30 + inpos - 1]) >>> (17 - 15) - | ((in[31 + inpos] - in[31 + inpos - 1]) << 15) - ; - } - - - protected static void integratedpack18(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (in[0 + inpos] - initoffset) - | ((in[1 + inpos] - in[1 + inpos - 1]) << 18) - ; - out[1 + outpos] = (in[1 + inpos] - in[1 + inpos - 1]) >>> (18 - 4) - | ((in[2 + inpos] - in[2 + inpos - 1]) << 4) - | ((in[3 + inpos] - in[3 + inpos - 1]) << 22) - ; - out[2 + outpos] = (in[3 + inpos] - in[3 + inpos - 1]) >>> (18 - 8) - | ((in[4 + inpos] - in[4 + inpos - 1]) << 8) - | ((in[5 + inpos] - in[5 + inpos - 1]) << 26) - ; - out[3 + outpos] = (in[5 + inpos] - in[5 + inpos - 1]) >>> (18 - 12) - | ((in[6 + inpos] - in[6 + inpos - 1]) << 12) - | ((in[7 + inpos] - in[7 + inpos - 1]) << 30) - ; - out[4 + outpos] = (in[7 + inpos] - in[7 + inpos - 1]) >>> (18 - 16) - | ((in[8 + inpos] - in[8 + inpos - 1]) << 16) - ; - out[5 + outpos] = (in[8 + inpos] - in[8 + inpos - 1]) >>> (18 - 2) - | ((in[9 + inpos] - in[9 + inpos - 1]) << 2) - | ((in[10 + inpos] - in[10 + inpos - 1]) << 20) - ; - out[6 + outpos] = (in[10 + inpos] - in[10 + inpos - 1]) >>> (18 - 6) - | ((in[11 + inpos] - in[11 + inpos - 1]) << 6) - | ((in[12 + inpos] - in[12 + inpos - 1]) << 24) - ; - out[7 + outpos] = (in[12 + inpos] - in[12 + inpos - 1]) >>> (18 - 10) - | ((in[13 + inpos] - in[13 + inpos - 1]) << 10) - | ((in[14 + inpos] - in[14 + inpos - 1]) << 28) - ; - out[8 + outpos] = (in[14 + inpos] - in[14 + inpos - 1]) >>> (18 - 14) - | ((in[15 + inpos] - in[15 + inpos - 1]) << 14) - ; - out[9 + outpos] = (in[16 + inpos] - in[16 + inpos - 1]) - | ((in[17 + inpos] - in[17 + inpos - 1]) << 18) - ; - out[10 + outpos] = (in[17 + inpos] - in[17 + inpos - 1]) >>> (18 - 4) - | ((in[18 + inpos] - in[18 + inpos - 1]) << 4) - | ((in[19 + inpos] - in[19 + inpos - 1]) << 22) - ; - out[11 + outpos] = (in[19 + inpos] - in[19 + inpos - 1]) >>> (18 - 8) - | ((in[20 + inpos] - in[20 + inpos - 1]) << 8) - | ((in[21 + inpos] - in[21 + inpos - 1]) << 26) - ; - out[12 + outpos] = (in[21 + inpos] - in[21 + inpos - 1]) >>> (18 - 12) - | ((in[22 + inpos] - in[22 + inpos - 1]) << 12) - | ((in[23 + inpos] - in[23 + inpos - 1]) << 30) - ; - out[13 + outpos] = (in[23 + inpos] - in[23 + inpos - 1]) >>> (18 - 16) - | ((in[24 + inpos] - in[24 + inpos - 1]) << 16) - ; - out[14 + outpos] = (in[24 + inpos] - in[24 + inpos - 1]) >>> (18 - 2) - | ((in[25 + inpos] - in[25 + inpos - 1]) << 2) - | ((in[26 + inpos] - in[26 + inpos - 1]) << 20) - ; - out[15 + outpos] = (in[26 + inpos] - in[26 + inpos - 1]) >>> (18 - 6) - | ((in[27 + inpos] - in[27 + inpos - 1]) << 6) - | ((in[28 + inpos] - in[28 + inpos - 1]) << 24) - ; - out[16 + outpos] = (in[28 + inpos] - in[28 + inpos - 1]) >>> (18 - 10) - | ((in[29 + inpos] - in[29 + inpos - 1]) << 10) - | ((in[30 + inpos] - in[30 + inpos - 1]) << 28) - ; - out[17 + outpos] = (in[30 + inpos] - in[30 + inpos - 1]) >>> (18 - 14) - | ((in[31 + inpos] - in[31 + inpos - 1]) << 14) - ; - } - - - protected static void integratedpack19(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (in[0 + inpos] - initoffset) - | ((in[1 + inpos] - in[1 + inpos - 1]) << 19) - ; - out[1 + outpos] = (in[1 + inpos] - in[1 + inpos - 1]) >>> (19 - 6) - | ((in[2 + inpos] - in[2 + inpos - 1]) << 6) - | ((in[3 + inpos] - in[3 + inpos - 1]) << 25) - ; - out[2 + outpos] = (in[3 + inpos] - in[3 + inpos - 1]) >>> (19 - 12) - | ((in[4 + inpos] - in[4 + inpos - 1]) << 12) - | ((in[5 + inpos] - in[5 + inpos - 1]) << 31) - ; - out[3 + outpos] = (in[5 + inpos] - in[5 + inpos - 1]) >>> (19 - 18) - | ((in[6 + inpos] - in[6 + inpos - 1]) << 18) - ; - out[4 + outpos] = (in[6 + inpos] - in[6 + inpos - 1]) >>> (19 - 5) - | ((in[7 + inpos] - in[7 + inpos - 1]) << 5) - | ((in[8 + inpos] - in[8 + inpos - 1]) << 24) - ; - out[5 + outpos] = (in[8 + inpos] - in[8 + inpos - 1]) >>> (19 - 11) - | ((in[9 + inpos] - in[9 + inpos - 1]) << 11) - | ((in[10 + inpos] - in[10 + inpos - 1]) << 30) - ; - out[6 + outpos] = (in[10 + inpos] - in[10 + inpos - 1]) >>> (19 - 17) - | ((in[11 + inpos] - in[11 + inpos - 1]) << 17) - ; - out[7 + outpos] = (in[11 + inpos] - in[11 + inpos - 1]) >>> (19 - 4) - | ((in[12 + inpos] - in[12 + inpos - 1]) << 4) - | ((in[13 + inpos] - in[13 + inpos - 1]) << 23) - ; - out[8 + outpos] = (in[13 + inpos] - in[13 + inpos - 1]) >>> (19 - 10) - | ((in[14 + inpos] - in[14 + inpos - 1]) << 10) - | ((in[15 + inpos] - in[15 + inpos - 1]) << 29) - ; - out[9 + outpos] = (in[15 + inpos] - in[15 + inpos - 1]) >>> (19 - 16) - | ((in[16 + inpos] - in[16 + inpos - 1]) << 16) - ; - out[10 + outpos] = (in[16 + inpos] - in[16 + inpos - 1]) >>> (19 - 3) - | ((in[17 + inpos] - in[17 + inpos - 1]) << 3) - | ((in[18 + inpos] - in[18 + inpos - 1]) << 22) - ; - out[11 + outpos] = (in[18 + inpos] - in[18 + inpos - 1]) >>> (19 - 9) - | ((in[19 + inpos] - in[19 + inpos - 1]) << 9) - | ((in[20 + inpos] - in[20 + inpos - 1]) << 28) - ; - out[12 + outpos] = (in[20 + inpos] - in[20 + inpos - 1]) >>> (19 - 15) - | ((in[21 + inpos] - in[21 + inpos - 1]) << 15) - ; - out[13 + outpos] = (in[21 + inpos] - in[21 + inpos - 1]) >>> (19 - 2) - | ((in[22 + inpos] - in[22 + inpos - 1]) << 2) - | ((in[23 + inpos] - in[23 + inpos - 1]) << 21) - ; - out[14 + outpos] = (in[23 + inpos] - in[23 + inpos - 1]) >>> (19 - 8) - | ((in[24 + inpos] - in[24 + inpos - 1]) << 8) - | ((in[25 + inpos] - in[25 + inpos - 1]) << 27) - ; - out[15 + outpos] = (in[25 + inpos] - in[25 + inpos - 1]) >>> (19 - 14) - | ((in[26 + inpos] - in[26 + inpos - 1]) << 14) - ; - out[16 + outpos] = (in[26 + inpos] - in[26 + inpos - 1]) >>> (19 - 1) - | ((in[27 + inpos] - in[27 + inpos - 1]) << 1) - | ((in[28 + inpos] - in[28 + inpos - 1]) << 20) - ; - out[17 + outpos] = (in[28 + inpos] - in[28 + inpos - 1]) >>> (19 - 7) - | ((in[29 + inpos] - in[29 + inpos - 1]) << 7) - | ((in[30 + inpos] - in[30 + inpos - 1]) << 26) - ; - out[18 + outpos] = (in[30 + inpos] - in[30 + inpos - 1]) >>> (19 - 13) - | ((in[31 + inpos] - in[31 + inpos - 1]) << 13) - ; - } - - - protected static void integratedpack20(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (in[0 + inpos] - initoffset) - | ((in[1 + inpos] - in[1 + inpos - 1]) << 20) - ; - out[1 + outpos] = (in[1 + inpos] - in[1 + inpos - 1]) >>> (20 - 8) - | ((in[2 + inpos] - in[2 + inpos - 1]) << 8) - | ((in[3 + inpos] - in[3 + inpos - 1]) << 28) - ; - out[2 + outpos] = (in[3 + inpos] - in[3 + inpos - 1]) >>> (20 - 16) - | ((in[4 + inpos] - in[4 + inpos - 1]) << 16) - ; - out[3 + outpos] = (in[4 + inpos] - in[4 + inpos - 1]) >>> (20 - 4) - | ((in[5 + inpos] - in[5 + inpos - 1]) << 4) - | ((in[6 + inpos] - in[6 + inpos - 1]) << 24) - ; - out[4 + outpos] = (in[6 + inpos] - in[6 + inpos - 1]) >>> (20 - 12) - | ((in[7 + inpos] - in[7 + inpos - 1]) << 12) - ; - out[5 + outpos] = (in[8 + inpos] - in[8 + inpos - 1]) - | ((in[9 + inpos] - in[9 + inpos - 1]) << 20) - ; - out[6 + outpos] = (in[9 + inpos] - in[9 + inpos - 1]) >>> (20 - 8) - | ((in[10 + inpos] - in[10 + inpos - 1]) << 8) - | ((in[11 + inpos] - in[11 + inpos - 1]) << 28) - ; - out[7 + outpos] = (in[11 + inpos] - in[11 + inpos - 1]) >>> (20 - 16) - | ((in[12 + inpos] - in[12 + inpos - 1]) << 16) - ; - out[8 + outpos] = (in[12 + inpos] - in[12 + inpos - 1]) >>> (20 - 4) - | ((in[13 + inpos] - in[13 + inpos - 1]) << 4) - | ((in[14 + inpos] - in[14 + inpos - 1]) << 24) - ; - out[9 + outpos] = (in[14 + inpos] - in[14 + inpos - 1]) >>> (20 - 12) - | ((in[15 + inpos] - in[15 + inpos - 1]) << 12) - ; - out[10 + outpos] = (in[16 + inpos] - in[16 + inpos - 1]) - | ((in[17 + inpos] - in[17 + inpos - 1]) << 20) - ; - out[11 + outpos] = (in[17 + inpos] - in[17 + inpos - 1]) >>> (20 - 8) - | ((in[18 + inpos] - in[18 + inpos - 1]) << 8) - | ((in[19 + inpos] - in[19 + inpos - 1]) << 28) - ; - out[12 + outpos] = (in[19 + inpos] - in[19 + inpos - 1]) >>> (20 - 16) - | ((in[20 + inpos] - in[20 + inpos - 1]) << 16) - ; - out[13 + outpos] = (in[20 + inpos] - in[20 + inpos - 1]) >>> (20 - 4) - | ((in[21 + inpos] - in[21 + inpos - 1]) << 4) - | ((in[22 + inpos] - in[22 + inpos - 1]) << 24) - ; - out[14 + outpos] = (in[22 + inpos] - in[22 + inpos - 1]) >>> (20 - 12) - | ((in[23 + inpos] - in[23 + inpos - 1]) << 12) - ; - out[15 + outpos] = (in[24 + inpos] - in[24 + inpos - 1]) - | ((in[25 + inpos] - in[25 + inpos - 1]) << 20) - ; - out[16 + outpos] = (in[25 + inpos] - in[25 + inpos - 1]) >>> (20 - 8) - | ((in[26 + inpos] - in[26 + inpos - 1]) << 8) - | ((in[27 + inpos] - in[27 + inpos - 1]) << 28) - ; - out[17 + outpos] = (in[27 + inpos] - in[27 + inpos - 1]) >>> (20 - 16) - | ((in[28 + inpos] - in[28 + inpos - 1]) << 16) - ; - out[18 + outpos] = (in[28 + inpos] - in[28 + inpos - 1]) >>> (20 - 4) - | ((in[29 + inpos] - in[29 + inpos - 1]) << 4) - | ((in[30 + inpos] - in[30 + inpos - 1]) << 24) - ; - out[19 + outpos] = (in[30 + inpos] - in[30 + inpos - 1]) >>> (20 - 12) - | ((in[31 + inpos] - in[31 + inpos - 1]) << 12) - ; - } - - - protected static void integratedpack21(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (in[0 + inpos] - initoffset) - | ((in[1 + inpos] - in[1 + inpos - 1]) << 21) - ; - out[1 + outpos] = (in[1 + inpos] - in[1 + inpos - 1]) >>> (21 - 10) - | ((in[2 + inpos] - in[2 + inpos - 1]) << 10) - | ((in[3 + inpos] - in[3 + inpos - 1]) << 31) - ; - out[2 + outpos] = (in[3 + inpos] - in[3 + inpos - 1]) >>> (21 - 20) - | ((in[4 + inpos] - in[4 + inpos - 1]) << 20) - ; - out[3 + outpos] = (in[4 + inpos] - in[4 + inpos - 1]) >>> (21 - 9) - | ((in[5 + inpos] - in[5 + inpos - 1]) << 9) - | ((in[6 + inpos] - in[6 + inpos - 1]) << 30) - ; - out[4 + outpos] = (in[6 + inpos] - in[6 + inpos - 1]) >>> (21 - 19) - | ((in[7 + inpos] - in[7 + inpos - 1]) << 19) - ; - out[5 + outpos] = (in[7 + inpos] - in[7 + inpos - 1]) >>> (21 - 8) - | ((in[8 + inpos] - in[8 + inpos - 1]) << 8) - | ((in[9 + inpos] - in[9 + inpos - 1]) << 29) - ; - out[6 + outpos] = (in[9 + inpos] - in[9 + inpos - 1]) >>> (21 - 18) - | ((in[10 + inpos] - in[10 + inpos - 1]) << 18) - ; - out[7 + outpos] = (in[10 + inpos] - in[10 + inpos - 1]) >>> (21 - 7) - | ((in[11 + inpos] - in[11 + inpos - 1]) << 7) - | ((in[12 + inpos] - in[12 + inpos - 1]) << 28) - ; - out[8 + outpos] = (in[12 + inpos] - in[12 + inpos - 1]) >>> (21 - 17) - | ((in[13 + inpos] - in[13 + inpos - 1]) << 17) - ; - out[9 + outpos] = (in[13 + inpos] - in[13 + inpos - 1]) >>> (21 - 6) - | ((in[14 + inpos] - in[14 + inpos - 1]) << 6) - | ((in[15 + inpos] - in[15 + inpos - 1]) << 27) - ; - out[10 + outpos] = (in[15 + inpos] - in[15 + inpos - 1]) >>> (21 - 16) - | ((in[16 + inpos] - in[16 + inpos - 1]) << 16) - ; - out[11 + outpos] = (in[16 + inpos] - in[16 + inpos - 1]) >>> (21 - 5) - | ((in[17 + inpos] - in[17 + inpos - 1]) << 5) - | ((in[18 + inpos] - in[18 + inpos - 1]) << 26) - ; - out[12 + outpos] = (in[18 + inpos] - in[18 + inpos - 1]) >>> (21 - 15) - | ((in[19 + inpos] - in[19 + inpos - 1]) << 15) - ; - out[13 + outpos] = (in[19 + inpos] - in[19 + inpos - 1]) >>> (21 - 4) - | ((in[20 + inpos] - in[20 + inpos - 1]) << 4) - | ((in[21 + inpos] - in[21 + inpos - 1]) << 25) - ; - out[14 + outpos] = (in[21 + inpos] - in[21 + inpos - 1]) >>> (21 - 14) - | ((in[22 + inpos] - in[22 + inpos - 1]) << 14) - ; - out[15 + outpos] = (in[22 + inpos] - in[22 + inpos - 1]) >>> (21 - 3) - | ((in[23 + inpos] - in[23 + inpos - 1]) << 3) - | ((in[24 + inpos] - in[24 + inpos - 1]) << 24) - ; - out[16 + outpos] = (in[24 + inpos] - in[24 + inpos - 1]) >>> (21 - 13) - | ((in[25 + inpos] - in[25 + inpos - 1]) << 13) - ; - out[17 + outpos] = (in[25 + inpos] - in[25 + inpos - 1]) >>> (21 - 2) - | ((in[26 + inpos] - in[26 + inpos - 1]) << 2) - | ((in[27 + inpos] - in[27 + inpos - 1]) << 23) - ; - out[18 + outpos] = (in[27 + inpos] - in[27 + inpos - 1]) >>> (21 - 12) - | ((in[28 + inpos] - in[28 + inpos - 1]) << 12) - ; - out[19 + outpos] = (in[28 + inpos] - in[28 + inpos - 1]) >>> (21 - 1) - | ((in[29 + inpos] - in[29 + inpos - 1]) << 1) - | ((in[30 + inpos] - in[30 + inpos - 1]) << 22) - ; - out[20 + outpos] = (in[30 + inpos] - in[30 + inpos - 1]) >>> (21 - 11) - | ((in[31 + inpos] - in[31 + inpos - 1]) << 11) - ; - } - - - protected static void integratedpack22(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (in[0 + inpos] - initoffset) - | ((in[1 + inpos] - in[1 + inpos - 1]) << 22) - ; - out[1 + outpos] = (in[1 + inpos] - in[1 + inpos - 1]) >>> (22 - 12) - | ((in[2 + inpos] - in[2 + inpos - 1]) << 12) - ; - out[2 + outpos] = (in[2 + inpos] - in[2 + inpos - 1]) >>> (22 - 2) - | ((in[3 + inpos] - in[3 + inpos - 1]) << 2) - | ((in[4 + inpos] - in[4 + inpos - 1]) << 24) - ; - out[3 + outpos] = (in[4 + inpos] - in[4 + inpos - 1]) >>> (22 - 14) - | ((in[5 + inpos] - in[5 + inpos - 1]) << 14) - ; - out[4 + outpos] = (in[5 + inpos] - in[5 + inpos - 1]) >>> (22 - 4) - | ((in[6 + inpos] - in[6 + inpos - 1]) << 4) - | ((in[7 + inpos] - in[7 + inpos - 1]) << 26) - ; - out[5 + outpos] = (in[7 + inpos] - in[7 + inpos - 1]) >>> (22 - 16) - | ((in[8 + inpos] - in[8 + inpos - 1]) << 16) - ; - out[6 + outpos] = (in[8 + inpos] - in[8 + inpos - 1]) >>> (22 - 6) - | ((in[9 + inpos] - in[9 + inpos - 1]) << 6) - | ((in[10 + inpos] - in[10 + inpos - 1]) << 28) - ; - out[7 + outpos] = (in[10 + inpos] - in[10 + inpos - 1]) >>> (22 - 18) - | ((in[11 + inpos] - in[11 + inpos - 1]) << 18) - ; - out[8 + outpos] = (in[11 + inpos] - in[11 + inpos - 1]) >>> (22 - 8) - | ((in[12 + inpos] - in[12 + inpos - 1]) << 8) - | ((in[13 + inpos] - in[13 + inpos - 1]) << 30) - ; - out[9 + outpos] = (in[13 + inpos] - in[13 + inpos - 1]) >>> (22 - 20) - | ((in[14 + inpos] - in[14 + inpos - 1]) << 20) - ; - out[10 + outpos] = (in[14 + inpos] - in[14 + inpos - 1]) >>> (22 - 10) - | ((in[15 + inpos] - in[15 + inpos - 1]) << 10) - ; - out[11 + outpos] = (in[16 + inpos] - in[16 + inpos - 1]) - | ((in[17 + inpos] - in[17 + inpos - 1]) << 22) - ; - out[12 + outpos] = (in[17 + inpos] - in[17 + inpos - 1]) >>> (22 - 12) - | ((in[18 + inpos] - in[18 + inpos - 1]) << 12) - ; - out[13 + outpos] = (in[18 + inpos] - in[18 + inpos - 1]) >>> (22 - 2) - | ((in[19 + inpos] - in[19 + inpos - 1]) << 2) - | ((in[20 + inpos] - in[20 + inpos - 1]) << 24) - ; - out[14 + outpos] = (in[20 + inpos] - in[20 + inpos - 1]) >>> (22 - 14) - | ((in[21 + inpos] - in[21 + inpos - 1]) << 14) - ; - out[15 + outpos] = (in[21 + inpos] - in[21 + inpos - 1]) >>> (22 - 4) - | ((in[22 + inpos] - in[22 + inpos - 1]) << 4) - | ((in[23 + inpos] - in[23 + inpos - 1]) << 26) - ; - out[16 + outpos] = (in[23 + inpos] - in[23 + inpos - 1]) >>> (22 - 16) - | ((in[24 + inpos] - in[24 + inpos - 1]) << 16) - ; - out[17 + outpos] = (in[24 + inpos] - in[24 + inpos - 1]) >>> (22 - 6) - | ((in[25 + inpos] - in[25 + inpos - 1]) << 6) - | ((in[26 + inpos] - in[26 + inpos - 1]) << 28) - ; - out[18 + outpos] = (in[26 + inpos] - in[26 + inpos - 1]) >>> (22 - 18) - | ((in[27 + inpos] - in[27 + inpos - 1]) << 18) - ; - out[19 + outpos] = (in[27 + inpos] - in[27 + inpos - 1]) >>> (22 - 8) - | ((in[28 + inpos] - in[28 + inpos - 1]) << 8) - | ((in[29 + inpos] - in[29 + inpos - 1]) << 30) - ; - out[20 + outpos] = (in[29 + inpos] - in[29 + inpos - 1]) >>> (22 - 20) - | ((in[30 + inpos] - in[30 + inpos - 1]) << 20) - ; - out[21 + outpos] = (in[30 + inpos] - in[30 + inpos - 1]) >>> (22 - 10) - | ((in[31 + inpos] - in[31 + inpos - 1]) << 10) - ; - } - - - protected static void integratedpack23(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (in[0 + inpos] - initoffset) - | ((in[1 + inpos] - in[1 + inpos - 1]) << 23) - ; - out[1 + outpos] = (in[1 + inpos] - in[1 + inpos - 1]) >>> (23 - 14) - | ((in[2 + inpos] - in[2 + inpos - 1]) << 14) - ; - out[2 + outpos] = (in[2 + inpos] - in[2 + inpos - 1]) >>> (23 - 5) - | ((in[3 + inpos] - in[3 + inpos - 1]) << 5) - | ((in[4 + inpos] - in[4 + inpos - 1]) << 28) - ; - out[3 + outpos] = (in[4 + inpos] - in[4 + inpos - 1]) >>> (23 - 19) - | ((in[5 + inpos] - in[5 + inpos - 1]) << 19) - ; - out[4 + outpos] = (in[5 + inpos] - in[5 + inpos - 1]) >>> (23 - 10) - | ((in[6 + inpos] - in[6 + inpos - 1]) << 10) - ; - out[5 + outpos] = (in[6 + inpos] - in[6 + inpos - 1]) >>> (23 - 1) - | ((in[7 + inpos] - in[7 + inpos - 1]) << 1) - | ((in[8 + inpos] - in[8 + inpos - 1]) << 24) - ; - out[6 + outpos] = (in[8 + inpos] - in[8 + inpos - 1]) >>> (23 - 15) - | ((in[9 + inpos] - in[9 + inpos - 1]) << 15) - ; - out[7 + outpos] = (in[9 + inpos] - in[9 + inpos - 1]) >>> (23 - 6) - | ((in[10 + inpos] - in[10 + inpos - 1]) << 6) - | ((in[11 + inpos] - in[11 + inpos - 1]) << 29) - ; - out[8 + outpos] = (in[11 + inpos] - in[11 + inpos - 1]) >>> (23 - 20) - | ((in[12 + inpos] - in[12 + inpos - 1]) << 20) - ; - out[9 + outpos] = (in[12 + inpos] - in[12 + inpos - 1]) >>> (23 - 11) - | ((in[13 + inpos] - in[13 + inpos - 1]) << 11) - ; - out[10 + outpos] = (in[13 + inpos] - in[13 + inpos - 1]) >>> (23 - 2) - | ((in[14 + inpos] - in[14 + inpos - 1]) << 2) - | ((in[15 + inpos] - in[15 + inpos - 1]) << 25) - ; - out[11 + outpos] = (in[15 + inpos] - in[15 + inpos - 1]) >>> (23 - 16) - | ((in[16 + inpos] - in[16 + inpos - 1]) << 16) - ; - out[12 + outpos] = (in[16 + inpos] - in[16 + inpos - 1]) >>> (23 - 7) - | ((in[17 + inpos] - in[17 + inpos - 1]) << 7) - | ((in[18 + inpos] - in[18 + inpos - 1]) << 30) - ; - out[13 + outpos] = (in[18 + inpos] - in[18 + inpos - 1]) >>> (23 - 21) - | ((in[19 + inpos] - in[19 + inpos - 1]) << 21) - ; - out[14 + outpos] = (in[19 + inpos] - in[19 + inpos - 1]) >>> (23 - 12) - | ((in[20 + inpos] - in[20 + inpos - 1]) << 12) - ; - out[15 + outpos] = (in[20 + inpos] - in[20 + inpos - 1]) >>> (23 - 3) - | ((in[21 + inpos] - in[21 + inpos - 1]) << 3) - | ((in[22 + inpos] - in[22 + inpos - 1]) << 26) - ; - out[16 + outpos] = (in[22 + inpos] - in[22 + inpos - 1]) >>> (23 - 17) - | ((in[23 + inpos] - in[23 + inpos - 1]) << 17) - ; - out[17 + outpos] = (in[23 + inpos] - in[23 + inpos - 1]) >>> (23 - 8) - | ((in[24 + inpos] - in[24 + inpos - 1]) << 8) - | ((in[25 + inpos] - in[25 + inpos - 1]) << 31) - ; - out[18 + outpos] = (in[25 + inpos] - in[25 + inpos - 1]) >>> (23 - 22) - | ((in[26 + inpos] - in[26 + inpos - 1]) << 22) - ; - out[19 + outpos] = (in[26 + inpos] - in[26 + inpos - 1]) >>> (23 - 13) - | ((in[27 + inpos] - in[27 + inpos - 1]) << 13) - ; - out[20 + outpos] = (in[27 + inpos] - in[27 + inpos - 1]) >>> (23 - 4) - | ((in[28 + inpos] - in[28 + inpos - 1]) << 4) - | ((in[29 + inpos] - in[29 + inpos - 1]) << 27) - ; - out[21 + outpos] = (in[29 + inpos] - in[29 + inpos - 1]) >>> (23 - 18) - | ((in[30 + inpos] - in[30 + inpos - 1]) << 18) - ; - out[22 + outpos] = (in[30 + inpos] - in[30 + inpos - 1]) >>> (23 - 9) - | ((in[31 + inpos] - in[31 + inpos - 1]) << 9) - ; - } - - - protected static void integratedpack24(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (in[0 + inpos] - initoffset) - | ((in[1 + inpos] - in[1 + inpos - 1]) << 24) - ; - out[1 + outpos] = (in[1 + inpos] - in[1 + inpos - 1]) >>> (24 - 16) - | ((in[2 + inpos] - in[2 + inpos - 1]) << 16) - ; - out[2 + outpos] = (in[2 + inpos] - in[2 + inpos - 1]) >>> (24 - 8) - | ((in[3 + inpos] - in[3 + inpos - 1]) << 8) - ; - out[3 + outpos] = (in[4 + inpos] - in[4 + inpos - 1]) - | ((in[5 + inpos] - in[5 + inpos - 1]) << 24) - ; - out[4 + outpos] = (in[5 + inpos] - in[5 + inpos - 1]) >>> (24 - 16) - | ((in[6 + inpos] - in[6 + inpos - 1]) << 16) - ; - out[5 + outpos] = (in[6 + inpos] - in[6 + inpos - 1]) >>> (24 - 8) - | ((in[7 + inpos] - in[7 + inpos - 1]) << 8) - ; - out[6 + outpos] = (in[8 + inpos] - in[8 + inpos - 1]) - | ((in[9 + inpos] - in[9 + inpos - 1]) << 24) - ; - out[7 + outpos] = (in[9 + inpos] - in[9 + inpos - 1]) >>> (24 - 16) - | ((in[10 + inpos] - in[10 + inpos - 1]) << 16) - ; - out[8 + outpos] = (in[10 + inpos] - in[10 + inpos - 1]) >>> (24 - 8) - | ((in[11 + inpos] - in[11 + inpos - 1]) << 8) - ; - out[9 + outpos] = (in[12 + inpos] - in[12 + inpos - 1]) - | ((in[13 + inpos] - in[13 + inpos - 1]) << 24) - ; - out[10 + outpos] = (in[13 + inpos] - in[13 + inpos - 1]) >>> (24 - 16) - | ((in[14 + inpos] - in[14 + inpos - 1]) << 16) - ; - out[11 + outpos] = (in[14 + inpos] - in[14 + inpos - 1]) >>> (24 - 8) - | ((in[15 + inpos] - in[15 + inpos - 1]) << 8) - ; - out[12 + outpos] = (in[16 + inpos] - in[16 + inpos - 1]) - | ((in[17 + inpos] - in[17 + inpos - 1]) << 24) - ; - out[13 + outpos] = (in[17 + inpos] - in[17 + inpos - 1]) >>> (24 - 16) - | ((in[18 + inpos] - in[18 + inpos - 1]) << 16) - ; - out[14 + outpos] = (in[18 + inpos] - in[18 + inpos - 1]) >>> (24 - 8) - | ((in[19 + inpos] - in[19 + inpos - 1]) << 8) - ; - out[15 + outpos] = (in[20 + inpos] - in[20 + inpos - 1]) - | ((in[21 + inpos] - in[21 + inpos - 1]) << 24) - ; - out[16 + outpos] = (in[21 + inpos] - in[21 + inpos - 1]) >>> (24 - 16) - | ((in[22 + inpos] - in[22 + inpos - 1]) << 16) - ; - out[17 + outpos] = (in[22 + inpos] - in[22 + inpos - 1]) >>> (24 - 8) - | ((in[23 + inpos] - in[23 + inpos - 1]) << 8) - ; - out[18 + outpos] = (in[24 + inpos] - in[24 + inpos - 1]) - | ((in[25 + inpos] - in[25 + inpos - 1]) << 24) - ; - out[19 + outpos] = (in[25 + inpos] - in[25 + inpos - 1]) >>> (24 - 16) - | ((in[26 + inpos] - in[26 + inpos - 1]) << 16) - ; - out[20 + outpos] = (in[26 + inpos] - in[26 + inpos - 1]) >>> (24 - 8) - | ((in[27 + inpos] - in[27 + inpos - 1]) << 8) - ; - out[21 + outpos] = (in[28 + inpos] - in[28 + inpos - 1]) - | ((in[29 + inpos] - in[29 + inpos - 1]) << 24) - ; - out[22 + outpos] = (in[29 + inpos] - in[29 + inpos - 1]) >>> (24 - 16) - | ((in[30 + inpos] - in[30 + inpos - 1]) << 16) - ; - out[23 + outpos] = (in[30 + inpos] - in[30 + inpos - 1]) >>> (24 - 8) - | ((in[31 + inpos] - in[31 + inpos - 1]) << 8) - ; - } - - - protected static void integratedpack25(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (in[0 + inpos] - initoffset) - | ((in[1 + inpos] - in[1 + inpos - 1]) << 25) - ; - out[1 + outpos] = (in[1 + inpos] - in[1 + inpos - 1]) >>> (25 - 18) - | ((in[2 + inpos] - in[2 + inpos - 1]) << 18) - ; - out[2 + outpos] = (in[2 + inpos] - in[2 + inpos - 1]) >>> (25 - 11) - | ((in[3 + inpos] - in[3 + inpos - 1]) << 11) - ; - out[3 + outpos] = (in[3 + inpos] - in[3 + inpos - 1]) >>> (25 - 4) - | ((in[4 + inpos] - in[4 + inpos - 1]) << 4) - | ((in[5 + inpos] - in[5 + inpos - 1]) << 29) - ; - out[4 + outpos] = (in[5 + inpos] - in[5 + inpos - 1]) >>> (25 - 22) - | ((in[6 + inpos] - in[6 + inpos - 1]) << 22) - ; - out[5 + outpos] = (in[6 + inpos] - in[6 + inpos - 1]) >>> (25 - 15) - | ((in[7 + inpos] - in[7 + inpos - 1]) << 15) - ; - out[6 + outpos] = (in[7 + inpos] - in[7 + inpos - 1]) >>> (25 - 8) - | ((in[8 + inpos] - in[8 + inpos - 1]) << 8) - ; - out[7 + outpos] = (in[8 + inpos] - in[8 + inpos - 1]) >>> (25 - 1) - | ((in[9 + inpos] - in[9 + inpos - 1]) << 1) - | ((in[10 + inpos] - in[10 + inpos - 1]) << 26) - ; - out[8 + outpos] = (in[10 + inpos] - in[10 + inpos - 1]) >>> (25 - 19) - | ((in[11 + inpos] - in[11 + inpos - 1]) << 19) - ; - out[9 + outpos] = (in[11 + inpos] - in[11 + inpos - 1]) >>> (25 - 12) - | ((in[12 + inpos] - in[12 + inpos - 1]) << 12) - ; - out[10 + outpos] = (in[12 + inpos] - in[12 + inpos - 1]) >>> (25 - 5) - | ((in[13 + inpos] - in[13 + inpos - 1]) << 5) - | ((in[14 + inpos] - in[14 + inpos - 1]) << 30) - ; - out[11 + outpos] = (in[14 + inpos] - in[14 + inpos - 1]) >>> (25 - 23) - | ((in[15 + inpos] - in[15 + inpos - 1]) << 23) - ; - out[12 + outpos] = (in[15 + inpos] - in[15 + inpos - 1]) >>> (25 - 16) - | ((in[16 + inpos] - in[16 + inpos - 1]) << 16) - ; - out[13 + outpos] = (in[16 + inpos] - in[16 + inpos - 1]) >>> (25 - 9) - | ((in[17 + inpos] - in[17 + inpos - 1]) << 9) - ; - out[14 + outpos] = (in[17 + inpos] - in[17 + inpos - 1]) >>> (25 - 2) - | ((in[18 + inpos] - in[18 + inpos - 1]) << 2) - | ((in[19 + inpos] - in[19 + inpos - 1]) << 27) - ; - out[15 + outpos] = (in[19 + inpos] - in[19 + inpos - 1]) >>> (25 - 20) - | ((in[20 + inpos] - in[20 + inpos - 1]) << 20) - ; - out[16 + outpos] = (in[20 + inpos] - in[20 + inpos - 1]) >>> (25 - 13) - | ((in[21 + inpos] - in[21 + inpos - 1]) << 13) - ; - out[17 + outpos] = (in[21 + inpos] - in[21 + inpos - 1]) >>> (25 - 6) - | ((in[22 + inpos] - in[22 + inpos - 1]) << 6) - | ((in[23 + inpos] - in[23 + inpos - 1]) << 31) - ; - out[18 + outpos] = (in[23 + inpos] - in[23 + inpos - 1]) >>> (25 - 24) - | ((in[24 + inpos] - in[24 + inpos - 1]) << 24) - ; - out[19 + outpos] = (in[24 + inpos] - in[24 + inpos - 1]) >>> (25 - 17) - | ((in[25 + inpos] - in[25 + inpos - 1]) << 17) - ; - out[20 + outpos] = (in[25 + inpos] - in[25 + inpos - 1]) >>> (25 - 10) - | ((in[26 + inpos] - in[26 + inpos - 1]) << 10) - ; - out[21 + outpos] = (in[26 + inpos] - in[26 + inpos - 1]) >>> (25 - 3) - | ((in[27 + inpos] - in[27 + inpos - 1]) << 3) - | ((in[28 + inpos] - in[28 + inpos - 1]) << 28) - ; - out[22 + outpos] = (in[28 + inpos] - in[28 + inpos - 1]) >>> (25 - 21) - | ((in[29 + inpos] - in[29 + inpos - 1]) << 21) - ; - out[23 + outpos] = (in[29 + inpos] - in[29 + inpos - 1]) >>> (25 - 14) - | ((in[30 + inpos] - in[30 + inpos - 1]) << 14) - ; - out[24 + outpos] = (in[30 + inpos] - in[30 + inpos - 1]) >>> (25 - 7) - | ((in[31 + inpos] - in[31 + inpos - 1]) << 7) - ; - } - - - protected static void integratedpack26(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (in[0 + inpos] - initoffset) - | ((in[1 + inpos] - in[1 + inpos - 1]) << 26) - ; - out[1 + outpos] = (in[1 + inpos] - in[1 + inpos - 1]) >>> (26 - 20) - | ((in[2 + inpos] - in[2 + inpos - 1]) << 20) - ; - out[2 + outpos] = (in[2 + inpos] - in[2 + inpos - 1]) >>> (26 - 14) - | ((in[3 + inpos] - in[3 + inpos - 1]) << 14) - ; - out[3 + outpos] = (in[3 + inpos] - in[3 + inpos - 1]) >>> (26 - 8) - | ((in[4 + inpos] - in[4 + inpos - 1]) << 8) - ; - out[4 + outpos] = (in[4 + inpos] - in[4 + inpos - 1]) >>> (26 - 2) - | ((in[5 + inpos] - in[5 + inpos - 1]) << 2) - | ((in[6 + inpos] - in[6 + inpos - 1]) << 28) - ; - out[5 + outpos] = (in[6 + inpos] - in[6 + inpos - 1]) >>> (26 - 22) - | ((in[7 + inpos] - in[7 + inpos - 1]) << 22) - ; - out[6 + outpos] = (in[7 + inpos] - in[7 + inpos - 1]) >>> (26 - 16) - | ((in[8 + inpos] - in[8 + inpos - 1]) << 16) - ; - out[7 + outpos] = (in[8 + inpos] - in[8 + inpos - 1]) >>> (26 - 10) - | ((in[9 + inpos] - in[9 + inpos - 1]) << 10) - ; - out[8 + outpos] = (in[9 + inpos] - in[9 + inpos - 1]) >>> (26 - 4) - | ((in[10 + inpos] - in[10 + inpos - 1]) << 4) - | ((in[11 + inpos] - in[11 + inpos - 1]) << 30) - ; - out[9 + outpos] = (in[11 + inpos] - in[11 + inpos - 1]) >>> (26 - 24) - | ((in[12 + inpos] - in[12 + inpos - 1]) << 24) - ; - out[10 + outpos] = (in[12 + inpos] - in[12 + inpos - 1]) >>> (26 - 18) - | ((in[13 + inpos] - in[13 + inpos - 1]) << 18) - ; - out[11 + outpos] = (in[13 + inpos] - in[13 + inpos - 1]) >>> (26 - 12) - | ((in[14 + inpos] - in[14 + inpos - 1]) << 12) - ; - out[12 + outpos] = (in[14 + inpos] - in[14 + inpos - 1]) >>> (26 - 6) - | ((in[15 + inpos] - in[15 + inpos - 1]) << 6) - ; - out[13 + outpos] = (in[16 + inpos] - in[16 + inpos - 1]) - | ((in[17 + inpos] - in[17 + inpos - 1]) << 26) - ; - out[14 + outpos] = (in[17 + inpos] - in[17 + inpos - 1]) >>> (26 - 20) - | ((in[18 + inpos] - in[18 + inpos - 1]) << 20) - ; - out[15 + outpos] = (in[18 + inpos] - in[18 + inpos - 1]) >>> (26 - 14) - | ((in[19 + inpos] - in[19 + inpos - 1]) << 14) - ; - out[16 + outpos] = (in[19 + inpos] - in[19 + inpos - 1]) >>> (26 - 8) - | ((in[20 + inpos] - in[20 + inpos - 1]) << 8) - ; - out[17 + outpos] = (in[20 + inpos] - in[20 + inpos - 1]) >>> (26 - 2) - | ((in[21 + inpos] - in[21 + inpos - 1]) << 2) - | ((in[22 + inpos] - in[22 + inpos - 1]) << 28) - ; - out[18 + outpos] = (in[22 + inpos] - in[22 + inpos - 1]) >>> (26 - 22) - | ((in[23 + inpos] - in[23 + inpos - 1]) << 22) - ; - out[19 + outpos] = (in[23 + inpos] - in[23 + inpos - 1]) >>> (26 - 16) - | ((in[24 + inpos] - in[24 + inpos - 1]) << 16) - ; - out[20 + outpos] = (in[24 + inpos] - in[24 + inpos - 1]) >>> (26 - 10) - | ((in[25 + inpos] - in[25 + inpos - 1]) << 10) - ; - out[21 + outpos] = (in[25 + inpos] - in[25 + inpos - 1]) >>> (26 - 4) - | ((in[26 + inpos] - in[26 + inpos - 1]) << 4) - | ((in[27 + inpos] - in[27 + inpos - 1]) << 30) - ; - out[22 + outpos] = (in[27 + inpos] - in[27 + inpos - 1]) >>> (26 - 24) - | ((in[28 + inpos] - in[28 + inpos - 1]) << 24) - ; - out[23 + outpos] = (in[28 + inpos] - in[28 + inpos - 1]) >>> (26 - 18) - | ((in[29 + inpos] - in[29 + inpos - 1]) << 18) - ; - out[24 + outpos] = (in[29 + inpos] - in[29 + inpos - 1]) >>> (26 - 12) - | ((in[30 + inpos] - in[30 + inpos - 1]) << 12) - ; - out[25 + outpos] = (in[30 + inpos] - in[30 + inpos - 1]) >>> (26 - 6) - | ((in[31 + inpos] - in[31 + inpos - 1]) << 6) - ; - } - - - protected static void integratedpack27(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (in[0 + inpos] - initoffset) - | ((in[1 + inpos] - in[1 + inpos - 1]) << 27) - ; - out[1 + outpos] = (in[1 + inpos] - in[1 + inpos - 1]) >>> (27 - 22) - | ((in[2 + inpos] - in[2 + inpos - 1]) << 22) - ; - out[2 + outpos] = (in[2 + inpos] - in[2 + inpos - 1]) >>> (27 - 17) - | ((in[3 + inpos] - in[3 + inpos - 1]) << 17) - ; - out[3 + outpos] = (in[3 + inpos] - in[3 + inpos - 1]) >>> (27 - 12) - | ((in[4 + inpos] - in[4 + inpos - 1]) << 12) - ; - out[4 + outpos] = (in[4 + inpos] - in[4 + inpos - 1]) >>> (27 - 7) - | ((in[5 + inpos] - in[5 + inpos - 1]) << 7) - ; - out[5 + outpos] = (in[5 + inpos] - in[5 + inpos - 1]) >>> (27 - 2) - | ((in[6 + inpos] - in[6 + inpos - 1]) << 2) - | ((in[7 + inpos] - in[7 + inpos - 1]) << 29) - ; - out[6 + outpos] = (in[7 + inpos] - in[7 + inpos - 1]) >>> (27 - 24) - | ((in[8 + inpos] - in[8 + inpos - 1]) << 24) - ; - out[7 + outpos] = (in[8 + inpos] - in[8 + inpos - 1]) >>> (27 - 19) - | ((in[9 + inpos] - in[9 + inpos - 1]) << 19) - ; - out[8 + outpos] = (in[9 + inpos] - in[9 + inpos - 1]) >>> (27 - 14) - | ((in[10 + inpos] - in[10 + inpos - 1]) << 14) - ; - out[9 + outpos] = (in[10 + inpos] - in[10 + inpos - 1]) >>> (27 - 9) - | ((in[11 + inpos] - in[11 + inpos - 1]) << 9) - ; - out[10 + outpos] = (in[11 + inpos] - in[11 + inpos - 1]) >>> (27 - 4) - | ((in[12 + inpos] - in[12 + inpos - 1]) << 4) - | ((in[13 + inpos] - in[13 + inpos - 1]) << 31) - ; - out[11 + outpos] = (in[13 + inpos] - in[13 + inpos - 1]) >>> (27 - 26) - | ((in[14 + inpos] - in[14 + inpos - 1]) << 26) - ; - out[12 + outpos] = (in[14 + inpos] - in[14 + inpos - 1]) >>> (27 - 21) - | ((in[15 + inpos] - in[15 + inpos - 1]) << 21) - ; - out[13 + outpos] = (in[15 + inpos] - in[15 + inpos - 1]) >>> (27 - 16) - | ((in[16 + inpos] - in[16 + inpos - 1]) << 16) - ; - out[14 + outpos] = (in[16 + inpos] - in[16 + inpos - 1]) >>> (27 - 11) - | ((in[17 + inpos] - in[17 + inpos - 1]) << 11) - ; - out[15 + outpos] = (in[17 + inpos] - in[17 + inpos - 1]) >>> (27 - 6) - | ((in[18 + inpos] - in[18 + inpos - 1]) << 6) - ; - out[16 + outpos] = (in[18 + inpos] - in[18 + inpos - 1]) >>> (27 - 1) - | ((in[19 + inpos] - in[19 + inpos - 1]) << 1) - | ((in[20 + inpos] - in[20 + inpos - 1]) << 28) - ; - out[17 + outpos] = (in[20 + inpos] - in[20 + inpos - 1]) >>> (27 - 23) - | ((in[21 + inpos] - in[21 + inpos - 1]) << 23) - ; - out[18 + outpos] = (in[21 + inpos] - in[21 + inpos - 1]) >>> (27 - 18) - | ((in[22 + inpos] - in[22 + inpos - 1]) << 18) - ; - out[19 + outpos] = (in[22 + inpos] - in[22 + inpos - 1]) >>> (27 - 13) - | ((in[23 + inpos] - in[23 + inpos - 1]) << 13) - ; - out[20 + outpos] = (in[23 + inpos] - in[23 + inpos - 1]) >>> (27 - 8) - | ((in[24 + inpos] - in[24 + inpos - 1]) << 8) - ; - out[21 + outpos] = (in[24 + inpos] - in[24 + inpos - 1]) >>> (27 - 3) - | ((in[25 + inpos] - in[25 + inpos - 1]) << 3) - | ((in[26 + inpos] - in[26 + inpos - 1]) << 30) - ; - out[22 + outpos] = (in[26 + inpos] - in[26 + inpos - 1]) >>> (27 - 25) - | ((in[27 + inpos] - in[27 + inpos - 1]) << 25) - ; - out[23 + outpos] = (in[27 + inpos] - in[27 + inpos - 1]) >>> (27 - 20) - | ((in[28 + inpos] - in[28 + inpos - 1]) << 20) - ; - out[24 + outpos] = (in[28 + inpos] - in[28 + inpos - 1]) >>> (27 - 15) - | ((in[29 + inpos] - in[29 + inpos - 1]) << 15) - ; - out[25 + outpos] = (in[29 + inpos] - in[29 + inpos - 1]) >>> (27 - 10) - | ((in[30 + inpos] - in[30 + inpos - 1]) << 10) - ; - out[26 + outpos] = (in[30 + inpos] - in[30 + inpos - 1]) >>> (27 - 5) - | ((in[31 + inpos] - in[31 + inpos - 1]) << 5) - ; - } - - - protected static void integratedpack28(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (in[0 + inpos] - initoffset) - | ((in[1 + inpos] - in[1 + inpos - 1]) << 28) - ; - out[1 + outpos] = (in[1 + inpos] - in[1 + inpos - 1]) >>> (28 - 24) - | ((in[2 + inpos] - in[2 + inpos - 1]) << 24) - ; - out[2 + outpos] = (in[2 + inpos] - in[2 + inpos - 1]) >>> (28 - 20) - | ((in[3 + inpos] - in[3 + inpos - 1]) << 20) - ; - out[3 + outpos] = (in[3 + inpos] - in[3 + inpos - 1]) >>> (28 - 16) - | ((in[4 + inpos] - in[4 + inpos - 1]) << 16) - ; - out[4 + outpos] = (in[4 + inpos] - in[4 + inpos - 1]) >>> (28 - 12) - | ((in[5 + inpos] - in[5 + inpos - 1]) << 12) - ; - out[5 + outpos] = (in[5 + inpos] - in[5 + inpos - 1]) >>> (28 - 8) - | ((in[6 + inpos] - in[6 + inpos - 1]) << 8) - ; - out[6 + outpos] = (in[6 + inpos] - in[6 + inpos - 1]) >>> (28 - 4) - | ((in[7 + inpos] - in[7 + inpos - 1]) << 4) - ; - out[7 + outpos] = (in[8 + inpos] - in[8 + inpos - 1]) - | ((in[9 + inpos] - in[9 + inpos - 1]) << 28) - ; - out[8 + outpos] = (in[9 + inpos] - in[9 + inpos - 1]) >>> (28 - 24) - | ((in[10 + inpos] - in[10 + inpos - 1]) << 24) - ; - out[9 + outpos] = (in[10 + inpos] - in[10 + inpos - 1]) >>> (28 - 20) - | ((in[11 + inpos] - in[11 + inpos - 1]) << 20) - ; - out[10 + outpos] = (in[11 + inpos] - in[11 + inpos - 1]) >>> (28 - 16) - | ((in[12 + inpos] - in[12 + inpos - 1]) << 16) - ; - out[11 + outpos] = (in[12 + inpos] - in[12 + inpos - 1]) >>> (28 - 12) - | ((in[13 + inpos] - in[13 + inpos - 1]) << 12) - ; - out[12 + outpos] = (in[13 + inpos] - in[13 + inpos - 1]) >>> (28 - 8) - | ((in[14 + inpos] - in[14 + inpos - 1]) << 8) - ; - out[13 + outpos] = (in[14 + inpos] - in[14 + inpos - 1]) >>> (28 - 4) - | ((in[15 + inpos] - in[15 + inpos - 1]) << 4) - ; - out[14 + outpos] = (in[16 + inpos] - in[16 + inpos - 1]) - | ((in[17 + inpos] - in[17 + inpos - 1]) << 28) - ; - out[15 + outpos] = (in[17 + inpos] - in[17 + inpos - 1]) >>> (28 - 24) - | ((in[18 + inpos] - in[18 + inpos - 1]) << 24) - ; - out[16 + outpos] = (in[18 + inpos] - in[18 + inpos - 1]) >>> (28 - 20) - | ((in[19 + inpos] - in[19 + inpos - 1]) << 20) - ; - out[17 + outpos] = (in[19 + inpos] - in[19 + inpos - 1]) >>> (28 - 16) - | ((in[20 + inpos] - in[20 + inpos - 1]) << 16) - ; - out[18 + outpos] = (in[20 + inpos] - in[20 + inpos - 1]) >>> (28 - 12) - | ((in[21 + inpos] - in[21 + inpos - 1]) << 12) - ; - out[19 + outpos] = (in[21 + inpos] - in[21 + inpos - 1]) >>> (28 - 8) - | ((in[22 + inpos] - in[22 + inpos - 1]) << 8) - ; - out[20 + outpos] = (in[22 + inpos] - in[22 + inpos - 1]) >>> (28 - 4) - | ((in[23 + inpos] - in[23 + inpos - 1]) << 4) - ; - out[21 + outpos] = (in[24 + inpos] - in[24 + inpos - 1]) - | ((in[25 + inpos] - in[25 + inpos - 1]) << 28) - ; - out[22 + outpos] = (in[25 + inpos] - in[25 + inpos - 1]) >>> (28 - 24) - | ((in[26 + inpos] - in[26 + inpos - 1]) << 24) - ; - out[23 + outpos] = (in[26 + inpos] - in[26 + inpos - 1]) >>> (28 - 20) - | ((in[27 + inpos] - in[27 + inpos - 1]) << 20) - ; - out[24 + outpos] = (in[27 + inpos] - in[27 + inpos - 1]) >>> (28 - 16) - | ((in[28 + inpos] - in[28 + inpos - 1]) << 16) - ; - out[25 + outpos] = (in[28 + inpos] - in[28 + inpos - 1]) >>> (28 - 12) - | ((in[29 + inpos] - in[29 + inpos - 1]) << 12) - ; - out[26 + outpos] = (in[29 + inpos] - in[29 + inpos - 1]) >>> (28 - 8) - | ((in[30 + inpos] - in[30 + inpos - 1]) << 8) - ; - out[27 + outpos] = (in[30 + inpos] - in[30 + inpos - 1]) >>> (28 - 4) - | ((in[31 + inpos] - in[31 + inpos - 1]) << 4) - ; - } - - - protected static void integratedpack29(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (in[0 + inpos] - initoffset) - | ((in[1 + inpos] - in[1 + inpos - 1]) << 29) - ; - out[1 + outpos] = (in[1 + inpos] - in[1 + inpos - 1]) >>> (29 - 26) - | ((in[2 + inpos] - in[2 + inpos - 1]) << 26) - ; - out[2 + outpos] = (in[2 + inpos] - in[2 + inpos - 1]) >>> (29 - 23) - | ((in[3 + inpos] - in[3 + inpos - 1]) << 23) - ; - out[3 + outpos] = (in[3 + inpos] - in[3 + inpos - 1]) >>> (29 - 20) - | ((in[4 + inpos] - in[4 + inpos - 1]) << 20) - ; - out[4 + outpos] = (in[4 + inpos] - in[4 + inpos - 1]) >>> (29 - 17) - | ((in[5 + inpos] - in[5 + inpos - 1]) << 17) - ; - out[5 + outpos] = (in[5 + inpos] - in[5 + inpos - 1]) >>> (29 - 14) - | ((in[6 + inpos] - in[6 + inpos - 1]) << 14) - ; - out[6 + outpos] = (in[6 + inpos] - in[6 + inpos - 1]) >>> (29 - 11) - | ((in[7 + inpos] - in[7 + inpos - 1]) << 11) - ; - out[7 + outpos] = (in[7 + inpos] - in[7 + inpos - 1]) >>> (29 - 8) - | ((in[8 + inpos] - in[8 + inpos - 1]) << 8) - ; - out[8 + outpos] = (in[8 + inpos] - in[8 + inpos - 1]) >>> (29 - 5) - | ((in[9 + inpos] - in[9 + inpos - 1]) << 5) - ; - out[9 + outpos] = (in[9 + inpos] - in[9 + inpos - 1]) >>> (29 - 2) - | ((in[10 + inpos] - in[10 + inpos - 1]) << 2) - | ((in[11 + inpos] - in[11 + inpos - 1]) << 31) - ; - out[10 + outpos] = (in[11 + inpos] - in[11 + inpos - 1]) >>> (29 - 28) - | ((in[12 + inpos] - in[12 + inpos - 1]) << 28) - ; - out[11 + outpos] = (in[12 + inpos] - in[12 + inpos - 1]) >>> (29 - 25) - | ((in[13 + inpos] - in[13 + inpos - 1]) << 25) - ; - out[12 + outpos] = (in[13 + inpos] - in[13 + inpos - 1]) >>> (29 - 22) - | ((in[14 + inpos] - in[14 + inpos - 1]) << 22) - ; - out[13 + outpos] = (in[14 + inpos] - in[14 + inpos - 1]) >>> (29 - 19) - | ((in[15 + inpos] - in[15 + inpos - 1]) << 19) - ; - out[14 + outpos] = (in[15 + inpos] - in[15 + inpos - 1]) >>> (29 - 16) - | ((in[16 + inpos] - in[16 + inpos - 1]) << 16) - ; - out[15 + outpos] = (in[16 + inpos] - in[16 + inpos - 1]) >>> (29 - 13) - | ((in[17 + inpos] - in[17 + inpos - 1]) << 13) - ; - out[16 + outpos] = (in[17 + inpos] - in[17 + inpos - 1]) >>> (29 - 10) - | ((in[18 + inpos] - in[18 + inpos - 1]) << 10) - ; - out[17 + outpos] = (in[18 + inpos] - in[18 + inpos - 1]) >>> (29 - 7) - | ((in[19 + inpos] - in[19 + inpos - 1]) << 7) - ; - out[18 + outpos] = (in[19 + inpos] - in[19 + inpos - 1]) >>> (29 - 4) - | ((in[20 + inpos] - in[20 + inpos - 1]) << 4) - ; - out[19 + outpos] = (in[20 + inpos] - in[20 + inpos - 1]) >>> (29 - 1) - | ((in[21 + inpos] - in[21 + inpos - 1]) << 1) - | ((in[22 + inpos] - in[22 + inpos - 1]) << 30) - ; - out[20 + outpos] = (in[22 + inpos] - in[22 + inpos - 1]) >>> (29 - 27) - | ((in[23 + inpos] - in[23 + inpos - 1]) << 27) - ; - out[21 + outpos] = (in[23 + inpos] - in[23 + inpos - 1]) >>> (29 - 24) - | ((in[24 + inpos] - in[24 + inpos - 1]) << 24) - ; - out[22 + outpos] = (in[24 + inpos] - in[24 + inpos - 1]) >>> (29 - 21) - | ((in[25 + inpos] - in[25 + inpos - 1]) << 21) - ; - out[23 + outpos] = (in[25 + inpos] - in[25 + inpos - 1]) >>> (29 - 18) - | ((in[26 + inpos] - in[26 + inpos - 1]) << 18) - ; - out[24 + outpos] = (in[26 + inpos] - in[26 + inpos - 1]) >>> (29 - 15) - | ((in[27 + inpos] - in[27 + inpos - 1]) << 15) - ; - out[25 + outpos] = (in[27 + inpos] - in[27 + inpos - 1]) >>> (29 - 12) - | ((in[28 + inpos] - in[28 + inpos - 1]) << 12) - ; - out[26 + outpos] = (in[28 + inpos] - in[28 + inpos - 1]) >>> (29 - 9) - | ((in[29 + inpos] - in[29 + inpos - 1]) << 9) - ; - out[27 + outpos] = (in[29 + inpos] - in[29 + inpos - 1]) >>> (29 - 6) - | ((in[30 + inpos] - in[30 + inpos - 1]) << 6) - ; - out[28 + outpos] = (in[30 + inpos] - in[30 + inpos - 1]) >>> (29 - 3) - | ((in[31 + inpos] - in[31 + inpos - 1]) << 3) - ; - } - - - protected static void integratedpack30(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (in[0 + inpos] - initoffset) - | ((in[1 + inpos] - in[1 + inpos - 1]) << 30) - ; - out[1 + outpos] = (in[1 + inpos] - in[1 + inpos - 1]) >>> (30 - 28) - | ((in[2 + inpos] - in[2 + inpos - 1]) << 28) - ; - out[2 + outpos] = (in[2 + inpos] - in[2 + inpos - 1]) >>> (30 - 26) - | ((in[3 + inpos] - in[3 + inpos - 1]) << 26) - ; - out[3 + outpos] = (in[3 + inpos] - in[3 + inpos - 1]) >>> (30 - 24) - | ((in[4 + inpos] - in[4 + inpos - 1]) << 24) - ; - out[4 + outpos] = (in[4 + inpos] - in[4 + inpos - 1]) >>> (30 - 22) - | ((in[5 + inpos] - in[5 + inpos - 1]) << 22) - ; - out[5 + outpos] = (in[5 + inpos] - in[5 + inpos - 1]) >>> (30 - 20) - | ((in[6 + inpos] - in[6 + inpos - 1]) << 20) - ; - out[6 + outpos] = (in[6 + inpos] - in[6 + inpos - 1]) >>> (30 - 18) - | ((in[7 + inpos] - in[7 + inpos - 1]) << 18) - ; - out[7 + outpos] = (in[7 + inpos] - in[7 + inpos - 1]) >>> (30 - 16) - | ((in[8 + inpos] - in[8 + inpos - 1]) << 16) - ; - out[8 + outpos] = (in[8 + inpos] - in[8 + inpos - 1]) >>> (30 - 14) - | ((in[9 + inpos] - in[9 + inpos - 1]) << 14) - ; - out[9 + outpos] = (in[9 + inpos] - in[9 + inpos - 1]) >>> (30 - 12) - | ((in[10 + inpos] - in[10 + inpos - 1]) << 12) - ; - out[10 + outpos] = (in[10 + inpos] - in[10 + inpos - 1]) >>> (30 - 10) - | ((in[11 + inpos] - in[11 + inpos - 1]) << 10) - ; - out[11 + outpos] = (in[11 + inpos] - in[11 + inpos - 1]) >>> (30 - 8) - | ((in[12 + inpos] - in[12 + inpos - 1]) << 8) - ; - out[12 + outpos] = (in[12 + inpos] - in[12 + inpos - 1]) >>> (30 - 6) - | ((in[13 + inpos] - in[13 + inpos - 1]) << 6) - ; - out[13 + outpos] = (in[13 + inpos] - in[13 + inpos - 1]) >>> (30 - 4) - | ((in[14 + inpos] - in[14 + inpos - 1]) << 4) - ; - out[14 + outpos] = (in[14 + inpos] - in[14 + inpos - 1]) >>> (30 - 2) - | ((in[15 + inpos] - in[15 + inpos - 1]) << 2) - ; - out[15 + outpos] = (in[16 + inpos] - in[16 + inpos - 1]) - | ((in[17 + inpos] - in[17 + inpos - 1]) << 30) - ; - out[16 + outpos] = (in[17 + inpos] - in[17 + inpos - 1]) >>> (30 - 28) - | ((in[18 + inpos] - in[18 + inpos - 1]) << 28) - ; - out[17 + outpos] = (in[18 + inpos] - in[18 + inpos - 1]) >>> (30 - 26) - | ((in[19 + inpos] - in[19 + inpos - 1]) << 26) - ; - out[18 + outpos] = (in[19 + inpos] - in[19 + inpos - 1]) >>> (30 - 24) - | ((in[20 + inpos] - in[20 + inpos - 1]) << 24) - ; - out[19 + outpos] = (in[20 + inpos] - in[20 + inpos - 1]) >>> (30 - 22) - | ((in[21 + inpos] - in[21 + inpos - 1]) << 22) - ; - out[20 + outpos] = (in[21 + inpos] - in[21 + inpos - 1]) >>> (30 - 20) - | ((in[22 + inpos] - in[22 + inpos - 1]) << 20) - ; - out[21 + outpos] = (in[22 + inpos] - in[22 + inpos - 1]) >>> (30 - 18) - | ((in[23 + inpos] - in[23 + inpos - 1]) << 18) - ; - out[22 + outpos] = (in[23 + inpos] - in[23 + inpos - 1]) >>> (30 - 16) - | ((in[24 + inpos] - in[24 + inpos - 1]) << 16) - ; - out[23 + outpos] = (in[24 + inpos] - in[24 + inpos - 1]) >>> (30 - 14) - | ((in[25 + inpos] - in[25 + inpos - 1]) << 14) - ; - out[24 + outpos] = (in[25 + inpos] - in[25 + inpos - 1]) >>> (30 - 12) - | ((in[26 + inpos] - in[26 + inpos - 1]) << 12) - ; - out[25 + outpos] = (in[26 + inpos] - in[26 + inpos - 1]) >>> (30 - 10) - | ((in[27 + inpos] - in[27 + inpos - 1]) << 10) - ; - out[26 + outpos] = (in[27 + inpos] - in[27 + inpos - 1]) >>> (30 - 8) - | ((in[28 + inpos] - in[28 + inpos - 1]) << 8) - ; - out[27 + outpos] = (in[28 + inpos] - in[28 + inpos - 1]) >>> (30 - 6) - | ((in[29 + inpos] - in[29 + inpos - 1]) << 6) - ; - out[28 + outpos] = (in[29 + inpos] - in[29 + inpos - 1]) >>> (30 - 4) - | ((in[30 + inpos] - in[30 + inpos - 1]) << 4) - ; - out[29 + outpos] = (in[30 + inpos] - in[30 + inpos - 1]) >>> (30 - 2) - | ((in[31 + inpos] - in[31 + inpos - 1]) << 2) - ; - } - - - protected static void integratedpack31(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (in[0 + inpos] - initoffset) - | ((in[1 + inpos] - in[1 + inpos - 1]) << 31) - ; - out[1 + outpos] = (in[1 + inpos] - in[1 + inpos - 1]) >>> (31 - 30) - | ((in[2 + inpos] - in[2 + inpos - 1]) << 30) - ; - out[2 + outpos] = (in[2 + inpos] - in[2 + inpos - 1]) >>> (31 - 29) - | ((in[3 + inpos] - in[3 + inpos - 1]) << 29) - ; - out[3 + outpos] = (in[3 + inpos] - in[3 + inpos - 1]) >>> (31 - 28) - | ((in[4 + inpos] - in[4 + inpos - 1]) << 28) - ; - out[4 + outpos] = (in[4 + inpos] - in[4 + inpos - 1]) >>> (31 - 27) - | ((in[5 + inpos] - in[5 + inpos - 1]) << 27) - ; - out[5 + outpos] = (in[5 + inpos] - in[5 + inpos - 1]) >>> (31 - 26) - | ((in[6 + inpos] - in[6 + inpos - 1]) << 26) - ; - out[6 + outpos] = (in[6 + inpos] - in[6 + inpos - 1]) >>> (31 - 25) - | ((in[7 + inpos] - in[7 + inpos - 1]) << 25) - ; - out[7 + outpos] = (in[7 + inpos] - in[7 + inpos - 1]) >>> (31 - 24) - | ((in[8 + inpos] - in[8 + inpos - 1]) << 24) - ; - out[8 + outpos] = (in[8 + inpos] - in[8 + inpos - 1]) >>> (31 - 23) - | ((in[9 + inpos] - in[9 + inpos - 1]) << 23) - ; - out[9 + outpos] = (in[9 + inpos] - in[9 + inpos - 1]) >>> (31 - 22) - | ((in[10 + inpos] - in[10 + inpos - 1]) << 22) - ; - out[10 + outpos] = (in[10 + inpos] - in[10 + inpos - 1]) >>> (31 - 21) - | ((in[11 + inpos] - in[11 + inpos - 1]) << 21) - ; - out[11 + outpos] = (in[11 + inpos] - in[11 + inpos - 1]) >>> (31 - 20) - | ((in[12 + inpos] - in[12 + inpos - 1]) << 20) - ; - out[12 + outpos] = (in[12 + inpos] - in[12 + inpos - 1]) >>> (31 - 19) - | ((in[13 + inpos] - in[13 + inpos - 1]) << 19) - ; - out[13 + outpos] = (in[13 + inpos] - in[13 + inpos - 1]) >>> (31 - 18) - | ((in[14 + inpos] - in[14 + inpos - 1]) << 18) - ; - out[14 + outpos] = (in[14 + inpos] - in[14 + inpos - 1]) >>> (31 - 17) - | ((in[15 + inpos] - in[15 + inpos - 1]) << 17) - ; - out[15 + outpos] = (in[15 + inpos] - in[15 + inpos - 1]) >>> (31 - 16) - | ((in[16 + inpos] - in[16 + inpos - 1]) << 16) - ; - out[16 + outpos] = (in[16 + inpos] - in[16 + inpos - 1]) >>> (31 - 15) - | ((in[17 + inpos] - in[17 + inpos - 1]) << 15) - ; - out[17 + outpos] = (in[17 + inpos] - in[17 + inpos - 1]) >>> (31 - 14) - | ((in[18 + inpos] - in[18 + inpos - 1]) << 14) - ; - out[18 + outpos] = (in[18 + inpos] - in[18 + inpos - 1]) >>> (31 - 13) - | ((in[19 + inpos] - in[19 + inpos - 1]) << 13) - ; - out[19 + outpos] = (in[19 + inpos] - in[19 + inpos - 1]) >>> (31 - 12) - | ((in[20 + inpos] - in[20 + inpos - 1]) << 12) - ; - out[20 + outpos] = (in[20 + inpos] - in[20 + inpos - 1]) >>> (31 - 11) - | ((in[21 + inpos] - in[21 + inpos - 1]) << 11) - ; - out[21 + outpos] = (in[21 + inpos] - in[21 + inpos - 1]) >>> (31 - 10) - | ((in[22 + inpos] - in[22 + inpos - 1]) << 10) - ; - out[22 + outpos] = (in[22 + inpos] - in[22 + inpos - 1]) >>> (31 - 9) - | ((in[23 + inpos] - in[23 + inpos - 1]) << 9) - ; - out[23 + outpos] = (in[23 + inpos] - in[23 + inpos - 1]) >>> (31 - 8) - | ((in[24 + inpos] - in[24 + inpos - 1]) << 8) - ; - out[24 + outpos] = (in[24 + inpos] - in[24 + inpos - 1]) >>> (31 - 7) - | ((in[25 + inpos] - in[25 + inpos - 1]) << 7) - ; - out[25 + outpos] = (in[25 + inpos] - in[25 + inpos - 1]) >>> (31 - 6) - | ((in[26 + inpos] - in[26 + inpos - 1]) << 6) - ; - out[26 + outpos] = (in[26 + inpos] - in[26 + inpos - 1]) >>> (31 - 5) - | ((in[27 + inpos] - in[27 + inpos - 1]) << 5) - ; - out[27 + outpos] = (in[27 + inpos] - in[27 + inpos - 1]) >>> (31 - 4) - | ((in[28 + inpos] - in[28 + inpos - 1]) << 4) - ; - out[28 + outpos] = (in[28 + inpos] - in[28 + inpos - 1]) >>> (31 - 3) - | ((in[29 + inpos] - in[29 + inpos - 1]) << 3) - ; - out[29 + outpos] = (in[29 + inpos] - in[29 + inpos - 1]) >>> (31 - 2) - | ((in[30 + inpos] - in[30 + inpos - 1]) << 2) - ; - out[30 + outpos] = (in[30 + inpos] - in[30 + inpos - 1]) >>> (31 - 1) - | ((in[31 + inpos] - in[31 + inpos - 1]) << 1) - ; - } - - - protected static void integratedunpack1(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (((in[0 + inpos] >>> 0) & 1) - ) + initoffset; - out[1 + outpos] = (((in[0 + inpos] >>> 1) & 1) - ) + out[1 + outpos - 1]; - out[2 + outpos] = (((in[0 + inpos] >>> 2) & 1) - ) + out[2 + outpos - 1]; - out[3 + outpos] = (((in[0 + inpos] >>> 3) & 1) - ) + out[3 + outpos - 1]; - out[4 + outpos] = (((in[0 + inpos] >>> 4) & 1) - ) + out[4 + outpos - 1]; - out[5 + outpos] = (((in[0 + inpos] >>> 5) & 1) - ) + out[5 + outpos - 1]; - out[6 + outpos] = (((in[0 + inpos] >>> 6) & 1) - ) + out[6 + outpos - 1]; - out[7 + outpos] = (((in[0 + inpos] >>> 7) & 1) - ) + out[7 + outpos - 1]; - out[8 + outpos] = (((in[0 + inpos] >>> 8) & 1) - ) + out[8 + outpos - 1]; - out[9 + outpos] = (((in[0 + inpos] >>> 9) & 1) - ) + out[9 + outpos - 1]; - out[10 + outpos] = (((in[0 + inpos] >>> 10) & 1) - ) + out[10 + outpos - 1]; - out[11 + outpos] = (((in[0 + inpos] >>> 11) & 1) - ) + out[11 + outpos - 1]; - out[12 + outpos] = (((in[0 + inpos] >>> 12) & 1) - ) + out[12 + outpos - 1]; - out[13 + outpos] = (((in[0 + inpos] >>> 13) & 1) - ) + out[13 + outpos - 1]; - out[14 + outpos] = (((in[0 + inpos] >>> 14) & 1) - ) + out[14 + outpos - 1]; - out[15 + outpos] = (((in[0 + inpos] >>> 15) & 1) - ) + out[15 + outpos - 1]; - out[16 + outpos] = (((in[0 + inpos] >>> 16) & 1) - ) + out[16 + outpos - 1]; - out[17 + outpos] = (((in[0 + inpos] >>> 17) & 1) - ) + out[17 + outpos - 1]; - out[18 + outpos] = (((in[0 + inpos] >>> 18) & 1) - ) + out[18 + outpos - 1]; - out[19 + outpos] = (((in[0 + inpos] >>> 19) & 1) - ) + out[19 + outpos - 1]; - out[20 + outpos] = (((in[0 + inpos] >>> 20) & 1) - ) + out[20 + outpos - 1]; - out[21 + outpos] = (((in[0 + inpos] >>> 21) & 1) - ) + out[21 + outpos - 1]; - out[22 + outpos] = (((in[0 + inpos] >>> 22) & 1) - ) + out[22 + outpos - 1]; - out[23 + outpos] = (((in[0 + inpos] >>> 23) & 1) - ) + out[23 + outpos - 1]; - out[24 + outpos] = (((in[0 + inpos] >>> 24) & 1) - ) + out[24 + outpos - 1]; - out[25 + outpos] = (((in[0 + inpos] >>> 25) & 1) - ) + out[25 + outpos - 1]; - out[26 + outpos] = (((in[0 + inpos] >>> 26) & 1) - ) + out[26 + outpos - 1]; - out[27 + outpos] = (((in[0 + inpos] >>> 27) & 1) - ) + out[27 + outpos - 1]; - out[28 + outpos] = (((in[0 + inpos] >>> 28) & 1) - ) + out[28 + outpos - 1]; - out[29 + outpos] = (((in[0 + inpos] >>> 29) & 1) - ) + out[29 + outpos - 1]; - out[30 + outpos] = (((in[0 + inpos] >>> 30) & 1) - ) + out[30 + outpos - 1]; - out[31 + outpos] = ((in[0 + inpos] >>> 31) - ) + out[31 + outpos - 1]; - } - - - protected static void integratedunpack2(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (((in[0 + inpos] >>> 0) & 3) - ) + initoffset; - out[1 + outpos] = (((in[0 + inpos] >>> 2) & 3) - ) + out[1 + outpos - 1]; - out[2 + outpos] = (((in[0 + inpos] >>> 4) & 3) - ) + out[2 + outpos - 1]; - out[3 + outpos] = (((in[0 + inpos] >>> 6) & 3) - ) + out[3 + outpos - 1]; - out[4 + outpos] = (((in[0 + inpos] >>> 8) & 3) - ) + out[4 + outpos - 1]; - out[5 + outpos] = (((in[0 + inpos] >>> 10) & 3) - ) + out[5 + outpos - 1]; - out[6 + outpos] = (((in[0 + inpos] >>> 12) & 3) - ) + out[6 + outpos - 1]; - out[7 + outpos] = (((in[0 + inpos] >>> 14) & 3) - ) + out[7 + outpos - 1]; - out[8 + outpos] = (((in[0 + inpos] >>> 16) & 3) - ) + out[8 + outpos - 1]; - out[9 + outpos] = (((in[0 + inpos] >>> 18) & 3) - ) + out[9 + outpos - 1]; - out[10 + outpos] = (((in[0 + inpos] >>> 20) & 3) - ) + out[10 + outpos - 1]; - out[11 + outpos] = (((in[0 + inpos] >>> 22) & 3) - ) + out[11 + outpos - 1]; - out[12 + outpos] = (((in[0 + inpos] >>> 24) & 3) - ) + out[12 + outpos - 1]; - out[13 + outpos] = (((in[0 + inpos] >>> 26) & 3) - ) + out[13 + outpos - 1]; - out[14 + outpos] = (((in[0 + inpos] >>> 28) & 3) - ) + out[14 + outpos - 1]; - out[15 + outpos] = ((in[0 + inpos] >>> 30) - ) + out[15 + outpos - 1]; - out[16 + outpos] = (((in[1 + inpos] >>> 0) & 3) - ) + out[16 + outpos - 1]; - out[17 + outpos] = (((in[1 + inpos] >>> 2) & 3) - ) + out[17 + outpos - 1]; - out[18 + outpos] = (((in[1 + inpos] >>> 4) & 3) - ) + out[18 + outpos - 1]; - out[19 + outpos] = (((in[1 + inpos] >>> 6) & 3) - ) + out[19 + outpos - 1]; - out[20 + outpos] = (((in[1 + inpos] >>> 8) & 3) - ) + out[20 + outpos - 1]; - out[21 + outpos] = (((in[1 + inpos] >>> 10) & 3) - ) + out[21 + outpos - 1]; - out[22 + outpos] = (((in[1 + inpos] >>> 12) & 3) - ) + out[22 + outpos - 1]; - out[23 + outpos] = (((in[1 + inpos] >>> 14) & 3) - ) + out[23 + outpos - 1]; - out[24 + outpos] = (((in[1 + inpos] >>> 16) & 3) - ) + out[24 + outpos - 1]; - out[25 + outpos] = (((in[1 + inpos] >>> 18) & 3) - ) + out[25 + outpos - 1]; - out[26 + outpos] = (((in[1 + inpos] >>> 20) & 3) - ) + out[26 + outpos - 1]; - out[27 + outpos] = (((in[1 + inpos] >>> 22) & 3) - ) + out[27 + outpos - 1]; - out[28 + outpos] = (((in[1 + inpos] >>> 24) & 3) - ) + out[28 + outpos - 1]; - out[29 + outpos] = (((in[1 + inpos] >>> 26) & 3) - ) + out[29 + outpos - 1]; - out[30 + outpos] = (((in[1 + inpos] >>> 28) & 3) - ) + out[30 + outpos - 1]; - out[31 + outpos] = ((in[1 + inpos] >>> 30) - ) + out[31 + outpos - 1]; - } - - - protected static void integratedunpack3(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (((in[0 + inpos] >>> 0) & 7) - ) + initoffset; - out[1 + outpos] = (((in[0 + inpos] >>> 3) & 7) - ) + out[1 + outpos - 1]; - out[2 + outpos] = (((in[0 + inpos] >>> 6) & 7) - ) + out[2 + outpos - 1]; - out[3 + outpos] = (((in[0 + inpos] >>> 9) & 7) - ) + out[3 + outpos - 1]; - out[4 + outpos] = (((in[0 + inpos] >>> 12) & 7) - ) + out[4 + outpos - 1]; - out[5 + outpos] = (((in[0 + inpos] >>> 15) & 7) - ) + out[5 + outpos - 1]; - out[6 + outpos] = (((in[0 + inpos] >>> 18) & 7) - ) + out[6 + outpos - 1]; - out[7 + outpos] = (((in[0 + inpos] >>> 21) & 7) - ) + out[7 + outpos - 1]; - out[8 + outpos] = (((in[0 + inpos] >>> 24) & 7) - ) + out[8 + outpos - 1]; - out[9 + outpos] = (((in[0 + inpos] >>> 27) & 7) - ) + out[9 + outpos - 1]; - out[10 + outpos] = ((in[0 + inpos] >>> 30) - | ((in[1 + inpos] & 1) << (3 - 1)) - ) + out[10 + outpos - 1]; - out[11 + outpos] = (((in[1 + inpos] >>> 1) & 7) - ) + out[11 + outpos - 1]; - out[12 + outpos] = (((in[1 + inpos] >>> 4) & 7) - ) + out[12 + outpos - 1]; - out[13 + outpos] = (((in[1 + inpos] >>> 7) & 7) - ) + out[13 + outpos - 1]; - out[14 + outpos] = (((in[1 + inpos] >>> 10) & 7) - ) + out[14 + outpos - 1]; - out[15 + outpos] = (((in[1 + inpos] >>> 13) & 7) - ) + out[15 + outpos - 1]; - out[16 + outpos] = (((in[1 + inpos] >>> 16) & 7) - ) + out[16 + outpos - 1]; - out[17 + outpos] = (((in[1 + inpos] >>> 19) & 7) - ) + out[17 + outpos - 1]; - out[18 + outpos] = (((in[1 + inpos] >>> 22) & 7) - ) + out[18 + outpos - 1]; - out[19 + outpos] = (((in[1 + inpos] >>> 25) & 7) - ) + out[19 + outpos - 1]; - out[20 + outpos] = (((in[1 + inpos] >>> 28) & 7) - ) + out[20 + outpos - 1]; - out[21 + outpos] = ((in[1 + inpos] >>> 31) - | ((in[2 + inpos] & 3) << (3 - 2)) - ) + out[21 + outpos - 1]; - out[22 + outpos] = (((in[2 + inpos] >>> 2) & 7) - ) + out[22 + outpos - 1]; - out[23 + outpos] = (((in[2 + inpos] >>> 5) & 7) - ) + out[23 + outpos - 1]; - out[24 + outpos] = (((in[2 + inpos] >>> 8) & 7) - ) + out[24 + outpos - 1]; - out[25 + outpos] = (((in[2 + inpos] >>> 11) & 7) - ) + out[25 + outpos - 1]; - out[26 + outpos] = (((in[2 + inpos] >>> 14) & 7) - ) + out[26 + outpos - 1]; - out[27 + outpos] = (((in[2 + inpos] >>> 17) & 7) - ) + out[27 + outpos - 1]; - out[28 + outpos] = (((in[2 + inpos] >>> 20) & 7) - ) + out[28 + outpos - 1]; - out[29 + outpos] = (((in[2 + inpos] >>> 23) & 7) - ) + out[29 + outpos - 1]; - out[30 + outpos] = (((in[2 + inpos] >>> 26) & 7) - ) + out[30 + outpos - 1]; - out[31 + outpos] = ((in[2 + inpos] >>> 29) - ) + out[31 + outpos - 1]; - } - - - protected static void integratedunpack4(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (((in[0 + inpos] >>> 0) & 15) - ) + initoffset; - out[1 + outpos] = (((in[0 + inpos] >>> 4) & 15) - ) + out[1 + outpos - 1]; - out[2 + outpos] = (((in[0 + inpos] >>> 8) & 15) - ) + out[2 + outpos - 1]; - out[3 + outpos] = (((in[0 + inpos] >>> 12) & 15) - ) + out[3 + outpos - 1]; - out[4 + outpos] = (((in[0 + inpos] >>> 16) & 15) - ) + out[4 + outpos - 1]; - out[5 + outpos] = (((in[0 + inpos] >>> 20) & 15) - ) + out[5 + outpos - 1]; - out[6 + outpos] = (((in[0 + inpos] >>> 24) & 15) - ) + out[6 + outpos - 1]; - out[7 + outpos] = ((in[0 + inpos] >>> 28) - ) + out[7 + outpos - 1]; - out[8 + outpos] = (((in[1 + inpos] >>> 0) & 15) - ) + out[8 + outpos - 1]; - out[9 + outpos] = (((in[1 + inpos] >>> 4) & 15) - ) + out[9 + outpos - 1]; - out[10 + outpos] = (((in[1 + inpos] >>> 8) & 15) - ) + out[10 + outpos - 1]; - out[11 + outpos] = (((in[1 + inpos] >>> 12) & 15) - ) + out[11 + outpos - 1]; - out[12 + outpos] = (((in[1 + inpos] >>> 16) & 15) - ) + out[12 + outpos - 1]; - out[13 + outpos] = (((in[1 + inpos] >>> 20) & 15) - ) + out[13 + outpos - 1]; - out[14 + outpos] = (((in[1 + inpos] >>> 24) & 15) - ) + out[14 + outpos - 1]; - out[15 + outpos] = ((in[1 + inpos] >>> 28) - ) + out[15 + outpos - 1]; - out[16 + outpos] = (((in[2 + inpos] >>> 0) & 15) - ) + out[16 + outpos - 1]; - out[17 + outpos] = (((in[2 + inpos] >>> 4) & 15) - ) + out[17 + outpos - 1]; - out[18 + outpos] = (((in[2 + inpos] >>> 8) & 15) - ) + out[18 + outpos - 1]; - out[19 + outpos] = (((in[2 + inpos] >>> 12) & 15) - ) + out[19 + outpos - 1]; - out[20 + outpos] = (((in[2 + inpos] >>> 16) & 15) - ) + out[20 + outpos - 1]; - out[21 + outpos] = (((in[2 + inpos] >>> 20) & 15) - ) + out[21 + outpos - 1]; - out[22 + outpos] = (((in[2 + inpos] >>> 24) & 15) - ) + out[22 + outpos - 1]; - out[23 + outpos] = ((in[2 + inpos] >>> 28) - ) + out[23 + outpos - 1]; - out[24 + outpos] = (((in[3 + inpos] >>> 0) & 15) - ) + out[24 + outpos - 1]; - out[25 + outpos] = (((in[3 + inpos] >>> 4) & 15) - ) + out[25 + outpos - 1]; - out[26 + outpos] = (((in[3 + inpos] >>> 8) & 15) - ) + out[26 + outpos - 1]; - out[27 + outpos] = (((in[3 + inpos] >>> 12) & 15) - ) + out[27 + outpos - 1]; - out[28 + outpos] = (((in[3 + inpos] >>> 16) & 15) - ) + out[28 + outpos - 1]; - out[29 + outpos] = (((in[3 + inpos] >>> 20) & 15) - ) + out[29 + outpos - 1]; - out[30 + outpos] = (((in[3 + inpos] >>> 24) & 15) - ) + out[30 + outpos - 1]; - out[31 + outpos] = ((in[3 + inpos] >>> 28) - ) + out[31 + outpos - 1]; - } - - - protected static void integratedunpack5(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (((in[0 + inpos] >>> 0) & 31) - ) + initoffset; - out[1 + outpos] = (((in[0 + inpos] >>> 5) & 31) - ) + out[1 + outpos - 1]; - out[2 + outpos] = (((in[0 + inpos] >>> 10) & 31) - ) + out[2 + outpos - 1]; - out[3 + outpos] = (((in[0 + inpos] >>> 15) & 31) - ) + out[3 + outpos - 1]; - out[4 + outpos] = (((in[0 + inpos] >>> 20) & 31) - ) + out[4 + outpos - 1]; - out[5 + outpos] = (((in[0 + inpos] >>> 25) & 31) - ) + out[5 + outpos - 1]; - out[6 + outpos] = ((in[0 + inpos] >>> 30) - | ((in[1 + inpos] & 7) << (5 - 3)) - ) + out[6 + outpos - 1]; - out[7 + outpos] = (((in[1 + inpos] >>> 3) & 31) - ) + out[7 + outpos - 1]; - out[8 + outpos] = (((in[1 + inpos] >>> 8) & 31) - ) + out[8 + outpos - 1]; - out[9 + outpos] = (((in[1 + inpos] >>> 13) & 31) - ) + out[9 + outpos - 1]; - out[10 + outpos] = (((in[1 + inpos] >>> 18) & 31) - ) + out[10 + outpos - 1]; - out[11 + outpos] = (((in[1 + inpos] >>> 23) & 31) - ) + out[11 + outpos - 1]; - out[12 + outpos] = ((in[1 + inpos] >>> 28) - | ((in[2 + inpos] & 1) << (5 - 1)) - ) + out[12 + outpos - 1]; - out[13 + outpos] = (((in[2 + inpos] >>> 1) & 31) - ) + out[13 + outpos - 1]; - out[14 + outpos] = (((in[2 + inpos] >>> 6) & 31) - ) + out[14 + outpos - 1]; - out[15 + outpos] = (((in[2 + inpos] >>> 11) & 31) - ) + out[15 + outpos - 1]; - out[16 + outpos] = (((in[2 + inpos] >>> 16) & 31) - ) + out[16 + outpos - 1]; - out[17 + outpos] = (((in[2 + inpos] >>> 21) & 31) - ) + out[17 + outpos - 1]; - out[18 + outpos] = (((in[2 + inpos] >>> 26) & 31) - ) + out[18 + outpos - 1]; - out[19 + outpos] = ((in[2 + inpos] >>> 31) - | ((in[3 + inpos] & 15) << (5 - 4)) - ) + out[19 + outpos - 1]; - out[20 + outpos] = (((in[3 + inpos] >>> 4) & 31) - ) + out[20 + outpos - 1]; - out[21 + outpos] = (((in[3 + inpos] >>> 9) & 31) - ) + out[21 + outpos - 1]; - out[22 + outpos] = (((in[3 + inpos] >>> 14) & 31) - ) + out[22 + outpos - 1]; - out[23 + outpos] = (((in[3 + inpos] >>> 19) & 31) - ) + out[23 + outpos - 1]; - out[24 + outpos] = (((in[3 + inpos] >>> 24) & 31) - ) + out[24 + outpos - 1]; - out[25 + outpos] = ((in[3 + inpos] >>> 29) - | ((in[4 + inpos] & 3) << (5 - 2)) - ) + out[25 + outpos - 1]; - out[26 + outpos] = (((in[4 + inpos] >>> 2) & 31) - ) + out[26 + outpos - 1]; - out[27 + outpos] = (((in[4 + inpos] >>> 7) & 31) - ) + out[27 + outpos - 1]; - out[28 + outpos] = (((in[4 + inpos] >>> 12) & 31) - ) + out[28 + outpos - 1]; - out[29 + outpos] = (((in[4 + inpos] >>> 17) & 31) - ) + out[29 + outpos - 1]; - out[30 + outpos] = (((in[4 + inpos] >>> 22) & 31) - ) + out[30 + outpos - 1]; - out[31 + outpos] = ((in[4 + inpos] >>> 27) - ) + out[31 + outpos - 1]; - } - - - protected static void integratedunpack6(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (((in[0 + inpos] >>> 0) & 63) - ) + initoffset; - out[1 + outpos] = (((in[0 + inpos] >>> 6) & 63) - ) + out[1 + outpos - 1]; - out[2 + outpos] = (((in[0 + inpos] >>> 12) & 63) - ) + out[2 + outpos - 1]; - out[3 + outpos] = (((in[0 + inpos] >>> 18) & 63) - ) + out[3 + outpos - 1]; - out[4 + outpos] = (((in[0 + inpos] >>> 24) & 63) - ) + out[4 + outpos - 1]; - out[5 + outpos] = ((in[0 + inpos] >>> 30) - | ((in[1 + inpos] & 15) << (6 - 4)) - ) + out[5 + outpos - 1]; - out[6 + outpos] = (((in[1 + inpos] >>> 4) & 63) - ) + out[6 + outpos - 1]; - out[7 + outpos] = (((in[1 + inpos] >>> 10) & 63) - ) + out[7 + outpos - 1]; - out[8 + outpos] = (((in[1 + inpos] >>> 16) & 63) - ) + out[8 + outpos - 1]; - out[9 + outpos] = (((in[1 + inpos] >>> 22) & 63) - ) + out[9 + outpos - 1]; - out[10 + outpos] = ((in[1 + inpos] >>> 28) - | ((in[2 + inpos] & 3) << (6 - 2)) - ) + out[10 + outpos - 1]; - out[11 + outpos] = (((in[2 + inpos] >>> 2) & 63) - ) + out[11 + outpos - 1]; - out[12 + outpos] = (((in[2 + inpos] >>> 8) & 63) - ) + out[12 + outpos - 1]; - out[13 + outpos] = (((in[2 + inpos] >>> 14) & 63) - ) + out[13 + outpos - 1]; - out[14 + outpos] = (((in[2 + inpos] >>> 20) & 63) - ) + out[14 + outpos - 1]; - out[15 + outpos] = ((in[2 + inpos] >>> 26) - ) + out[15 + outpos - 1]; - out[16 + outpos] = (((in[3 + inpos] >>> 0) & 63) - ) + out[16 + outpos - 1]; - out[17 + outpos] = (((in[3 + inpos] >>> 6) & 63) - ) + out[17 + outpos - 1]; - out[18 + outpos] = (((in[3 + inpos] >>> 12) & 63) - ) + out[18 + outpos - 1]; - out[19 + outpos] = (((in[3 + inpos] >>> 18) & 63) - ) + out[19 + outpos - 1]; - out[20 + outpos] = (((in[3 + inpos] >>> 24) & 63) - ) + out[20 + outpos - 1]; - out[21 + outpos] = ((in[3 + inpos] >>> 30) - | ((in[4 + inpos] & 15) << (6 - 4)) - ) + out[21 + outpos - 1]; - out[22 + outpos] = (((in[4 + inpos] >>> 4) & 63) - ) + out[22 + outpos - 1]; - out[23 + outpos] = (((in[4 + inpos] >>> 10) & 63) - ) + out[23 + outpos - 1]; - out[24 + outpos] = (((in[4 + inpos] >>> 16) & 63) - ) + out[24 + outpos - 1]; - out[25 + outpos] = (((in[4 + inpos] >>> 22) & 63) - ) + out[25 + outpos - 1]; - out[26 + outpos] = ((in[4 + inpos] >>> 28) - | ((in[5 + inpos] & 3) << (6 - 2)) - ) + out[26 + outpos - 1]; - out[27 + outpos] = (((in[5 + inpos] >>> 2) & 63) - ) + out[27 + outpos - 1]; - out[28 + outpos] = (((in[5 + inpos] >>> 8) & 63) - ) + out[28 + outpos - 1]; - out[29 + outpos] = (((in[5 + inpos] >>> 14) & 63) - ) + out[29 + outpos - 1]; - out[30 + outpos] = (((in[5 + inpos] >>> 20) & 63) - ) + out[30 + outpos - 1]; - out[31 + outpos] = ((in[5 + inpos] >>> 26) - ) + out[31 + outpos - 1]; - } - - - protected static void integratedunpack7(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (((in[0 + inpos] >>> 0) & 127) - ) + initoffset; - out[1 + outpos] = (((in[0 + inpos] >>> 7) & 127) - ) + out[1 + outpos - 1]; - out[2 + outpos] = (((in[0 + inpos] >>> 14) & 127) - ) + out[2 + outpos - 1]; - out[3 + outpos] = (((in[0 + inpos] >>> 21) & 127) - ) + out[3 + outpos - 1]; - out[4 + outpos] = ((in[0 + inpos] >>> 28) - | ((in[1 + inpos] & 7) << (7 - 3)) - ) + out[4 + outpos - 1]; - out[5 + outpos] = (((in[1 + inpos] >>> 3) & 127) - ) + out[5 + outpos - 1]; - out[6 + outpos] = (((in[1 + inpos] >>> 10) & 127) - ) + out[6 + outpos - 1]; - out[7 + outpos] = (((in[1 + inpos] >>> 17) & 127) - ) + out[7 + outpos - 1]; - out[8 + outpos] = (((in[1 + inpos] >>> 24) & 127) - ) + out[8 + outpos - 1]; - out[9 + outpos] = ((in[1 + inpos] >>> 31) - | ((in[2 + inpos] & 63) << (7 - 6)) - ) + out[9 + outpos - 1]; - out[10 + outpos] = (((in[2 + inpos] >>> 6) & 127) - ) + out[10 + outpos - 1]; - out[11 + outpos] = (((in[2 + inpos] >>> 13) & 127) - ) + out[11 + outpos - 1]; - out[12 + outpos] = (((in[2 + inpos] >>> 20) & 127) - ) + out[12 + outpos - 1]; - out[13 + outpos] = ((in[2 + inpos] >>> 27) - | ((in[3 + inpos] & 3) << (7 - 2)) - ) + out[13 + outpos - 1]; - out[14 + outpos] = (((in[3 + inpos] >>> 2) & 127) - ) + out[14 + outpos - 1]; - out[15 + outpos] = (((in[3 + inpos] >>> 9) & 127) - ) + out[15 + outpos - 1]; - out[16 + outpos] = (((in[3 + inpos] >>> 16) & 127) - ) + out[16 + outpos - 1]; - out[17 + outpos] = (((in[3 + inpos] >>> 23) & 127) - ) + out[17 + outpos - 1]; - out[18 + outpos] = ((in[3 + inpos] >>> 30) - | ((in[4 + inpos] & 31) << (7 - 5)) - ) + out[18 + outpos - 1]; - out[19 + outpos] = (((in[4 + inpos] >>> 5) & 127) - ) + out[19 + outpos - 1]; - out[20 + outpos] = (((in[4 + inpos] >>> 12) & 127) - ) + out[20 + outpos - 1]; - out[21 + outpos] = (((in[4 + inpos] >>> 19) & 127) - ) + out[21 + outpos - 1]; - out[22 + outpos] = ((in[4 + inpos] >>> 26) - | ((in[5 + inpos] & 1) << (7 - 1)) - ) + out[22 + outpos - 1]; - out[23 + outpos] = (((in[5 + inpos] >>> 1) & 127) - ) + out[23 + outpos - 1]; - out[24 + outpos] = (((in[5 + inpos] >>> 8) & 127) - ) + out[24 + outpos - 1]; - out[25 + outpos] = (((in[5 + inpos] >>> 15) & 127) - ) + out[25 + outpos - 1]; - out[26 + outpos] = (((in[5 + inpos] >>> 22) & 127) - ) + out[26 + outpos - 1]; - out[27 + outpos] = ((in[5 + inpos] >>> 29) - | ((in[6 + inpos] & 15) << (7 - 4)) - ) + out[27 + outpos - 1]; - out[28 + outpos] = (((in[6 + inpos] >>> 4) & 127) - ) + out[28 + outpos - 1]; - out[29 + outpos] = (((in[6 + inpos] >>> 11) & 127) - ) + out[29 + outpos - 1]; - out[30 + outpos] = (((in[6 + inpos] >>> 18) & 127) - ) + out[30 + outpos - 1]; - out[31 + outpos] = ((in[6 + inpos] >>> 25) - ) + out[31 + outpos - 1]; - } - - - protected static void integratedunpack8(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (((in[0 + inpos] >>> 0) & 255) - ) + initoffset; - out[1 + outpos] = (((in[0 + inpos] >>> 8) & 255) - ) + out[1 + outpos - 1]; - out[2 + outpos] = (((in[0 + inpos] >>> 16) & 255) - ) + out[2 + outpos - 1]; - out[3 + outpos] = ((in[0 + inpos] >>> 24) - ) + out[3 + outpos - 1]; - out[4 + outpos] = (((in[1 + inpos] >>> 0) & 255) - ) + out[4 + outpos - 1]; - out[5 + outpos] = (((in[1 + inpos] >>> 8) & 255) - ) + out[5 + outpos - 1]; - out[6 + outpos] = (((in[1 + inpos] >>> 16) & 255) - ) + out[6 + outpos - 1]; - out[7 + outpos] = ((in[1 + inpos] >>> 24) - ) + out[7 + outpos - 1]; - out[8 + outpos] = (((in[2 + inpos] >>> 0) & 255) - ) + out[8 + outpos - 1]; - out[9 + outpos] = (((in[2 + inpos] >>> 8) & 255) - ) + out[9 + outpos - 1]; - out[10 + outpos] = (((in[2 + inpos] >>> 16) & 255) - ) + out[10 + outpos - 1]; - out[11 + outpos] = ((in[2 + inpos] >>> 24) - ) + out[11 + outpos - 1]; - out[12 + outpos] = (((in[3 + inpos] >>> 0) & 255) - ) + out[12 + outpos - 1]; - out[13 + outpos] = (((in[3 + inpos] >>> 8) & 255) - ) + out[13 + outpos - 1]; - out[14 + outpos] = (((in[3 + inpos] >>> 16) & 255) - ) + out[14 + outpos - 1]; - out[15 + outpos] = ((in[3 + inpos] >>> 24) - ) + out[15 + outpos - 1]; - out[16 + outpos] = (((in[4 + inpos] >>> 0) & 255) - ) + out[16 + outpos - 1]; - out[17 + outpos] = (((in[4 + inpos] >>> 8) & 255) - ) + out[17 + outpos - 1]; - out[18 + outpos] = (((in[4 + inpos] >>> 16) & 255) - ) + out[18 + outpos - 1]; - out[19 + outpos] = ((in[4 + inpos] >>> 24) - ) + out[19 + outpos - 1]; - out[20 + outpos] = (((in[5 + inpos] >>> 0) & 255) - ) + out[20 + outpos - 1]; - out[21 + outpos] = (((in[5 + inpos] >>> 8) & 255) - ) + out[21 + outpos - 1]; - out[22 + outpos] = (((in[5 + inpos] >>> 16) & 255) - ) + out[22 + outpos - 1]; - out[23 + outpos] = ((in[5 + inpos] >>> 24) - ) + out[23 + outpos - 1]; - out[24 + outpos] = (((in[6 + inpos] >>> 0) & 255) - ) + out[24 + outpos - 1]; - out[25 + outpos] = (((in[6 + inpos] >>> 8) & 255) - ) + out[25 + outpos - 1]; - out[26 + outpos] = (((in[6 + inpos] >>> 16) & 255) - ) + out[26 + outpos - 1]; - out[27 + outpos] = ((in[6 + inpos] >>> 24) - ) + out[27 + outpos - 1]; - out[28 + outpos] = (((in[7 + inpos] >>> 0) & 255) - ) + out[28 + outpos - 1]; - out[29 + outpos] = (((in[7 + inpos] >>> 8) & 255) - ) + out[29 + outpos - 1]; - out[30 + outpos] = (((in[7 + inpos] >>> 16) & 255) - ) + out[30 + outpos - 1]; - out[31 + outpos] = ((in[7 + inpos] >>> 24) - ) + out[31 + outpos - 1]; - } - - - protected static void integratedunpack9(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (((in[0 + inpos] >>> 0) & 511) - ) + initoffset; - out[1 + outpos] = (((in[0 + inpos] >>> 9) & 511) - ) + out[1 + outpos - 1]; - out[2 + outpos] = (((in[0 + inpos] >>> 18) & 511) - ) + out[2 + outpos - 1]; - out[3 + outpos] = ((in[0 + inpos] >>> 27) - | ((in[1 + inpos] & 15) << (9 - 4)) - ) + out[3 + outpos - 1]; - out[4 + outpos] = (((in[1 + inpos] >>> 4) & 511) - ) + out[4 + outpos - 1]; - out[5 + outpos] = (((in[1 + inpos] >>> 13) & 511) - ) + out[5 + outpos - 1]; - out[6 + outpos] = (((in[1 + inpos] >>> 22) & 511) - ) + out[6 + outpos - 1]; - out[7 + outpos] = ((in[1 + inpos] >>> 31) - | ((in[2 + inpos] & 255) << (9 - 8)) - ) + out[7 + outpos - 1]; - out[8 + outpos] = (((in[2 + inpos] >>> 8) & 511) - ) + out[8 + outpos - 1]; - out[9 + outpos] = (((in[2 + inpos] >>> 17) & 511) - ) + out[9 + outpos - 1]; - out[10 + outpos] = ((in[2 + inpos] >>> 26) - | ((in[3 + inpos] & 7) << (9 - 3)) - ) + out[10 + outpos - 1]; - out[11 + outpos] = (((in[3 + inpos] >>> 3) & 511) - ) + out[11 + outpos - 1]; - out[12 + outpos] = (((in[3 + inpos] >>> 12) & 511) - ) + out[12 + outpos - 1]; - out[13 + outpos] = (((in[3 + inpos] >>> 21) & 511) - ) + out[13 + outpos - 1]; - out[14 + outpos] = ((in[3 + inpos] >>> 30) - | ((in[4 + inpos] & 127) << (9 - 7)) - ) + out[14 + outpos - 1]; - out[15 + outpos] = (((in[4 + inpos] >>> 7) & 511) - ) + out[15 + outpos - 1]; - out[16 + outpos] = (((in[4 + inpos] >>> 16) & 511) - ) + out[16 + outpos - 1]; - out[17 + outpos] = ((in[4 + inpos] >>> 25) - | ((in[5 + inpos] & 3) << (9 - 2)) - ) + out[17 + outpos - 1]; - out[18 + outpos] = (((in[5 + inpos] >>> 2) & 511) - ) + out[18 + outpos - 1]; - out[19 + outpos] = (((in[5 + inpos] >>> 11) & 511) - ) + out[19 + outpos - 1]; - out[20 + outpos] = (((in[5 + inpos] >>> 20) & 511) - ) + out[20 + outpos - 1]; - out[21 + outpos] = ((in[5 + inpos] >>> 29) - | ((in[6 + inpos] & 63) << (9 - 6)) - ) + out[21 + outpos - 1]; - out[22 + outpos] = (((in[6 + inpos] >>> 6) & 511) - ) + out[22 + outpos - 1]; - out[23 + outpos] = (((in[6 + inpos] >>> 15) & 511) - ) + out[23 + outpos - 1]; - out[24 + outpos] = ((in[6 + inpos] >>> 24) - | ((in[7 + inpos] & 1) << (9 - 1)) - ) + out[24 + outpos - 1]; - out[25 + outpos] = (((in[7 + inpos] >>> 1) & 511) - ) + out[25 + outpos - 1]; - out[26 + outpos] = (((in[7 + inpos] >>> 10) & 511) - ) + out[26 + outpos - 1]; - out[27 + outpos] = (((in[7 + inpos] >>> 19) & 511) - ) + out[27 + outpos - 1]; - out[28 + outpos] = ((in[7 + inpos] >>> 28) - | ((in[8 + inpos] & 31) << (9 - 5)) - ) + out[28 + outpos - 1]; - out[29 + outpos] = (((in[8 + inpos] >>> 5) & 511) - ) + out[29 + outpos - 1]; - out[30 + outpos] = (((in[8 + inpos] >>> 14) & 511) - ) + out[30 + outpos - 1]; - out[31 + outpos] = ((in[8 + inpos] >>> 23) - ) + out[31 + outpos - 1]; - } - - - protected static void integratedunpack10(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (((in[0 + inpos] >>> 0) & 1023) - ) + initoffset; - out[1 + outpos] = (((in[0 + inpos] >>> 10) & 1023) - ) + out[1 + outpos - 1]; - out[2 + outpos] = (((in[0 + inpos] >>> 20) & 1023) - ) + out[2 + outpos - 1]; - out[3 + outpos] = ((in[0 + inpos] >>> 30) - | ((in[1 + inpos] & 255) << (10 - 8)) - ) + out[3 + outpos - 1]; - out[4 + outpos] = (((in[1 + inpos] >>> 8) & 1023) - ) + out[4 + outpos - 1]; - out[5 + outpos] = (((in[1 + inpos] >>> 18) & 1023) - ) + out[5 + outpos - 1]; - out[6 + outpos] = ((in[1 + inpos] >>> 28) - | ((in[2 + inpos] & 63) << (10 - 6)) - ) + out[6 + outpos - 1]; - out[7 + outpos] = (((in[2 + inpos] >>> 6) & 1023) - ) + out[7 + outpos - 1]; - out[8 + outpos] = (((in[2 + inpos] >>> 16) & 1023) - ) + out[8 + outpos - 1]; - out[9 + outpos] = ((in[2 + inpos] >>> 26) - | ((in[3 + inpos] & 15) << (10 - 4)) - ) + out[9 + outpos - 1]; - out[10 + outpos] = (((in[3 + inpos] >>> 4) & 1023) - ) + out[10 + outpos - 1]; - out[11 + outpos] = (((in[3 + inpos] >>> 14) & 1023) - ) + out[11 + outpos - 1]; - out[12 + outpos] = ((in[3 + inpos] >>> 24) - | ((in[4 + inpos] & 3) << (10 - 2)) - ) + out[12 + outpos - 1]; - out[13 + outpos] = (((in[4 + inpos] >>> 2) & 1023) - ) + out[13 + outpos - 1]; - out[14 + outpos] = (((in[4 + inpos] >>> 12) & 1023) - ) + out[14 + outpos - 1]; - out[15 + outpos] = ((in[4 + inpos] >>> 22) - ) + out[15 + outpos - 1]; - out[16 + outpos] = (((in[5 + inpos] >>> 0) & 1023) - ) + out[16 + outpos - 1]; - out[17 + outpos] = (((in[5 + inpos] >>> 10) & 1023) - ) + out[17 + outpos - 1]; - out[18 + outpos] = (((in[5 + inpos] >>> 20) & 1023) - ) + out[18 + outpos - 1]; - out[19 + outpos] = ((in[5 + inpos] >>> 30) - | ((in[6 + inpos] & 255) << (10 - 8)) - ) + out[19 + outpos - 1]; - out[20 + outpos] = (((in[6 + inpos] >>> 8) & 1023) - ) + out[20 + outpos - 1]; - out[21 + outpos] = (((in[6 + inpos] >>> 18) & 1023) - ) + out[21 + outpos - 1]; - out[22 + outpos] = ((in[6 + inpos] >>> 28) - | ((in[7 + inpos] & 63) << (10 - 6)) - ) + out[22 + outpos - 1]; - out[23 + outpos] = (((in[7 + inpos] >>> 6) & 1023) - ) + out[23 + outpos - 1]; - out[24 + outpos] = (((in[7 + inpos] >>> 16) & 1023) - ) + out[24 + outpos - 1]; - out[25 + outpos] = ((in[7 + inpos] >>> 26) - | ((in[8 + inpos] & 15) << (10 - 4)) - ) + out[25 + outpos - 1]; - out[26 + outpos] = (((in[8 + inpos] >>> 4) & 1023) - ) + out[26 + outpos - 1]; - out[27 + outpos] = (((in[8 + inpos] >>> 14) & 1023) - ) + out[27 + outpos - 1]; - out[28 + outpos] = ((in[8 + inpos] >>> 24) - | ((in[9 + inpos] & 3) << (10 - 2)) - ) + out[28 + outpos - 1]; - out[29 + outpos] = (((in[9 + inpos] >>> 2) & 1023) - ) + out[29 + outpos - 1]; - out[30 + outpos] = (((in[9 + inpos] >>> 12) & 1023) - ) + out[30 + outpos - 1]; - out[31 + outpos] = ((in[9 + inpos] >>> 22) - ) + out[31 + outpos - 1]; - } - - - protected static void integratedunpack11(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (((in[0 + inpos] >>> 0) & 2047) - ) + initoffset; - out[1 + outpos] = (((in[0 + inpos] >>> 11) & 2047) - ) + out[1 + outpos - 1]; - out[2 + outpos] = ((in[0 + inpos] >>> 22) - | ((in[1 + inpos] & 1) << (11 - 1)) - ) + out[2 + outpos - 1]; - out[3 + outpos] = (((in[1 + inpos] >>> 1) & 2047) - ) + out[3 + outpos - 1]; - out[4 + outpos] = (((in[1 + inpos] >>> 12) & 2047) - ) + out[4 + outpos - 1]; - out[5 + outpos] = ((in[1 + inpos] >>> 23) - | ((in[2 + inpos] & 3) << (11 - 2)) - ) + out[5 + outpos - 1]; - out[6 + outpos] = (((in[2 + inpos] >>> 2) & 2047) - ) + out[6 + outpos - 1]; - out[7 + outpos] = (((in[2 + inpos] >>> 13) & 2047) - ) + out[7 + outpos - 1]; - out[8 + outpos] = ((in[2 + inpos] >>> 24) - | ((in[3 + inpos] & 7) << (11 - 3)) - ) + out[8 + outpos - 1]; - out[9 + outpos] = (((in[3 + inpos] >>> 3) & 2047) - ) + out[9 + outpos - 1]; - out[10 + outpos] = (((in[3 + inpos] >>> 14) & 2047) - ) + out[10 + outpos - 1]; - out[11 + outpos] = ((in[3 + inpos] >>> 25) - | ((in[4 + inpos] & 15) << (11 - 4)) - ) + out[11 + outpos - 1]; - out[12 + outpos] = (((in[4 + inpos] >>> 4) & 2047) - ) + out[12 + outpos - 1]; - out[13 + outpos] = (((in[4 + inpos] >>> 15) & 2047) - ) + out[13 + outpos - 1]; - out[14 + outpos] = ((in[4 + inpos] >>> 26) - | ((in[5 + inpos] & 31) << (11 - 5)) - ) + out[14 + outpos - 1]; - out[15 + outpos] = (((in[5 + inpos] >>> 5) & 2047) - ) + out[15 + outpos - 1]; - out[16 + outpos] = (((in[5 + inpos] >>> 16) & 2047) - ) + out[16 + outpos - 1]; - out[17 + outpos] = ((in[5 + inpos] >>> 27) - | ((in[6 + inpos] & 63) << (11 - 6)) - ) + out[17 + outpos - 1]; - out[18 + outpos] = (((in[6 + inpos] >>> 6) & 2047) - ) + out[18 + outpos - 1]; - out[19 + outpos] = (((in[6 + inpos] >>> 17) & 2047) - ) + out[19 + outpos - 1]; - out[20 + outpos] = ((in[6 + inpos] >>> 28) - | ((in[7 + inpos] & 127) << (11 - 7)) - ) + out[20 + outpos - 1]; - out[21 + outpos] = (((in[7 + inpos] >>> 7) & 2047) - ) + out[21 + outpos - 1]; - out[22 + outpos] = (((in[7 + inpos] >>> 18) & 2047) - ) + out[22 + outpos - 1]; - out[23 + outpos] = ((in[7 + inpos] >>> 29) - | ((in[8 + inpos] & 255) << (11 - 8)) - ) + out[23 + outpos - 1]; - out[24 + outpos] = (((in[8 + inpos] >>> 8) & 2047) - ) + out[24 + outpos - 1]; - out[25 + outpos] = (((in[8 + inpos] >>> 19) & 2047) - ) + out[25 + outpos - 1]; - out[26 + outpos] = ((in[8 + inpos] >>> 30) - | ((in[9 + inpos] & 511) << (11 - 9)) - ) + out[26 + outpos - 1]; - out[27 + outpos] = (((in[9 + inpos] >>> 9) & 2047) - ) + out[27 + outpos - 1]; - out[28 + outpos] = (((in[9 + inpos] >>> 20) & 2047) - ) + out[28 + outpos - 1]; - out[29 + outpos] = ((in[9 + inpos] >>> 31) - | ((in[10 + inpos] & 1023) << (11 - 10)) - ) + out[29 + outpos - 1]; - out[30 + outpos] = (((in[10 + inpos] >>> 10) & 2047) - ) + out[30 + outpos - 1]; - out[31 + outpos] = ((in[10 + inpos] >>> 21) - ) + out[31 + outpos - 1]; - } - - - protected static void integratedunpack12(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (((in[0 + inpos] >>> 0) & 4095) - ) + initoffset; - out[1 + outpos] = (((in[0 + inpos] >>> 12) & 4095) - ) + out[1 + outpos - 1]; - out[2 + outpos] = ((in[0 + inpos] >>> 24) - | ((in[1 + inpos] & 15) << (12 - 4)) - ) + out[2 + outpos - 1]; - out[3 + outpos] = (((in[1 + inpos] >>> 4) & 4095) - ) + out[3 + outpos - 1]; - out[4 + outpos] = (((in[1 + inpos] >>> 16) & 4095) - ) + out[4 + outpos - 1]; - out[5 + outpos] = ((in[1 + inpos] >>> 28) - | ((in[2 + inpos] & 255) << (12 - 8)) - ) + out[5 + outpos - 1]; - out[6 + outpos] = (((in[2 + inpos] >>> 8) & 4095) - ) + out[6 + outpos - 1]; - out[7 + outpos] = ((in[2 + inpos] >>> 20) - ) + out[7 + outpos - 1]; - out[8 + outpos] = (((in[3 + inpos] >>> 0) & 4095) - ) + out[8 + outpos - 1]; - out[9 + outpos] = (((in[3 + inpos] >>> 12) & 4095) - ) + out[9 + outpos - 1]; - out[10 + outpos] = ((in[3 + inpos] >>> 24) - | ((in[4 + inpos] & 15) << (12 - 4)) - ) + out[10 + outpos - 1]; - out[11 + outpos] = (((in[4 + inpos] >>> 4) & 4095) - ) + out[11 + outpos - 1]; - out[12 + outpos] = (((in[4 + inpos] >>> 16) & 4095) - ) + out[12 + outpos - 1]; - out[13 + outpos] = ((in[4 + inpos] >>> 28) - | ((in[5 + inpos] & 255) << (12 - 8)) - ) + out[13 + outpos - 1]; - out[14 + outpos] = (((in[5 + inpos] >>> 8) & 4095) - ) + out[14 + outpos - 1]; - out[15 + outpos] = ((in[5 + inpos] >>> 20) - ) + out[15 + outpos - 1]; - out[16 + outpos] = (((in[6 + inpos] >>> 0) & 4095) - ) + out[16 + outpos - 1]; - out[17 + outpos] = (((in[6 + inpos] >>> 12) & 4095) - ) + out[17 + outpos - 1]; - out[18 + outpos] = ((in[6 + inpos] >>> 24) - | ((in[7 + inpos] & 15) << (12 - 4)) - ) + out[18 + outpos - 1]; - out[19 + outpos] = (((in[7 + inpos] >>> 4) & 4095) - ) + out[19 + outpos - 1]; - out[20 + outpos] = (((in[7 + inpos] >>> 16) & 4095) - ) + out[20 + outpos - 1]; - out[21 + outpos] = ((in[7 + inpos] >>> 28) - | ((in[8 + inpos] & 255) << (12 - 8)) - ) + out[21 + outpos - 1]; - out[22 + outpos] = (((in[8 + inpos] >>> 8) & 4095) - ) + out[22 + outpos - 1]; - out[23 + outpos] = ((in[8 + inpos] >>> 20) - ) + out[23 + outpos - 1]; - out[24 + outpos] = (((in[9 + inpos] >>> 0) & 4095) - ) + out[24 + outpos - 1]; - out[25 + outpos] = (((in[9 + inpos] >>> 12) & 4095) - ) + out[25 + outpos - 1]; - out[26 + outpos] = ((in[9 + inpos] >>> 24) - | ((in[10 + inpos] & 15) << (12 - 4)) - ) + out[26 + outpos - 1]; - out[27 + outpos] = (((in[10 + inpos] >>> 4) & 4095) - ) + out[27 + outpos - 1]; - out[28 + outpos] = (((in[10 + inpos] >>> 16) & 4095) - ) + out[28 + outpos - 1]; - out[29 + outpos] = ((in[10 + inpos] >>> 28) - | ((in[11 + inpos] & 255) << (12 - 8)) - ) + out[29 + outpos - 1]; - out[30 + outpos] = (((in[11 + inpos] >>> 8) & 4095) - ) + out[30 + outpos - 1]; - out[31 + outpos] = ((in[11 + inpos] >>> 20) - ) + out[31 + outpos - 1]; - } - - - protected static void integratedunpack13(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (((in[0 + inpos] >>> 0) & 8191) - ) + initoffset; - out[1 + outpos] = (((in[0 + inpos] >>> 13) & 8191) - ) + out[1 + outpos - 1]; - out[2 + outpos] = ((in[0 + inpos] >>> 26) - | ((in[1 + inpos] & 127) << (13 - 7)) - ) + out[2 + outpos - 1]; - out[3 + outpos] = (((in[1 + inpos] >>> 7) & 8191) - ) + out[3 + outpos - 1]; - out[4 + outpos] = ((in[1 + inpos] >>> 20) - | ((in[2 + inpos] & 1) << (13 - 1)) - ) + out[4 + outpos - 1]; - out[5 + outpos] = (((in[2 + inpos] >>> 1) & 8191) - ) + out[5 + outpos - 1]; - out[6 + outpos] = (((in[2 + inpos] >>> 14) & 8191) - ) + out[6 + outpos - 1]; - out[7 + outpos] = ((in[2 + inpos] >>> 27) - | ((in[3 + inpos] & 255) << (13 - 8)) - ) + out[7 + outpos - 1]; - out[8 + outpos] = (((in[3 + inpos] >>> 8) & 8191) - ) + out[8 + outpos - 1]; - out[9 + outpos] = ((in[3 + inpos] >>> 21) - | ((in[4 + inpos] & 3) << (13 - 2)) - ) + out[9 + outpos - 1]; - out[10 + outpos] = (((in[4 + inpos] >>> 2) & 8191) - ) + out[10 + outpos - 1]; - out[11 + outpos] = (((in[4 + inpos] >>> 15) & 8191) - ) + out[11 + outpos - 1]; - out[12 + outpos] = ((in[4 + inpos] >>> 28) - | ((in[5 + inpos] & 511) << (13 - 9)) - ) + out[12 + outpos - 1]; - out[13 + outpos] = (((in[5 + inpos] >>> 9) & 8191) - ) + out[13 + outpos - 1]; - out[14 + outpos] = ((in[5 + inpos] >>> 22) - | ((in[6 + inpos] & 7) << (13 - 3)) - ) + out[14 + outpos - 1]; - out[15 + outpos] = (((in[6 + inpos] >>> 3) & 8191) - ) + out[15 + outpos - 1]; - out[16 + outpos] = (((in[6 + inpos] >>> 16) & 8191) - ) + out[16 + outpos - 1]; - out[17 + outpos] = ((in[6 + inpos] >>> 29) - | ((in[7 + inpos] & 1023) << (13 - 10)) - ) + out[17 + outpos - 1]; - out[18 + outpos] = (((in[7 + inpos] >>> 10) & 8191) - ) + out[18 + outpos - 1]; - out[19 + outpos] = ((in[7 + inpos] >>> 23) - | ((in[8 + inpos] & 15) << (13 - 4)) - ) + out[19 + outpos - 1]; - out[20 + outpos] = (((in[8 + inpos] >>> 4) & 8191) - ) + out[20 + outpos - 1]; - out[21 + outpos] = (((in[8 + inpos] >>> 17) & 8191) - ) + out[21 + outpos - 1]; - out[22 + outpos] = ((in[8 + inpos] >>> 30) - | ((in[9 + inpos] & 2047) << (13 - 11)) - ) + out[22 + outpos - 1]; - out[23 + outpos] = (((in[9 + inpos] >>> 11) & 8191) - ) + out[23 + outpos - 1]; - out[24 + outpos] = ((in[9 + inpos] >>> 24) - | ((in[10 + inpos] & 31) << (13 - 5)) - ) + out[24 + outpos - 1]; - out[25 + outpos] = (((in[10 + inpos] >>> 5) & 8191) - ) + out[25 + outpos - 1]; - out[26 + outpos] = (((in[10 + inpos] >>> 18) & 8191) - ) + out[26 + outpos - 1]; - out[27 + outpos] = ((in[10 + inpos] >>> 31) - | ((in[11 + inpos] & 4095) << (13 - 12)) - ) + out[27 + outpos - 1]; - out[28 + outpos] = (((in[11 + inpos] >>> 12) & 8191) - ) + out[28 + outpos - 1]; - out[29 + outpos] = ((in[11 + inpos] >>> 25) - | ((in[12 + inpos] & 63) << (13 - 6)) - ) + out[29 + outpos - 1]; - out[30 + outpos] = (((in[12 + inpos] >>> 6) & 8191) - ) + out[30 + outpos - 1]; - out[31 + outpos] = ((in[12 + inpos] >>> 19) - ) + out[31 + outpos - 1]; - } - - - protected static void integratedunpack14(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (((in[0 + inpos] >>> 0) & 16383) - ) + initoffset; - out[1 + outpos] = (((in[0 + inpos] >>> 14) & 16383) - ) + out[1 + outpos - 1]; - out[2 + outpos] = ((in[0 + inpos] >>> 28) - | ((in[1 + inpos] & 1023) << (14 - 10)) - ) + out[2 + outpos - 1]; - out[3 + outpos] = (((in[1 + inpos] >>> 10) & 16383) - ) + out[3 + outpos - 1]; - out[4 + outpos] = ((in[1 + inpos] >>> 24) - | ((in[2 + inpos] & 63) << (14 - 6)) - ) + out[4 + outpos - 1]; - out[5 + outpos] = (((in[2 + inpos] >>> 6) & 16383) - ) + out[5 + outpos - 1]; - out[6 + outpos] = ((in[2 + inpos] >>> 20) - | ((in[3 + inpos] & 3) << (14 - 2)) - ) + out[6 + outpos - 1]; - out[7 + outpos] = (((in[3 + inpos] >>> 2) & 16383) - ) + out[7 + outpos - 1]; - out[8 + outpos] = (((in[3 + inpos] >>> 16) & 16383) - ) + out[8 + outpos - 1]; - out[9 + outpos] = ((in[3 + inpos] >>> 30) - | ((in[4 + inpos] & 4095) << (14 - 12)) - ) + out[9 + outpos - 1]; - out[10 + outpos] = (((in[4 + inpos] >>> 12) & 16383) - ) + out[10 + outpos - 1]; - out[11 + outpos] = ((in[4 + inpos] >>> 26) - | ((in[5 + inpos] & 255) << (14 - 8)) - ) + out[11 + outpos - 1]; - out[12 + outpos] = (((in[5 + inpos] >>> 8) & 16383) - ) + out[12 + outpos - 1]; - out[13 + outpos] = ((in[5 + inpos] >>> 22) - | ((in[6 + inpos] & 15) << (14 - 4)) - ) + out[13 + outpos - 1]; - out[14 + outpos] = (((in[6 + inpos] >>> 4) & 16383) - ) + out[14 + outpos - 1]; - out[15 + outpos] = ((in[6 + inpos] >>> 18) - ) + out[15 + outpos - 1]; - out[16 + outpos] = (((in[7 + inpos] >>> 0) & 16383) - ) + out[16 + outpos - 1]; - out[17 + outpos] = (((in[7 + inpos] >>> 14) & 16383) - ) + out[17 + outpos - 1]; - out[18 + outpos] = ((in[7 + inpos] >>> 28) - | ((in[8 + inpos] & 1023) << (14 - 10)) - ) + out[18 + outpos - 1]; - out[19 + outpos] = (((in[8 + inpos] >>> 10) & 16383) - ) + out[19 + outpos - 1]; - out[20 + outpos] = ((in[8 + inpos] >>> 24) - | ((in[9 + inpos] & 63) << (14 - 6)) - ) + out[20 + outpos - 1]; - out[21 + outpos] = (((in[9 + inpos] >>> 6) & 16383) - ) + out[21 + outpos - 1]; - out[22 + outpos] = ((in[9 + inpos] >>> 20) - | ((in[10 + inpos] & 3) << (14 - 2)) - ) + out[22 + outpos - 1]; - out[23 + outpos] = (((in[10 + inpos] >>> 2) & 16383) - ) + out[23 + outpos - 1]; - out[24 + outpos] = (((in[10 + inpos] >>> 16) & 16383) - ) + out[24 + outpos - 1]; - out[25 + outpos] = ((in[10 + inpos] >>> 30) - | ((in[11 + inpos] & 4095) << (14 - 12)) - ) + out[25 + outpos - 1]; - out[26 + outpos] = (((in[11 + inpos] >>> 12) & 16383) - ) + out[26 + outpos - 1]; - out[27 + outpos] = ((in[11 + inpos] >>> 26) - | ((in[12 + inpos] & 255) << (14 - 8)) - ) + out[27 + outpos - 1]; - out[28 + outpos] = (((in[12 + inpos] >>> 8) & 16383) - ) + out[28 + outpos - 1]; - out[29 + outpos] = ((in[12 + inpos] >>> 22) - | ((in[13 + inpos] & 15) << (14 - 4)) - ) + out[29 + outpos - 1]; - out[30 + outpos] = (((in[13 + inpos] >>> 4) & 16383) - ) + out[30 + outpos - 1]; - out[31 + outpos] = ((in[13 + inpos] >>> 18) - ) + out[31 + outpos - 1]; - } - - - protected static void integratedunpack15(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (((in[0 + inpos] >>> 0) & 32767) - ) + initoffset; - out[1 + outpos] = (((in[0 + inpos] >>> 15) & 32767) - ) + out[1 + outpos - 1]; - out[2 + outpos] = ((in[0 + inpos] >>> 30) - | ((in[1 + inpos] & 8191) << (15 - 13)) - ) + out[2 + outpos - 1]; - out[3 + outpos] = (((in[1 + inpos] >>> 13) & 32767) - ) + out[3 + outpos - 1]; - out[4 + outpos] = ((in[1 + inpos] >>> 28) - | ((in[2 + inpos] & 2047) << (15 - 11)) - ) + out[4 + outpos - 1]; - out[5 + outpos] = (((in[2 + inpos] >>> 11) & 32767) - ) + out[5 + outpos - 1]; - out[6 + outpos] = ((in[2 + inpos] >>> 26) - | ((in[3 + inpos] & 511) << (15 - 9)) - ) + out[6 + outpos - 1]; - out[7 + outpos] = (((in[3 + inpos] >>> 9) & 32767) - ) + out[7 + outpos - 1]; - out[8 + outpos] = ((in[3 + inpos] >>> 24) - | ((in[4 + inpos] & 127) << (15 - 7)) - ) + out[8 + outpos - 1]; - out[9 + outpos] = (((in[4 + inpos] >>> 7) & 32767) - ) + out[9 + outpos - 1]; - out[10 + outpos] = ((in[4 + inpos] >>> 22) - | ((in[5 + inpos] & 31) << (15 - 5)) - ) + out[10 + outpos - 1]; - out[11 + outpos] = (((in[5 + inpos] >>> 5) & 32767) - ) + out[11 + outpos - 1]; - out[12 + outpos] = ((in[5 + inpos] >>> 20) - | ((in[6 + inpos] & 7) << (15 - 3)) - ) + out[12 + outpos - 1]; - out[13 + outpos] = (((in[6 + inpos] >>> 3) & 32767) - ) + out[13 + outpos - 1]; - out[14 + outpos] = ((in[6 + inpos] >>> 18) - | ((in[7 + inpos] & 1) << (15 - 1)) - ) + out[14 + outpos - 1]; - out[15 + outpos] = (((in[7 + inpos] >>> 1) & 32767) - ) + out[15 + outpos - 1]; - out[16 + outpos] = (((in[7 + inpos] >>> 16) & 32767) - ) + out[16 + outpos - 1]; - out[17 + outpos] = ((in[7 + inpos] >>> 31) - | ((in[8 + inpos] & 16383) << (15 - 14)) - ) + out[17 + outpos - 1]; - out[18 + outpos] = (((in[8 + inpos] >>> 14) & 32767) - ) + out[18 + outpos - 1]; - out[19 + outpos] = ((in[8 + inpos] >>> 29) - | ((in[9 + inpos] & 4095) << (15 - 12)) - ) + out[19 + outpos - 1]; - out[20 + outpos] = (((in[9 + inpos] >>> 12) & 32767) - ) + out[20 + outpos - 1]; - out[21 + outpos] = ((in[9 + inpos] >>> 27) - | ((in[10 + inpos] & 1023) << (15 - 10)) - ) + out[21 + outpos - 1]; - out[22 + outpos] = (((in[10 + inpos] >>> 10) & 32767) - ) + out[22 + outpos - 1]; - out[23 + outpos] = ((in[10 + inpos] >>> 25) - | ((in[11 + inpos] & 255) << (15 - 8)) - ) + out[23 + outpos - 1]; - out[24 + outpos] = (((in[11 + inpos] >>> 8) & 32767) - ) + out[24 + outpos - 1]; - out[25 + outpos] = ((in[11 + inpos] >>> 23) - | ((in[12 + inpos] & 63) << (15 - 6)) - ) + out[25 + outpos - 1]; - out[26 + outpos] = (((in[12 + inpos] >>> 6) & 32767) - ) + out[26 + outpos - 1]; - out[27 + outpos] = ((in[12 + inpos] >>> 21) - | ((in[13 + inpos] & 15) << (15 - 4)) - ) + out[27 + outpos - 1]; - out[28 + outpos] = (((in[13 + inpos] >>> 4) & 32767) - ) + out[28 + outpos - 1]; - out[29 + outpos] = ((in[13 + inpos] >>> 19) - | ((in[14 + inpos] & 3) << (15 - 2)) - ) + out[29 + outpos - 1]; - out[30 + outpos] = (((in[14 + inpos] >>> 2) & 32767) - ) + out[30 + outpos - 1]; - out[31 + outpos] = ((in[14 + inpos] >>> 17) - ) + out[31 + outpos - 1]; - } - - - protected static void integratedunpack16(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (((in[0 + inpos] >>> 0) & 65535) - ) + initoffset; - out[1 + outpos] = ((in[0 + inpos] >>> 16) - ) + out[1 + outpos - 1]; - out[2 + outpos] = (((in[1 + inpos] >>> 0) & 65535) - ) + out[2 + outpos - 1]; - out[3 + outpos] = ((in[1 + inpos] >>> 16) - ) + out[3 + outpos - 1]; - out[4 + outpos] = (((in[2 + inpos] >>> 0) & 65535) - ) + out[4 + outpos - 1]; - out[5 + outpos] = ((in[2 + inpos] >>> 16) - ) + out[5 + outpos - 1]; - out[6 + outpos] = (((in[3 + inpos] >>> 0) & 65535) - ) + out[6 + outpos - 1]; - out[7 + outpos] = ((in[3 + inpos] >>> 16) - ) + out[7 + outpos - 1]; - out[8 + outpos] = (((in[4 + inpos] >>> 0) & 65535) - ) + out[8 + outpos - 1]; - out[9 + outpos] = ((in[4 + inpos] >>> 16) - ) + out[9 + outpos - 1]; - out[10 + outpos] = (((in[5 + inpos] >>> 0) & 65535) - ) + out[10 + outpos - 1]; - out[11 + outpos] = ((in[5 + inpos] >>> 16) - ) + out[11 + outpos - 1]; - out[12 + outpos] = (((in[6 + inpos] >>> 0) & 65535) - ) + out[12 + outpos - 1]; - out[13 + outpos] = ((in[6 + inpos] >>> 16) - ) + out[13 + outpos - 1]; - out[14 + outpos] = (((in[7 + inpos] >>> 0) & 65535) - ) + out[14 + outpos - 1]; - out[15 + outpos] = ((in[7 + inpos] >>> 16) - ) + out[15 + outpos - 1]; - out[16 + outpos] = (((in[8 + inpos] >>> 0) & 65535) - ) + out[16 + outpos - 1]; - out[17 + outpos] = ((in[8 + inpos] >>> 16) - ) + out[17 + outpos - 1]; - out[18 + outpos] = (((in[9 + inpos] >>> 0) & 65535) - ) + out[18 + outpos - 1]; - out[19 + outpos] = ((in[9 + inpos] >>> 16) - ) + out[19 + outpos - 1]; - out[20 + outpos] = (((in[10 + inpos] >>> 0) & 65535) - ) + out[20 + outpos - 1]; - out[21 + outpos] = ((in[10 + inpos] >>> 16) - ) + out[21 + outpos - 1]; - out[22 + outpos] = (((in[11 + inpos] >>> 0) & 65535) - ) + out[22 + outpos - 1]; - out[23 + outpos] = ((in[11 + inpos] >>> 16) - ) + out[23 + outpos - 1]; - out[24 + outpos] = (((in[12 + inpos] >>> 0) & 65535) - ) + out[24 + outpos - 1]; - out[25 + outpos] = ((in[12 + inpos] >>> 16) - ) + out[25 + outpos - 1]; - out[26 + outpos] = (((in[13 + inpos] >>> 0) & 65535) - ) + out[26 + outpos - 1]; - out[27 + outpos] = ((in[13 + inpos] >>> 16) - ) + out[27 + outpos - 1]; - out[28 + outpos] = (((in[14 + inpos] >>> 0) & 65535) - ) + out[28 + outpos - 1]; - out[29 + outpos] = ((in[14 + inpos] >>> 16) - ) + out[29 + outpos - 1]; - out[30 + outpos] = (((in[15 + inpos] >>> 0) & 65535) - ) + out[30 + outpos - 1]; - out[31 + outpos] = ((in[15 + inpos] >>> 16) - ) + out[31 + outpos - 1]; - } - - - protected static void integratedunpack17(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (((in[0 + inpos] >>> 0) & 131071) - ) + initoffset; - out[1 + outpos] = ((in[0 + inpos] >>> 17) - | ((in[1 + inpos] & 3) << (17 - 2)) - ) + out[1 + outpos - 1]; - out[2 + outpos] = (((in[1 + inpos] >>> 2) & 131071) - ) + out[2 + outpos - 1]; - out[3 + outpos] = ((in[1 + inpos] >>> 19) - | ((in[2 + inpos] & 15) << (17 - 4)) - ) + out[3 + outpos - 1]; - out[4 + outpos] = (((in[2 + inpos] >>> 4) & 131071) - ) + out[4 + outpos - 1]; - out[5 + outpos] = ((in[2 + inpos] >>> 21) - | ((in[3 + inpos] & 63) << (17 - 6)) - ) + out[5 + outpos - 1]; - out[6 + outpos] = (((in[3 + inpos] >>> 6) & 131071) - ) + out[6 + outpos - 1]; - out[7 + outpos] = ((in[3 + inpos] >>> 23) - | ((in[4 + inpos] & 255) << (17 - 8)) - ) + out[7 + outpos - 1]; - out[8 + outpos] = (((in[4 + inpos] >>> 8) & 131071) - ) + out[8 + outpos - 1]; - out[9 + outpos] = ((in[4 + inpos] >>> 25) - | ((in[5 + inpos] & 1023) << (17 - 10)) - ) + out[9 + outpos - 1]; - out[10 + outpos] = (((in[5 + inpos] >>> 10) & 131071) - ) + out[10 + outpos - 1]; - out[11 + outpos] = ((in[5 + inpos] >>> 27) - | ((in[6 + inpos] & 4095) << (17 - 12)) - ) + out[11 + outpos - 1]; - out[12 + outpos] = (((in[6 + inpos] >>> 12) & 131071) - ) + out[12 + outpos - 1]; - out[13 + outpos] = ((in[6 + inpos] >>> 29) - | ((in[7 + inpos] & 16383) << (17 - 14)) - ) + out[13 + outpos - 1]; - out[14 + outpos] = (((in[7 + inpos] >>> 14) & 131071) - ) + out[14 + outpos - 1]; - out[15 + outpos] = ((in[7 + inpos] >>> 31) - | ((in[8 + inpos] & 65535) << (17 - 16)) - ) + out[15 + outpos - 1]; - out[16 + outpos] = ((in[8 + inpos] >>> 16) - | ((in[9 + inpos] & 1) << (17 - 1)) - ) + out[16 + outpos - 1]; - out[17 + outpos] = (((in[9 + inpos] >>> 1) & 131071) - ) + out[17 + outpos - 1]; - out[18 + outpos] = ((in[9 + inpos] >>> 18) - | ((in[10 + inpos] & 7) << (17 - 3)) - ) + out[18 + outpos - 1]; - out[19 + outpos] = (((in[10 + inpos] >>> 3) & 131071) - ) + out[19 + outpos - 1]; - out[20 + outpos] = ((in[10 + inpos] >>> 20) - | ((in[11 + inpos] & 31) << (17 - 5)) - ) + out[20 + outpos - 1]; - out[21 + outpos] = (((in[11 + inpos] >>> 5) & 131071) - ) + out[21 + outpos - 1]; - out[22 + outpos] = ((in[11 + inpos] >>> 22) - | ((in[12 + inpos] & 127) << (17 - 7)) - ) + out[22 + outpos - 1]; - out[23 + outpos] = (((in[12 + inpos] >>> 7) & 131071) - ) + out[23 + outpos - 1]; - out[24 + outpos] = ((in[12 + inpos] >>> 24) - | ((in[13 + inpos] & 511) << (17 - 9)) - ) + out[24 + outpos - 1]; - out[25 + outpos] = (((in[13 + inpos] >>> 9) & 131071) - ) + out[25 + outpos - 1]; - out[26 + outpos] = ((in[13 + inpos] >>> 26) - | ((in[14 + inpos] & 2047) << (17 - 11)) - ) + out[26 + outpos - 1]; - out[27 + outpos] = (((in[14 + inpos] >>> 11) & 131071) - ) + out[27 + outpos - 1]; - out[28 + outpos] = ((in[14 + inpos] >>> 28) - | ((in[15 + inpos] & 8191) << (17 - 13)) - ) + out[28 + outpos - 1]; - out[29 + outpos] = (((in[15 + inpos] >>> 13) & 131071) - ) + out[29 + outpos - 1]; - out[30 + outpos] = ((in[15 + inpos] >>> 30) - | ((in[16 + inpos] & 32767) << (17 - 15)) - ) + out[30 + outpos - 1]; - out[31 + outpos] = ((in[16 + inpos] >>> 15) - ) + out[31 + outpos - 1]; - } - - - protected static void integratedunpack18(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (((in[0 + inpos] >>> 0) & 262143) - ) + initoffset; - out[1 + outpos] = ((in[0 + inpos] >>> 18) - | ((in[1 + inpos] & 15) << (18 - 4)) - ) + out[1 + outpos - 1]; - out[2 + outpos] = (((in[1 + inpos] >>> 4) & 262143) - ) + out[2 + outpos - 1]; - out[3 + outpos] = ((in[1 + inpos] >>> 22) - | ((in[2 + inpos] & 255) << (18 - 8)) - ) + out[3 + outpos - 1]; - out[4 + outpos] = (((in[2 + inpos] >>> 8) & 262143) - ) + out[4 + outpos - 1]; - out[5 + outpos] = ((in[2 + inpos] >>> 26) - | ((in[3 + inpos] & 4095) << (18 - 12)) - ) + out[5 + outpos - 1]; - out[6 + outpos] = (((in[3 + inpos] >>> 12) & 262143) - ) + out[6 + outpos - 1]; - out[7 + outpos] = ((in[3 + inpos] >>> 30) - | ((in[4 + inpos] & 65535) << (18 - 16)) - ) + out[7 + outpos - 1]; - out[8 + outpos] = ((in[4 + inpos] >>> 16) - | ((in[5 + inpos] & 3) << (18 - 2)) - ) + out[8 + outpos - 1]; - out[9 + outpos] = (((in[5 + inpos] >>> 2) & 262143) - ) + out[9 + outpos - 1]; - out[10 + outpos] = ((in[5 + inpos] >>> 20) - | ((in[6 + inpos] & 63) << (18 - 6)) - ) + out[10 + outpos - 1]; - out[11 + outpos] = (((in[6 + inpos] >>> 6) & 262143) - ) + out[11 + outpos - 1]; - out[12 + outpos] = ((in[6 + inpos] >>> 24) - | ((in[7 + inpos] & 1023) << (18 - 10)) - ) + out[12 + outpos - 1]; - out[13 + outpos] = (((in[7 + inpos] >>> 10) & 262143) - ) + out[13 + outpos - 1]; - out[14 + outpos] = ((in[7 + inpos] >>> 28) - | ((in[8 + inpos] & 16383) << (18 - 14)) - ) + out[14 + outpos - 1]; - out[15 + outpos] = ((in[8 + inpos] >>> 14) - ) + out[15 + outpos - 1]; - out[16 + outpos] = (((in[9 + inpos] >>> 0) & 262143) - ) + out[16 + outpos - 1]; - out[17 + outpos] = ((in[9 + inpos] >>> 18) - | ((in[10 + inpos] & 15) << (18 - 4)) - ) + out[17 + outpos - 1]; - out[18 + outpos] = (((in[10 + inpos] >>> 4) & 262143) - ) + out[18 + outpos - 1]; - out[19 + outpos] = ((in[10 + inpos] >>> 22) - | ((in[11 + inpos] & 255) << (18 - 8)) - ) + out[19 + outpos - 1]; - out[20 + outpos] = (((in[11 + inpos] >>> 8) & 262143) - ) + out[20 + outpos - 1]; - out[21 + outpos] = ((in[11 + inpos] >>> 26) - | ((in[12 + inpos] & 4095) << (18 - 12)) - ) + out[21 + outpos - 1]; - out[22 + outpos] = (((in[12 + inpos] >>> 12) & 262143) - ) + out[22 + outpos - 1]; - out[23 + outpos] = ((in[12 + inpos] >>> 30) - | ((in[13 + inpos] & 65535) << (18 - 16)) - ) + out[23 + outpos - 1]; - out[24 + outpos] = ((in[13 + inpos] >>> 16) - | ((in[14 + inpos] & 3) << (18 - 2)) - ) + out[24 + outpos - 1]; - out[25 + outpos] = (((in[14 + inpos] >>> 2) & 262143) - ) + out[25 + outpos - 1]; - out[26 + outpos] = ((in[14 + inpos] >>> 20) - | ((in[15 + inpos] & 63) << (18 - 6)) - ) + out[26 + outpos - 1]; - out[27 + outpos] = (((in[15 + inpos] >>> 6) & 262143) - ) + out[27 + outpos - 1]; - out[28 + outpos] = ((in[15 + inpos] >>> 24) - | ((in[16 + inpos] & 1023) << (18 - 10)) - ) + out[28 + outpos - 1]; - out[29 + outpos] = (((in[16 + inpos] >>> 10) & 262143) - ) + out[29 + outpos - 1]; - out[30 + outpos] = ((in[16 + inpos] >>> 28) - | ((in[17 + inpos] & 16383) << (18 - 14)) - ) + out[30 + outpos - 1]; - out[31 + outpos] = ((in[17 + inpos] >>> 14) - ) + out[31 + outpos - 1]; - } - - - protected static void integratedunpack19(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (((in[0 + inpos] >>> 0) & 524287) - ) + initoffset; - out[1 + outpos] = ((in[0 + inpos] >>> 19) - | ((in[1 + inpos] & 63) << (19 - 6)) - ) + out[1 + outpos - 1]; - out[2 + outpos] = (((in[1 + inpos] >>> 6) & 524287) - ) + out[2 + outpos - 1]; - out[3 + outpos] = ((in[1 + inpos] >>> 25) - | ((in[2 + inpos] & 4095) << (19 - 12)) - ) + out[3 + outpos - 1]; - out[4 + outpos] = (((in[2 + inpos] >>> 12) & 524287) - ) + out[4 + outpos - 1]; - out[5 + outpos] = ((in[2 + inpos] >>> 31) - | ((in[3 + inpos] & 262143) << (19 - 18)) - ) + out[5 + outpos - 1]; - out[6 + outpos] = ((in[3 + inpos] >>> 18) - | ((in[4 + inpos] & 31) << (19 - 5)) - ) + out[6 + outpos - 1]; - out[7 + outpos] = (((in[4 + inpos] >>> 5) & 524287) - ) + out[7 + outpos - 1]; - out[8 + outpos] = ((in[4 + inpos] >>> 24) - | ((in[5 + inpos] & 2047) << (19 - 11)) - ) + out[8 + outpos - 1]; - out[9 + outpos] = (((in[5 + inpos] >>> 11) & 524287) - ) + out[9 + outpos - 1]; - out[10 + outpos] = ((in[5 + inpos] >>> 30) - | ((in[6 + inpos] & 131071) << (19 - 17)) - ) + out[10 + outpos - 1]; - out[11 + outpos] = ((in[6 + inpos] >>> 17) - | ((in[7 + inpos] & 15) << (19 - 4)) - ) + out[11 + outpos - 1]; - out[12 + outpos] = (((in[7 + inpos] >>> 4) & 524287) - ) + out[12 + outpos - 1]; - out[13 + outpos] = ((in[7 + inpos] >>> 23) - | ((in[8 + inpos] & 1023) << (19 - 10)) - ) + out[13 + outpos - 1]; - out[14 + outpos] = (((in[8 + inpos] >>> 10) & 524287) - ) + out[14 + outpos - 1]; - out[15 + outpos] = ((in[8 + inpos] >>> 29) - | ((in[9 + inpos] & 65535) << (19 - 16)) - ) + out[15 + outpos - 1]; - out[16 + outpos] = ((in[9 + inpos] >>> 16) - | ((in[10 + inpos] & 7) << (19 - 3)) - ) + out[16 + outpos - 1]; - out[17 + outpos] = (((in[10 + inpos] >>> 3) & 524287) - ) + out[17 + outpos - 1]; - out[18 + outpos] = ((in[10 + inpos] >>> 22) - | ((in[11 + inpos] & 511) << (19 - 9)) - ) + out[18 + outpos - 1]; - out[19 + outpos] = (((in[11 + inpos] >>> 9) & 524287) - ) + out[19 + outpos - 1]; - out[20 + outpos] = ((in[11 + inpos] >>> 28) - | ((in[12 + inpos] & 32767) << (19 - 15)) - ) + out[20 + outpos - 1]; - out[21 + outpos] = ((in[12 + inpos] >>> 15) - | ((in[13 + inpos] & 3) << (19 - 2)) - ) + out[21 + outpos - 1]; - out[22 + outpos] = (((in[13 + inpos] >>> 2) & 524287) - ) + out[22 + outpos - 1]; - out[23 + outpos] = ((in[13 + inpos] >>> 21) - | ((in[14 + inpos] & 255) << (19 - 8)) - ) + out[23 + outpos - 1]; - out[24 + outpos] = (((in[14 + inpos] >>> 8) & 524287) - ) + out[24 + outpos - 1]; - out[25 + outpos] = ((in[14 + inpos] >>> 27) - | ((in[15 + inpos] & 16383) << (19 - 14)) - ) + out[25 + outpos - 1]; - out[26 + outpos] = ((in[15 + inpos] >>> 14) - | ((in[16 + inpos] & 1) << (19 - 1)) - ) + out[26 + outpos - 1]; - out[27 + outpos] = (((in[16 + inpos] >>> 1) & 524287) - ) + out[27 + outpos - 1]; - out[28 + outpos] = ((in[16 + inpos] >>> 20) - | ((in[17 + inpos] & 127) << (19 - 7)) - ) + out[28 + outpos - 1]; - out[29 + outpos] = (((in[17 + inpos] >>> 7) & 524287) - ) + out[29 + outpos - 1]; - out[30 + outpos] = ((in[17 + inpos] >>> 26) - | ((in[18 + inpos] & 8191) << (19 - 13)) - ) + out[30 + outpos - 1]; - out[31 + outpos] = ((in[18 + inpos] >>> 13) - ) + out[31 + outpos - 1]; - } - - - protected static void integratedunpack20(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (((in[0 + inpos] >>> 0) & 1048575) - ) + initoffset; - out[1 + outpos] = ((in[0 + inpos] >>> 20) - | ((in[1 + inpos] & 255) << (20 - 8)) - ) + out[1 + outpos - 1]; - out[2 + outpos] = (((in[1 + inpos] >>> 8) & 1048575) - ) + out[2 + outpos - 1]; - out[3 + outpos] = ((in[1 + inpos] >>> 28) - | ((in[2 + inpos] & 65535) << (20 - 16)) - ) + out[3 + outpos - 1]; - out[4 + outpos] = ((in[2 + inpos] >>> 16) - | ((in[3 + inpos] & 15) << (20 - 4)) - ) + out[4 + outpos - 1]; - out[5 + outpos] = (((in[3 + inpos] >>> 4) & 1048575) - ) + out[5 + outpos - 1]; - out[6 + outpos] = ((in[3 + inpos] >>> 24) - | ((in[4 + inpos] & 4095) << (20 - 12)) - ) + out[6 + outpos - 1]; - out[7 + outpos] = ((in[4 + inpos] >>> 12) - ) + out[7 + outpos - 1]; - out[8 + outpos] = (((in[5 + inpos] >>> 0) & 1048575) - ) + out[8 + outpos - 1]; - out[9 + outpos] = ((in[5 + inpos] >>> 20) - | ((in[6 + inpos] & 255) << (20 - 8)) - ) + out[9 + outpos - 1]; - out[10 + outpos] = (((in[6 + inpos] >>> 8) & 1048575) - ) + out[10 + outpos - 1]; - out[11 + outpos] = ((in[6 + inpos] >>> 28) - | ((in[7 + inpos] & 65535) << (20 - 16)) - ) + out[11 + outpos - 1]; - out[12 + outpos] = ((in[7 + inpos] >>> 16) - | ((in[8 + inpos] & 15) << (20 - 4)) - ) + out[12 + outpos - 1]; - out[13 + outpos] = (((in[8 + inpos] >>> 4) & 1048575) - ) + out[13 + outpos - 1]; - out[14 + outpos] = ((in[8 + inpos] >>> 24) - | ((in[9 + inpos] & 4095) << (20 - 12)) - ) + out[14 + outpos - 1]; - out[15 + outpos] = ((in[9 + inpos] >>> 12) - ) + out[15 + outpos - 1]; - out[16 + outpos] = (((in[10 + inpos] >>> 0) & 1048575) - ) + out[16 + outpos - 1]; - out[17 + outpos] = ((in[10 + inpos] >>> 20) - | ((in[11 + inpos] & 255) << (20 - 8)) - ) + out[17 + outpos - 1]; - out[18 + outpos] = (((in[11 + inpos] >>> 8) & 1048575) - ) + out[18 + outpos - 1]; - out[19 + outpos] = ((in[11 + inpos] >>> 28) - | ((in[12 + inpos] & 65535) << (20 - 16)) - ) + out[19 + outpos - 1]; - out[20 + outpos] = ((in[12 + inpos] >>> 16) - | ((in[13 + inpos] & 15) << (20 - 4)) - ) + out[20 + outpos - 1]; - out[21 + outpos] = (((in[13 + inpos] >>> 4) & 1048575) - ) + out[21 + outpos - 1]; - out[22 + outpos] = ((in[13 + inpos] >>> 24) - | ((in[14 + inpos] & 4095) << (20 - 12)) - ) + out[22 + outpos - 1]; - out[23 + outpos] = ((in[14 + inpos] >>> 12) - ) + out[23 + outpos - 1]; - out[24 + outpos] = (((in[15 + inpos] >>> 0) & 1048575) - ) + out[24 + outpos - 1]; - out[25 + outpos] = ((in[15 + inpos] >>> 20) - | ((in[16 + inpos] & 255) << (20 - 8)) - ) + out[25 + outpos - 1]; - out[26 + outpos] = (((in[16 + inpos] >>> 8) & 1048575) - ) + out[26 + outpos - 1]; - out[27 + outpos] = ((in[16 + inpos] >>> 28) - | ((in[17 + inpos] & 65535) << (20 - 16)) - ) + out[27 + outpos - 1]; - out[28 + outpos] = ((in[17 + inpos] >>> 16) - | ((in[18 + inpos] & 15) << (20 - 4)) - ) + out[28 + outpos - 1]; - out[29 + outpos] = (((in[18 + inpos] >>> 4) & 1048575) - ) + out[29 + outpos - 1]; - out[30 + outpos] = ((in[18 + inpos] >>> 24) - | ((in[19 + inpos] & 4095) << (20 - 12)) - ) + out[30 + outpos - 1]; - out[31 + outpos] = ((in[19 + inpos] >>> 12) - ) + out[31 + outpos - 1]; - } - - - protected static void integratedunpack21(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (((in[0 + inpos] >>> 0) & 2097151) - ) + initoffset; - out[1 + outpos] = ((in[0 + inpos] >>> 21) - | ((in[1 + inpos] & 1023) << (21 - 10)) - ) + out[1 + outpos - 1]; - out[2 + outpos] = (((in[1 + inpos] >>> 10) & 2097151) - ) + out[2 + outpos - 1]; - out[3 + outpos] = ((in[1 + inpos] >>> 31) - | ((in[2 + inpos] & 1048575) << (21 - 20)) - ) + out[3 + outpos - 1]; - out[4 + outpos] = ((in[2 + inpos] >>> 20) - | ((in[3 + inpos] & 511) << (21 - 9)) - ) + out[4 + outpos - 1]; - out[5 + outpos] = (((in[3 + inpos] >>> 9) & 2097151) - ) + out[5 + outpos - 1]; - out[6 + outpos] = ((in[3 + inpos] >>> 30) - | ((in[4 + inpos] & 524287) << (21 - 19)) - ) + out[6 + outpos - 1]; - out[7 + outpos] = ((in[4 + inpos] >>> 19) - | ((in[5 + inpos] & 255) << (21 - 8)) - ) + out[7 + outpos - 1]; - out[8 + outpos] = (((in[5 + inpos] >>> 8) & 2097151) - ) + out[8 + outpos - 1]; - out[9 + outpos] = ((in[5 + inpos] >>> 29) - | ((in[6 + inpos] & 262143) << (21 - 18)) - ) + out[9 + outpos - 1]; - out[10 + outpos] = ((in[6 + inpos] >>> 18) - | ((in[7 + inpos] & 127) << (21 - 7)) - ) + out[10 + outpos - 1]; - out[11 + outpos] = (((in[7 + inpos] >>> 7) & 2097151) - ) + out[11 + outpos - 1]; - out[12 + outpos] = ((in[7 + inpos] >>> 28) - | ((in[8 + inpos] & 131071) << (21 - 17)) - ) + out[12 + outpos - 1]; - out[13 + outpos] = ((in[8 + inpos] >>> 17) - | ((in[9 + inpos] & 63) << (21 - 6)) - ) + out[13 + outpos - 1]; - out[14 + outpos] = (((in[9 + inpos] >>> 6) & 2097151) - ) + out[14 + outpos - 1]; - out[15 + outpos] = ((in[9 + inpos] >>> 27) - | ((in[10 + inpos] & 65535) << (21 - 16)) - ) + out[15 + outpos - 1]; - out[16 + outpos] = ((in[10 + inpos] >>> 16) - | ((in[11 + inpos] & 31) << (21 - 5)) - ) + out[16 + outpos - 1]; - out[17 + outpos] = (((in[11 + inpos] >>> 5) & 2097151) - ) + out[17 + outpos - 1]; - out[18 + outpos] = ((in[11 + inpos] >>> 26) - | ((in[12 + inpos] & 32767) << (21 - 15)) - ) + out[18 + outpos - 1]; - out[19 + outpos] = ((in[12 + inpos] >>> 15) - | ((in[13 + inpos] & 15) << (21 - 4)) - ) + out[19 + outpos - 1]; - out[20 + outpos] = (((in[13 + inpos] >>> 4) & 2097151) - ) + out[20 + outpos - 1]; - out[21 + outpos] = ((in[13 + inpos] >>> 25) - | ((in[14 + inpos] & 16383) << (21 - 14)) - ) + out[21 + outpos - 1]; - out[22 + outpos] = ((in[14 + inpos] >>> 14) - | ((in[15 + inpos] & 7) << (21 - 3)) - ) + out[22 + outpos - 1]; - out[23 + outpos] = (((in[15 + inpos] >>> 3) & 2097151) - ) + out[23 + outpos - 1]; - out[24 + outpos] = ((in[15 + inpos] >>> 24) - | ((in[16 + inpos] & 8191) << (21 - 13)) - ) + out[24 + outpos - 1]; - out[25 + outpos] = ((in[16 + inpos] >>> 13) - | ((in[17 + inpos] & 3) << (21 - 2)) - ) + out[25 + outpos - 1]; - out[26 + outpos] = (((in[17 + inpos] >>> 2) & 2097151) - ) + out[26 + outpos - 1]; - out[27 + outpos] = ((in[17 + inpos] >>> 23) - | ((in[18 + inpos] & 4095) << (21 - 12)) - ) + out[27 + outpos - 1]; - out[28 + outpos] = ((in[18 + inpos] >>> 12) - | ((in[19 + inpos] & 1) << (21 - 1)) - ) + out[28 + outpos - 1]; - out[29 + outpos] = (((in[19 + inpos] >>> 1) & 2097151) - ) + out[29 + outpos - 1]; - out[30 + outpos] = ((in[19 + inpos] >>> 22) - | ((in[20 + inpos] & 2047) << (21 - 11)) - ) + out[30 + outpos - 1]; - out[31 + outpos] = ((in[20 + inpos] >>> 11) - ) + out[31 + outpos - 1]; - } - - - protected static void integratedunpack22(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (((in[0 + inpos] >>> 0) & 4194303) - ) + initoffset; - out[1 + outpos] = ((in[0 + inpos] >>> 22) - | ((in[1 + inpos] & 4095) << (22 - 12)) - ) + out[1 + outpos - 1]; - out[2 + outpos] = ((in[1 + inpos] >>> 12) - | ((in[2 + inpos] & 3) << (22 - 2)) - ) + out[2 + outpos - 1]; - out[3 + outpos] = (((in[2 + inpos] >>> 2) & 4194303) - ) + out[3 + outpos - 1]; - out[4 + outpos] = ((in[2 + inpos] >>> 24) - | ((in[3 + inpos] & 16383) << (22 - 14)) - ) + out[4 + outpos - 1]; - out[5 + outpos] = ((in[3 + inpos] >>> 14) - | ((in[4 + inpos] & 15) << (22 - 4)) - ) + out[5 + outpos - 1]; - out[6 + outpos] = (((in[4 + inpos] >>> 4) & 4194303) - ) + out[6 + outpos - 1]; - out[7 + outpos] = ((in[4 + inpos] >>> 26) - | ((in[5 + inpos] & 65535) << (22 - 16)) - ) + out[7 + outpos - 1]; - out[8 + outpos] = ((in[5 + inpos] >>> 16) - | ((in[6 + inpos] & 63) << (22 - 6)) - ) + out[8 + outpos - 1]; - out[9 + outpos] = (((in[6 + inpos] >>> 6) & 4194303) - ) + out[9 + outpos - 1]; - out[10 + outpos] = ((in[6 + inpos] >>> 28) - | ((in[7 + inpos] & 262143) << (22 - 18)) - ) + out[10 + outpos - 1]; - out[11 + outpos] = ((in[7 + inpos] >>> 18) - | ((in[8 + inpos] & 255) << (22 - 8)) - ) + out[11 + outpos - 1]; - out[12 + outpos] = (((in[8 + inpos] >>> 8) & 4194303) - ) + out[12 + outpos - 1]; - out[13 + outpos] = ((in[8 + inpos] >>> 30) - | ((in[9 + inpos] & 1048575) << (22 - 20)) - ) + out[13 + outpos - 1]; - out[14 + outpos] = ((in[9 + inpos] >>> 20) - | ((in[10 + inpos] & 1023) << (22 - 10)) - ) + out[14 + outpos - 1]; - out[15 + outpos] = ((in[10 + inpos] >>> 10) - ) + out[15 + outpos - 1]; - out[16 + outpos] = (((in[11 + inpos] >>> 0) & 4194303) - ) + out[16 + outpos - 1]; - out[17 + outpos] = ((in[11 + inpos] >>> 22) - | ((in[12 + inpos] & 4095) << (22 - 12)) - ) + out[17 + outpos - 1]; - out[18 + outpos] = ((in[12 + inpos] >>> 12) - | ((in[13 + inpos] & 3) << (22 - 2)) - ) + out[18 + outpos - 1]; - out[19 + outpos] = (((in[13 + inpos] >>> 2) & 4194303) - ) + out[19 + outpos - 1]; - out[20 + outpos] = ((in[13 + inpos] >>> 24) - | ((in[14 + inpos] & 16383) << (22 - 14)) - ) + out[20 + outpos - 1]; - out[21 + outpos] = ((in[14 + inpos] >>> 14) - | ((in[15 + inpos] & 15) << (22 - 4)) - ) + out[21 + outpos - 1]; - out[22 + outpos] = (((in[15 + inpos] >>> 4) & 4194303) - ) + out[22 + outpos - 1]; - out[23 + outpos] = ((in[15 + inpos] >>> 26) - | ((in[16 + inpos] & 65535) << (22 - 16)) - ) + out[23 + outpos - 1]; - out[24 + outpos] = ((in[16 + inpos] >>> 16) - | ((in[17 + inpos] & 63) << (22 - 6)) - ) + out[24 + outpos - 1]; - out[25 + outpos] = (((in[17 + inpos] >>> 6) & 4194303) - ) + out[25 + outpos - 1]; - out[26 + outpos] = ((in[17 + inpos] >>> 28) - | ((in[18 + inpos] & 262143) << (22 - 18)) - ) + out[26 + outpos - 1]; - out[27 + outpos] = ((in[18 + inpos] >>> 18) - | ((in[19 + inpos] & 255) << (22 - 8)) - ) + out[27 + outpos - 1]; - out[28 + outpos] = (((in[19 + inpos] >>> 8) & 4194303) - ) + out[28 + outpos - 1]; - out[29 + outpos] = ((in[19 + inpos] >>> 30) - | ((in[20 + inpos] & 1048575) << (22 - 20)) - ) + out[29 + outpos - 1]; - out[30 + outpos] = ((in[20 + inpos] >>> 20) - | ((in[21 + inpos] & 1023) << (22 - 10)) - ) + out[30 + outpos - 1]; - out[31 + outpos] = ((in[21 + inpos] >>> 10) - ) + out[31 + outpos - 1]; - } - - - protected static void integratedunpack23(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (((in[0 + inpos] >>> 0) & 8388607) - ) + initoffset; - out[1 + outpos] = ((in[0 + inpos] >>> 23) - | ((in[1 + inpos] & 16383) << (23 - 14)) - ) + out[1 + outpos - 1]; - out[2 + outpos] = ((in[1 + inpos] >>> 14) - | ((in[2 + inpos] & 31) << (23 - 5)) - ) + out[2 + outpos - 1]; - out[3 + outpos] = (((in[2 + inpos] >>> 5) & 8388607) - ) + out[3 + outpos - 1]; - out[4 + outpos] = ((in[2 + inpos] >>> 28) - | ((in[3 + inpos] & 524287) << (23 - 19)) - ) + out[4 + outpos - 1]; - out[5 + outpos] = ((in[3 + inpos] >>> 19) - | ((in[4 + inpos] & 1023) << (23 - 10)) - ) + out[5 + outpos - 1]; - out[6 + outpos] = ((in[4 + inpos] >>> 10) - | ((in[5 + inpos] & 1) << (23 - 1)) - ) + out[6 + outpos - 1]; - out[7 + outpos] = (((in[5 + inpos] >>> 1) & 8388607) - ) + out[7 + outpos - 1]; - out[8 + outpos] = ((in[5 + inpos] >>> 24) - | ((in[6 + inpos] & 32767) << (23 - 15)) - ) + out[8 + outpos - 1]; - out[9 + outpos] = ((in[6 + inpos] >>> 15) - | ((in[7 + inpos] & 63) << (23 - 6)) - ) + out[9 + outpos - 1]; - out[10 + outpos] = (((in[7 + inpos] >>> 6) & 8388607) - ) + out[10 + outpos - 1]; - out[11 + outpos] = ((in[7 + inpos] >>> 29) - | ((in[8 + inpos] & 1048575) << (23 - 20)) - ) + out[11 + outpos - 1]; - out[12 + outpos] = ((in[8 + inpos] >>> 20) - | ((in[9 + inpos] & 2047) << (23 - 11)) - ) + out[12 + outpos - 1]; - out[13 + outpos] = ((in[9 + inpos] >>> 11) - | ((in[10 + inpos] & 3) << (23 - 2)) - ) + out[13 + outpos - 1]; - out[14 + outpos] = (((in[10 + inpos] >>> 2) & 8388607) - ) + out[14 + outpos - 1]; - out[15 + outpos] = ((in[10 + inpos] >>> 25) - | ((in[11 + inpos] & 65535) << (23 - 16)) - ) + out[15 + outpos - 1]; - out[16 + outpos] = ((in[11 + inpos] >>> 16) - | ((in[12 + inpos] & 127) << (23 - 7)) - ) + out[16 + outpos - 1]; - out[17 + outpos] = (((in[12 + inpos] >>> 7) & 8388607) - ) + out[17 + outpos - 1]; - out[18 + outpos] = ((in[12 + inpos] >>> 30) - | ((in[13 + inpos] & 2097151) << (23 - 21)) - ) + out[18 + outpos - 1]; - out[19 + outpos] = ((in[13 + inpos] >>> 21) - | ((in[14 + inpos] & 4095) << (23 - 12)) - ) + out[19 + outpos - 1]; - out[20 + outpos] = ((in[14 + inpos] >>> 12) - | ((in[15 + inpos] & 7) << (23 - 3)) - ) + out[20 + outpos - 1]; - out[21 + outpos] = (((in[15 + inpos] >>> 3) & 8388607) - ) + out[21 + outpos - 1]; - out[22 + outpos] = ((in[15 + inpos] >>> 26) - | ((in[16 + inpos] & 131071) << (23 - 17)) - ) + out[22 + outpos - 1]; - out[23 + outpos] = ((in[16 + inpos] >>> 17) - | ((in[17 + inpos] & 255) << (23 - 8)) - ) + out[23 + outpos - 1]; - out[24 + outpos] = (((in[17 + inpos] >>> 8) & 8388607) - ) + out[24 + outpos - 1]; - out[25 + outpos] = ((in[17 + inpos] >>> 31) - | ((in[18 + inpos] & 4194303) << (23 - 22)) - ) + out[25 + outpos - 1]; - out[26 + outpos] = ((in[18 + inpos] >>> 22) - | ((in[19 + inpos] & 8191) << (23 - 13)) - ) + out[26 + outpos - 1]; - out[27 + outpos] = ((in[19 + inpos] >>> 13) - | ((in[20 + inpos] & 15) << (23 - 4)) - ) + out[27 + outpos - 1]; - out[28 + outpos] = (((in[20 + inpos] >>> 4) & 8388607) - ) + out[28 + outpos - 1]; - out[29 + outpos] = ((in[20 + inpos] >>> 27) - | ((in[21 + inpos] & 262143) << (23 - 18)) - ) + out[29 + outpos - 1]; - out[30 + outpos] = ((in[21 + inpos] >>> 18) - | ((in[22 + inpos] & 511) << (23 - 9)) - ) + out[30 + outpos - 1]; - out[31 + outpos] = ((in[22 + inpos] >>> 9) - ) + out[31 + outpos - 1]; - } - - - protected static void integratedunpack24(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (((in[0 + inpos] >>> 0) & 16777215) - ) + initoffset; - out[1 + outpos] = ((in[0 + inpos] >>> 24) - | ((in[1 + inpos] & 65535) << (24 - 16)) - ) + out[1 + outpos - 1]; - out[2 + outpos] = ((in[1 + inpos] >>> 16) - | ((in[2 + inpos] & 255) << (24 - 8)) - ) + out[2 + outpos - 1]; - out[3 + outpos] = ((in[2 + inpos] >>> 8) - ) + out[3 + outpos - 1]; - out[4 + outpos] = (((in[3 + inpos] >>> 0) & 16777215) - ) + out[4 + outpos - 1]; - out[5 + outpos] = ((in[3 + inpos] >>> 24) - | ((in[4 + inpos] & 65535) << (24 - 16)) - ) + out[5 + outpos - 1]; - out[6 + outpos] = ((in[4 + inpos] >>> 16) - | ((in[5 + inpos] & 255) << (24 - 8)) - ) + out[6 + outpos - 1]; - out[7 + outpos] = ((in[5 + inpos] >>> 8) - ) + out[7 + outpos - 1]; - out[8 + outpos] = (((in[6 + inpos] >>> 0) & 16777215) - ) + out[8 + outpos - 1]; - out[9 + outpos] = ((in[6 + inpos] >>> 24) - | ((in[7 + inpos] & 65535) << (24 - 16)) - ) + out[9 + outpos - 1]; - out[10 + outpos] = ((in[7 + inpos] >>> 16) - | ((in[8 + inpos] & 255) << (24 - 8)) - ) + out[10 + outpos - 1]; - out[11 + outpos] = ((in[8 + inpos] >>> 8) - ) + out[11 + outpos - 1]; - out[12 + outpos] = (((in[9 + inpos] >>> 0) & 16777215) - ) + out[12 + outpos - 1]; - out[13 + outpos] = ((in[9 + inpos] >>> 24) - | ((in[10 + inpos] & 65535) << (24 - 16)) - ) + out[13 + outpos - 1]; - out[14 + outpos] = ((in[10 + inpos] >>> 16) - | ((in[11 + inpos] & 255) << (24 - 8)) - ) + out[14 + outpos - 1]; - out[15 + outpos] = ((in[11 + inpos] >>> 8) - ) + out[15 + outpos - 1]; - out[16 + outpos] = (((in[12 + inpos] >>> 0) & 16777215) - ) + out[16 + outpos - 1]; - out[17 + outpos] = ((in[12 + inpos] >>> 24) - | ((in[13 + inpos] & 65535) << (24 - 16)) - ) + out[17 + outpos - 1]; - out[18 + outpos] = ((in[13 + inpos] >>> 16) - | ((in[14 + inpos] & 255) << (24 - 8)) - ) + out[18 + outpos - 1]; - out[19 + outpos] = ((in[14 + inpos] >>> 8) - ) + out[19 + outpos - 1]; - out[20 + outpos] = (((in[15 + inpos] >>> 0) & 16777215) - ) + out[20 + outpos - 1]; - out[21 + outpos] = ((in[15 + inpos] >>> 24) - | ((in[16 + inpos] & 65535) << (24 - 16)) - ) + out[21 + outpos - 1]; - out[22 + outpos] = ((in[16 + inpos] >>> 16) - | ((in[17 + inpos] & 255) << (24 - 8)) - ) + out[22 + outpos - 1]; - out[23 + outpos] = ((in[17 + inpos] >>> 8) - ) + out[23 + outpos - 1]; - out[24 + outpos] = (((in[18 + inpos] >>> 0) & 16777215) - ) + out[24 + outpos - 1]; - out[25 + outpos] = ((in[18 + inpos] >>> 24) - | ((in[19 + inpos] & 65535) << (24 - 16)) - ) + out[25 + outpos - 1]; - out[26 + outpos] = ((in[19 + inpos] >>> 16) - | ((in[20 + inpos] & 255) << (24 - 8)) - ) + out[26 + outpos - 1]; - out[27 + outpos] = ((in[20 + inpos] >>> 8) - ) + out[27 + outpos - 1]; - out[28 + outpos] = (((in[21 + inpos] >>> 0) & 16777215) - ) + out[28 + outpos - 1]; - out[29 + outpos] = ((in[21 + inpos] >>> 24) - | ((in[22 + inpos] & 65535) << (24 - 16)) - ) + out[29 + outpos - 1]; - out[30 + outpos] = ((in[22 + inpos] >>> 16) - | ((in[23 + inpos] & 255) << (24 - 8)) - ) + out[30 + outpos - 1]; - out[31 + outpos] = ((in[23 + inpos] >>> 8) - ) + out[31 + outpos - 1]; - } - - - protected static void integratedunpack25(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (((in[0 + inpos] >>> 0) & 33554431) - ) + initoffset; - out[1 + outpos] = ((in[0 + inpos] >>> 25) - | ((in[1 + inpos] & 262143) << (25 - 18)) - ) + out[1 + outpos - 1]; - out[2 + outpos] = ((in[1 + inpos] >>> 18) - | ((in[2 + inpos] & 2047) << (25 - 11)) - ) + out[2 + outpos - 1]; - out[3 + outpos] = ((in[2 + inpos] >>> 11) - | ((in[3 + inpos] & 15) << (25 - 4)) - ) + out[3 + outpos - 1]; - out[4 + outpos] = (((in[3 + inpos] >>> 4) & 33554431) - ) + out[4 + outpos - 1]; - out[5 + outpos] = ((in[3 + inpos] >>> 29) - | ((in[4 + inpos] & 4194303) << (25 - 22)) - ) + out[5 + outpos - 1]; - out[6 + outpos] = ((in[4 + inpos] >>> 22) - | ((in[5 + inpos] & 32767) << (25 - 15)) - ) + out[6 + outpos - 1]; - out[7 + outpos] = ((in[5 + inpos] >>> 15) - | ((in[6 + inpos] & 255) << (25 - 8)) - ) + out[7 + outpos - 1]; - out[8 + outpos] = ((in[6 + inpos] >>> 8) - | ((in[7 + inpos] & 1) << (25 - 1)) - ) + out[8 + outpos - 1]; - out[9 + outpos] = (((in[7 + inpos] >>> 1) & 33554431) - ) + out[9 + outpos - 1]; - out[10 + outpos] = ((in[7 + inpos] >>> 26) - | ((in[8 + inpos] & 524287) << (25 - 19)) - ) + out[10 + outpos - 1]; - out[11 + outpos] = ((in[8 + inpos] >>> 19) - | ((in[9 + inpos] & 4095) << (25 - 12)) - ) + out[11 + outpos - 1]; - out[12 + outpos] = ((in[9 + inpos] >>> 12) - | ((in[10 + inpos] & 31) << (25 - 5)) - ) + out[12 + outpos - 1]; - out[13 + outpos] = (((in[10 + inpos] >>> 5) & 33554431) - ) + out[13 + outpos - 1]; - out[14 + outpos] = ((in[10 + inpos] >>> 30) - | ((in[11 + inpos] & 8388607) << (25 - 23)) - ) + out[14 + outpos - 1]; - out[15 + outpos] = ((in[11 + inpos] >>> 23) - | ((in[12 + inpos] & 65535) << (25 - 16)) - ) + out[15 + outpos - 1]; - out[16 + outpos] = ((in[12 + inpos] >>> 16) - | ((in[13 + inpos] & 511) << (25 - 9)) - ) + out[16 + outpos - 1]; - out[17 + outpos] = ((in[13 + inpos] >>> 9) - | ((in[14 + inpos] & 3) << (25 - 2)) - ) + out[17 + outpos - 1]; - out[18 + outpos] = (((in[14 + inpos] >>> 2) & 33554431) - ) + out[18 + outpos - 1]; - out[19 + outpos] = ((in[14 + inpos] >>> 27) - | ((in[15 + inpos] & 1048575) << (25 - 20)) - ) + out[19 + outpos - 1]; - out[20 + outpos] = ((in[15 + inpos] >>> 20) - | ((in[16 + inpos] & 8191) << (25 - 13)) - ) + out[20 + outpos - 1]; - out[21 + outpos] = ((in[16 + inpos] >>> 13) - | ((in[17 + inpos] & 63) << (25 - 6)) - ) + out[21 + outpos - 1]; - out[22 + outpos] = (((in[17 + inpos] >>> 6) & 33554431) - ) + out[22 + outpos - 1]; - out[23 + outpos] = ((in[17 + inpos] >>> 31) - | ((in[18 + inpos] & 16777215) << (25 - 24)) - ) + out[23 + outpos - 1]; - out[24 + outpos] = ((in[18 + inpos] >>> 24) - | ((in[19 + inpos] & 131071) << (25 - 17)) - ) + out[24 + outpos - 1]; - out[25 + outpos] = ((in[19 + inpos] >>> 17) - | ((in[20 + inpos] & 1023) << (25 - 10)) - ) + out[25 + outpos - 1]; - out[26 + outpos] = ((in[20 + inpos] >>> 10) - | ((in[21 + inpos] & 7) << (25 - 3)) - ) + out[26 + outpos - 1]; - out[27 + outpos] = (((in[21 + inpos] >>> 3) & 33554431) - ) + out[27 + outpos - 1]; - out[28 + outpos] = ((in[21 + inpos] >>> 28) - | ((in[22 + inpos] & 2097151) << (25 - 21)) - ) + out[28 + outpos - 1]; - out[29 + outpos] = ((in[22 + inpos] >>> 21) - | ((in[23 + inpos] & 16383) << (25 - 14)) - ) + out[29 + outpos - 1]; - out[30 + outpos] = ((in[23 + inpos] >>> 14) - | ((in[24 + inpos] & 127) << (25 - 7)) - ) + out[30 + outpos - 1]; - out[31 + outpos] = ((in[24 + inpos] >>> 7) - ) + out[31 + outpos - 1]; - } - - - protected static void integratedunpack26(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (((in[0 + inpos] >>> 0) & 67108863) - ) + initoffset; - out[1 + outpos] = ((in[0 + inpos] >>> 26) - | ((in[1 + inpos] & 1048575) << (26 - 20)) - ) + out[1 + outpos - 1]; - out[2 + outpos] = ((in[1 + inpos] >>> 20) - | ((in[2 + inpos] & 16383) << (26 - 14)) - ) + out[2 + outpos - 1]; - out[3 + outpos] = ((in[2 + inpos] >>> 14) - | ((in[3 + inpos] & 255) << (26 - 8)) - ) + out[3 + outpos - 1]; - out[4 + outpos] = ((in[3 + inpos] >>> 8) - | ((in[4 + inpos] & 3) << (26 - 2)) - ) + out[4 + outpos - 1]; - out[5 + outpos] = (((in[4 + inpos] >>> 2) & 67108863) - ) + out[5 + outpos - 1]; - out[6 + outpos] = ((in[4 + inpos] >>> 28) - | ((in[5 + inpos] & 4194303) << (26 - 22)) - ) + out[6 + outpos - 1]; - out[7 + outpos] = ((in[5 + inpos] >>> 22) - | ((in[6 + inpos] & 65535) << (26 - 16)) - ) + out[7 + outpos - 1]; - out[8 + outpos] = ((in[6 + inpos] >>> 16) - | ((in[7 + inpos] & 1023) << (26 - 10)) - ) + out[8 + outpos - 1]; - out[9 + outpos] = ((in[7 + inpos] >>> 10) - | ((in[8 + inpos] & 15) << (26 - 4)) - ) + out[9 + outpos - 1]; - out[10 + outpos] = (((in[8 + inpos] >>> 4) & 67108863) - ) + out[10 + outpos - 1]; - out[11 + outpos] = ((in[8 + inpos] >>> 30) - | ((in[9 + inpos] & 16777215) << (26 - 24)) - ) + out[11 + outpos - 1]; - out[12 + outpos] = ((in[9 + inpos] >>> 24) - | ((in[10 + inpos] & 262143) << (26 - 18)) - ) + out[12 + outpos - 1]; - out[13 + outpos] = ((in[10 + inpos] >>> 18) - | ((in[11 + inpos] & 4095) << (26 - 12)) - ) + out[13 + outpos - 1]; - out[14 + outpos] = ((in[11 + inpos] >>> 12) - | ((in[12 + inpos] & 63) << (26 - 6)) - ) + out[14 + outpos - 1]; - out[15 + outpos] = ((in[12 + inpos] >>> 6) - ) + out[15 + outpos - 1]; - out[16 + outpos] = (((in[13 + inpos] >>> 0) & 67108863) - ) + out[16 + outpos - 1]; - out[17 + outpos] = ((in[13 + inpos] >>> 26) - | ((in[14 + inpos] & 1048575) << (26 - 20)) - ) + out[17 + outpos - 1]; - out[18 + outpos] = ((in[14 + inpos] >>> 20) - | ((in[15 + inpos] & 16383) << (26 - 14)) - ) + out[18 + outpos - 1]; - out[19 + outpos] = ((in[15 + inpos] >>> 14) - | ((in[16 + inpos] & 255) << (26 - 8)) - ) + out[19 + outpos - 1]; - out[20 + outpos] = ((in[16 + inpos] >>> 8) - | ((in[17 + inpos] & 3) << (26 - 2)) - ) + out[20 + outpos - 1]; - out[21 + outpos] = (((in[17 + inpos] >>> 2) & 67108863) - ) + out[21 + outpos - 1]; - out[22 + outpos] = ((in[17 + inpos] >>> 28) - | ((in[18 + inpos] & 4194303) << (26 - 22)) - ) + out[22 + outpos - 1]; - out[23 + outpos] = ((in[18 + inpos] >>> 22) - | ((in[19 + inpos] & 65535) << (26 - 16)) - ) + out[23 + outpos - 1]; - out[24 + outpos] = ((in[19 + inpos] >>> 16) - | ((in[20 + inpos] & 1023) << (26 - 10)) - ) + out[24 + outpos - 1]; - out[25 + outpos] = ((in[20 + inpos] >>> 10) - | ((in[21 + inpos] & 15) << (26 - 4)) - ) + out[25 + outpos - 1]; - out[26 + outpos] = (((in[21 + inpos] >>> 4) & 67108863) - ) + out[26 + outpos - 1]; - out[27 + outpos] = ((in[21 + inpos] >>> 30) - | ((in[22 + inpos] & 16777215) << (26 - 24)) - ) + out[27 + outpos - 1]; - out[28 + outpos] = ((in[22 + inpos] >>> 24) - | ((in[23 + inpos] & 262143) << (26 - 18)) - ) + out[28 + outpos - 1]; - out[29 + outpos] = ((in[23 + inpos] >>> 18) - | ((in[24 + inpos] & 4095) << (26 - 12)) - ) + out[29 + outpos - 1]; - out[30 + outpos] = ((in[24 + inpos] >>> 12) - | ((in[25 + inpos] & 63) << (26 - 6)) - ) + out[30 + outpos - 1]; - out[31 + outpos] = ((in[25 + inpos] >>> 6) - ) + out[31 + outpos - 1]; - } - - - protected static void integratedunpack27(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (((in[0 + inpos] >>> 0) & 134217727) - ) + initoffset; - out[1 + outpos] = ((in[0 + inpos] >>> 27) - | ((in[1 + inpos] & 4194303) << (27 - 22)) - ) + out[1 + outpos - 1]; - out[2 + outpos] = ((in[1 + inpos] >>> 22) - | ((in[2 + inpos] & 131071) << (27 - 17)) - ) + out[2 + outpos - 1]; - out[3 + outpos] = ((in[2 + inpos] >>> 17) - | ((in[3 + inpos] & 4095) << (27 - 12)) - ) + out[3 + outpos - 1]; - out[4 + outpos] = ((in[3 + inpos] >>> 12) - | ((in[4 + inpos] & 127) << (27 - 7)) - ) + out[4 + outpos - 1]; - out[5 + outpos] = ((in[4 + inpos] >>> 7) - | ((in[5 + inpos] & 3) << (27 - 2)) - ) + out[5 + outpos - 1]; - out[6 + outpos] = (((in[5 + inpos] >>> 2) & 134217727) - ) + out[6 + outpos - 1]; - out[7 + outpos] = ((in[5 + inpos] >>> 29) - | ((in[6 + inpos] & 16777215) << (27 - 24)) - ) + out[7 + outpos - 1]; - out[8 + outpos] = ((in[6 + inpos] >>> 24) - | ((in[7 + inpos] & 524287) << (27 - 19)) - ) + out[8 + outpos - 1]; - out[9 + outpos] = ((in[7 + inpos] >>> 19) - | ((in[8 + inpos] & 16383) << (27 - 14)) - ) + out[9 + outpos - 1]; - out[10 + outpos] = ((in[8 + inpos] >>> 14) - | ((in[9 + inpos] & 511) << (27 - 9)) - ) + out[10 + outpos - 1]; - out[11 + outpos] = ((in[9 + inpos] >>> 9) - | ((in[10 + inpos] & 15) << (27 - 4)) - ) + out[11 + outpos - 1]; - out[12 + outpos] = (((in[10 + inpos] >>> 4) & 134217727) - ) + out[12 + outpos - 1]; - out[13 + outpos] = ((in[10 + inpos] >>> 31) - | ((in[11 + inpos] & 67108863) << (27 - 26)) - ) + out[13 + outpos - 1]; - out[14 + outpos] = ((in[11 + inpos] >>> 26) - | ((in[12 + inpos] & 2097151) << (27 - 21)) - ) + out[14 + outpos - 1]; - out[15 + outpos] = ((in[12 + inpos] >>> 21) - | ((in[13 + inpos] & 65535) << (27 - 16)) - ) + out[15 + outpos - 1]; - out[16 + outpos] = ((in[13 + inpos] >>> 16) - | ((in[14 + inpos] & 2047) << (27 - 11)) - ) + out[16 + outpos - 1]; - out[17 + outpos] = ((in[14 + inpos] >>> 11) - | ((in[15 + inpos] & 63) << (27 - 6)) - ) + out[17 + outpos - 1]; - out[18 + outpos] = ((in[15 + inpos] >>> 6) - | ((in[16 + inpos] & 1) << (27 - 1)) - ) + out[18 + outpos - 1]; - out[19 + outpos] = (((in[16 + inpos] >>> 1) & 134217727) - ) + out[19 + outpos - 1]; - out[20 + outpos] = ((in[16 + inpos] >>> 28) - | ((in[17 + inpos] & 8388607) << (27 - 23)) - ) + out[20 + outpos - 1]; - out[21 + outpos] = ((in[17 + inpos] >>> 23) - | ((in[18 + inpos] & 262143) << (27 - 18)) - ) + out[21 + outpos - 1]; - out[22 + outpos] = ((in[18 + inpos] >>> 18) - | ((in[19 + inpos] & 8191) << (27 - 13)) - ) + out[22 + outpos - 1]; - out[23 + outpos] = ((in[19 + inpos] >>> 13) - | ((in[20 + inpos] & 255) << (27 - 8)) - ) + out[23 + outpos - 1]; - out[24 + outpos] = ((in[20 + inpos] >>> 8) - | ((in[21 + inpos] & 7) << (27 - 3)) - ) + out[24 + outpos - 1]; - out[25 + outpos] = (((in[21 + inpos] >>> 3) & 134217727) - ) + out[25 + outpos - 1]; - out[26 + outpos] = ((in[21 + inpos] >>> 30) - | ((in[22 + inpos] & 33554431) << (27 - 25)) - ) + out[26 + outpos - 1]; - out[27 + outpos] = ((in[22 + inpos] >>> 25) - | ((in[23 + inpos] & 1048575) << (27 - 20)) - ) + out[27 + outpos - 1]; - out[28 + outpos] = ((in[23 + inpos] >>> 20) - | ((in[24 + inpos] & 32767) << (27 - 15)) - ) + out[28 + outpos - 1]; - out[29 + outpos] = ((in[24 + inpos] >>> 15) - | ((in[25 + inpos] & 1023) << (27 - 10)) - ) + out[29 + outpos - 1]; - out[30 + outpos] = ((in[25 + inpos] >>> 10) - | ((in[26 + inpos] & 31) << (27 - 5)) - ) + out[30 + outpos - 1]; - out[31 + outpos] = ((in[26 + inpos] >>> 5) - ) + out[31 + outpos - 1]; - } - - - protected static void integratedunpack28(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (((in[0 + inpos] >>> 0) & 268435455) - ) + initoffset; - out[1 + outpos] = ((in[0 + inpos] >>> 28) - | ((in[1 + inpos] & 16777215) << (28 - 24)) - ) + out[1 + outpos - 1]; - out[2 + outpos] = ((in[1 + inpos] >>> 24) - | ((in[2 + inpos] & 1048575) << (28 - 20)) - ) + out[2 + outpos - 1]; - out[3 + outpos] = ((in[2 + inpos] >>> 20) - | ((in[3 + inpos] & 65535) << (28 - 16)) - ) + out[3 + outpos - 1]; - out[4 + outpos] = ((in[3 + inpos] >>> 16) - | ((in[4 + inpos] & 4095) << (28 - 12)) - ) + out[4 + outpos - 1]; - out[5 + outpos] = ((in[4 + inpos] >>> 12) - | ((in[5 + inpos] & 255) << (28 - 8)) - ) + out[5 + outpos - 1]; - out[6 + outpos] = ((in[5 + inpos] >>> 8) - | ((in[6 + inpos] & 15) << (28 - 4)) - ) + out[6 + outpos - 1]; - out[7 + outpos] = ((in[6 + inpos] >>> 4) - ) + out[7 + outpos - 1]; - out[8 + outpos] = (((in[7 + inpos] >>> 0) & 268435455) - ) + out[8 + outpos - 1]; - out[9 + outpos] = ((in[7 + inpos] >>> 28) - | ((in[8 + inpos] & 16777215) << (28 - 24)) - ) + out[9 + outpos - 1]; - out[10 + outpos] = ((in[8 + inpos] >>> 24) - | ((in[9 + inpos] & 1048575) << (28 - 20)) - ) + out[10 + outpos - 1]; - out[11 + outpos] = ((in[9 + inpos] >>> 20) - | ((in[10 + inpos] & 65535) << (28 - 16)) - ) + out[11 + outpos - 1]; - out[12 + outpos] = ((in[10 + inpos] >>> 16) - | ((in[11 + inpos] & 4095) << (28 - 12)) - ) + out[12 + outpos - 1]; - out[13 + outpos] = ((in[11 + inpos] >>> 12) - | ((in[12 + inpos] & 255) << (28 - 8)) - ) + out[13 + outpos - 1]; - out[14 + outpos] = ((in[12 + inpos] >>> 8) - | ((in[13 + inpos] & 15) << (28 - 4)) - ) + out[14 + outpos - 1]; - out[15 + outpos] = ((in[13 + inpos] >>> 4) - ) + out[15 + outpos - 1]; - out[16 + outpos] = (((in[14 + inpos] >>> 0) & 268435455) - ) + out[16 + outpos - 1]; - out[17 + outpos] = ((in[14 + inpos] >>> 28) - | ((in[15 + inpos] & 16777215) << (28 - 24)) - ) + out[17 + outpos - 1]; - out[18 + outpos] = ((in[15 + inpos] >>> 24) - | ((in[16 + inpos] & 1048575) << (28 - 20)) - ) + out[18 + outpos - 1]; - out[19 + outpos] = ((in[16 + inpos] >>> 20) - | ((in[17 + inpos] & 65535) << (28 - 16)) - ) + out[19 + outpos - 1]; - out[20 + outpos] = ((in[17 + inpos] >>> 16) - | ((in[18 + inpos] & 4095) << (28 - 12)) - ) + out[20 + outpos - 1]; - out[21 + outpos] = ((in[18 + inpos] >>> 12) - | ((in[19 + inpos] & 255) << (28 - 8)) - ) + out[21 + outpos - 1]; - out[22 + outpos] = ((in[19 + inpos] >>> 8) - | ((in[20 + inpos] & 15) << (28 - 4)) - ) + out[22 + outpos - 1]; - out[23 + outpos] = ((in[20 + inpos] >>> 4) - ) + out[23 + outpos - 1]; - out[24 + outpos] = (((in[21 + inpos] >>> 0) & 268435455) - ) + out[24 + outpos - 1]; - out[25 + outpos] = ((in[21 + inpos] >>> 28) - | ((in[22 + inpos] & 16777215) << (28 - 24)) - ) + out[25 + outpos - 1]; - out[26 + outpos] = ((in[22 + inpos] >>> 24) - | ((in[23 + inpos] & 1048575) << (28 - 20)) - ) + out[26 + outpos - 1]; - out[27 + outpos] = ((in[23 + inpos] >>> 20) - | ((in[24 + inpos] & 65535) << (28 - 16)) - ) + out[27 + outpos - 1]; - out[28 + outpos] = ((in[24 + inpos] >>> 16) - | ((in[25 + inpos] & 4095) << (28 - 12)) - ) + out[28 + outpos - 1]; - out[29 + outpos] = ((in[25 + inpos] >>> 12) - | ((in[26 + inpos] & 255) << (28 - 8)) - ) + out[29 + outpos - 1]; - out[30 + outpos] = ((in[26 + inpos] >>> 8) - | ((in[27 + inpos] & 15) << (28 - 4)) - ) + out[30 + outpos - 1]; - out[31 + outpos] = ((in[27 + inpos] >>> 4) - ) + out[31 + outpos - 1]; - } - - - protected static void integratedunpack29(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (((in[0 + inpos] >>> 0) & 536870911) - ) + initoffset; - out[1 + outpos] = ((in[0 + inpos] >>> 29) - | ((in[1 + inpos] & 67108863) << (29 - 26)) - ) + out[1 + outpos - 1]; - out[2 + outpos] = ((in[1 + inpos] >>> 26) - | ((in[2 + inpos] & 8388607) << (29 - 23)) - ) + out[2 + outpos - 1]; - out[3 + outpos] = ((in[2 + inpos] >>> 23) - | ((in[3 + inpos] & 1048575) << (29 - 20)) - ) + out[3 + outpos - 1]; - out[4 + outpos] = ((in[3 + inpos] >>> 20) - | ((in[4 + inpos] & 131071) << (29 - 17)) - ) + out[4 + outpos - 1]; - out[5 + outpos] = ((in[4 + inpos] >>> 17) - | ((in[5 + inpos] & 16383) << (29 - 14)) - ) + out[5 + outpos - 1]; - out[6 + outpos] = ((in[5 + inpos] >>> 14) - | ((in[6 + inpos] & 2047) << (29 - 11)) - ) + out[6 + outpos - 1]; - out[7 + outpos] = ((in[6 + inpos] >>> 11) - | ((in[7 + inpos] & 255) << (29 - 8)) - ) + out[7 + outpos - 1]; - out[8 + outpos] = ((in[7 + inpos] >>> 8) - | ((in[8 + inpos] & 31) << (29 - 5)) - ) + out[8 + outpos - 1]; - out[9 + outpos] = ((in[8 + inpos] >>> 5) - | ((in[9 + inpos] & 3) << (29 - 2)) - ) + out[9 + outpos - 1]; - out[10 + outpos] = (((in[9 + inpos] >>> 2) & 536870911) - ) + out[10 + outpos - 1]; - out[11 + outpos] = ((in[9 + inpos] >>> 31) - | ((in[10 + inpos] & 268435455) << (29 - 28)) - ) + out[11 + outpos - 1]; - out[12 + outpos] = ((in[10 + inpos] >>> 28) - | ((in[11 + inpos] & 33554431) << (29 - 25)) - ) + out[12 + outpos - 1]; - out[13 + outpos] = ((in[11 + inpos] >>> 25) - | ((in[12 + inpos] & 4194303) << (29 - 22)) - ) + out[13 + outpos - 1]; - out[14 + outpos] = ((in[12 + inpos] >>> 22) - | ((in[13 + inpos] & 524287) << (29 - 19)) - ) + out[14 + outpos - 1]; - out[15 + outpos] = ((in[13 + inpos] >>> 19) - | ((in[14 + inpos] & 65535) << (29 - 16)) - ) + out[15 + outpos - 1]; - out[16 + outpos] = ((in[14 + inpos] >>> 16) - | ((in[15 + inpos] & 8191) << (29 - 13)) - ) + out[16 + outpos - 1]; - out[17 + outpos] = ((in[15 + inpos] >>> 13) - | ((in[16 + inpos] & 1023) << (29 - 10)) - ) + out[17 + outpos - 1]; - out[18 + outpos] = ((in[16 + inpos] >>> 10) - | ((in[17 + inpos] & 127) << (29 - 7)) - ) + out[18 + outpos - 1]; - out[19 + outpos] = ((in[17 + inpos] >>> 7) - | ((in[18 + inpos] & 15) << (29 - 4)) - ) + out[19 + outpos - 1]; - out[20 + outpos] = ((in[18 + inpos] >>> 4) - | ((in[19 + inpos] & 1) << (29 - 1)) - ) + out[20 + outpos - 1]; - out[21 + outpos] = (((in[19 + inpos] >>> 1) & 536870911) - ) + out[21 + outpos - 1]; - out[22 + outpos] = ((in[19 + inpos] >>> 30) - | ((in[20 + inpos] & 134217727) << (29 - 27)) - ) + out[22 + outpos - 1]; - out[23 + outpos] = ((in[20 + inpos] >>> 27) - | ((in[21 + inpos] & 16777215) << (29 - 24)) - ) + out[23 + outpos - 1]; - out[24 + outpos] = ((in[21 + inpos] >>> 24) - | ((in[22 + inpos] & 2097151) << (29 - 21)) - ) + out[24 + outpos - 1]; - out[25 + outpos] = ((in[22 + inpos] >>> 21) - | ((in[23 + inpos] & 262143) << (29 - 18)) - ) + out[25 + outpos - 1]; - out[26 + outpos] = ((in[23 + inpos] >>> 18) - | ((in[24 + inpos] & 32767) << (29 - 15)) - ) + out[26 + outpos - 1]; - out[27 + outpos] = ((in[24 + inpos] >>> 15) - | ((in[25 + inpos] & 4095) << (29 - 12)) - ) + out[27 + outpos - 1]; - out[28 + outpos] = ((in[25 + inpos] >>> 12) - | ((in[26 + inpos] & 511) << (29 - 9)) - ) + out[28 + outpos - 1]; - out[29 + outpos] = ((in[26 + inpos] >>> 9) - | ((in[27 + inpos] & 63) << (29 - 6)) - ) + out[29 + outpos - 1]; - out[30 + outpos] = ((in[27 + inpos] >>> 6) - | ((in[28 + inpos] & 7) << (29 - 3)) - ) + out[30 + outpos - 1]; - out[31 + outpos] = ((in[28 + inpos] >>> 3) - ) + out[31 + outpos - 1]; - } - - - protected static void integratedunpack30(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (((in[0 + inpos] >>> 0) & 1073741823) - ) + initoffset; - out[1 + outpos] = ((in[0 + inpos] >>> 30) - | ((in[1 + inpos] & 268435455) << (30 - 28)) - ) + out[1 + outpos - 1]; - out[2 + outpos] = ((in[1 + inpos] >>> 28) - | ((in[2 + inpos] & 67108863) << (30 - 26)) - ) + out[2 + outpos - 1]; - out[3 + outpos] = ((in[2 + inpos] >>> 26) - | ((in[3 + inpos] & 16777215) << (30 - 24)) - ) + out[3 + outpos - 1]; - out[4 + outpos] = ((in[3 + inpos] >>> 24) - | ((in[4 + inpos] & 4194303) << (30 - 22)) - ) + out[4 + outpos - 1]; - out[5 + outpos] = ((in[4 + inpos] >>> 22) - | ((in[5 + inpos] & 1048575) << (30 - 20)) - ) + out[5 + outpos - 1]; - out[6 + outpos] = ((in[5 + inpos] >>> 20) - | ((in[6 + inpos] & 262143) << (30 - 18)) - ) + out[6 + outpos - 1]; - out[7 + outpos] = ((in[6 + inpos] >>> 18) - | ((in[7 + inpos] & 65535) << (30 - 16)) - ) + out[7 + outpos - 1]; - out[8 + outpos] = ((in[7 + inpos] >>> 16) - | ((in[8 + inpos] & 16383) << (30 - 14)) - ) + out[8 + outpos - 1]; - out[9 + outpos] = ((in[8 + inpos] >>> 14) - | ((in[9 + inpos] & 4095) << (30 - 12)) - ) + out[9 + outpos - 1]; - out[10 + outpos] = ((in[9 + inpos] >>> 12) - | ((in[10 + inpos] & 1023) << (30 - 10)) - ) + out[10 + outpos - 1]; - out[11 + outpos] = ((in[10 + inpos] >>> 10) - | ((in[11 + inpos] & 255) << (30 - 8)) - ) + out[11 + outpos - 1]; - out[12 + outpos] = ((in[11 + inpos] >>> 8) - | ((in[12 + inpos] & 63) << (30 - 6)) - ) + out[12 + outpos - 1]; - out[13 + outpos] = ((in[12 + inpos] >>> 6) - | ((in[13 + inpos] & 15) << (30 - 4)) - ) + out[13 + outpos - 1]; - out[14 + outpos] = ((in[13 + inpos] >>> 4) - | ((in[14 + inpos] & 3) << (30 - 2)) - ) + out[14 + outpos - 1]; - out[15 + outpos] = ((in[14 + inpos] >>> 2) - ) + out[15 + outpos - 1]; - out[16 + outpos] = (((in[15 + inpos] >>> 0) & 1073741823) - ) + out[16 + outpos - 1]; - out[17 + outpos] = ((in[15 + inpos] >>> 30) - | ((in[16 + inpos] & 268435455) << (30 - 28)) - ) + out[17 + outpos - 1]; - out[18 + outpos] = ((in[16 + inpos] >>> 28) - | ((in[17 + inpos] & 67108863) << (30 - 26)) - ) + out[18 + outpos - 1]; - out[19 + outpos] = ((in[17 + inpos] >>> 26) - | ((in[18 + inpos] & 16777215) << (30 - 24)) - ) + out[19 + outpos - 1]; - out[20 + outpos] = ((in[18 + inpos] >>> 24) - | ((in[19 + inpos] & 4194303) << (30 - 22)) - ) + out[20 + outpos - 1]; - out[21 + outpos] = ((in[19 + inpos] >>> 22) - | ((in[20 + inpos] & 1048575) << (30 - 20)) - ) + out[21 + outpos - 1]; - out[22 + outpos] = ((in[20 + inpos] >>> 20) - | ((in[21 + inpos] & 262143) << (30 - 18)) - ) + out[22 + outpos - 1]; - out[23 + outpos] = ((in[21 + inpos] >>> 18) - | ((in[22 + inpos] & 65535) << (30 - 16)) - ) + out[23 + outpos - 1]; - out[24 + outpos] = ((in[22 + inpos] >>> 16) - | ((in[23 + inpos] & 16383) << (30 - 14)) - ) + out[24 + outpos - 1]; - out[25 + outpos] = ((in[23 + inpos] >>> 14) - | ((in[24 + inpos] & 4095) << (30 - 12)) - ) + out[25 + outpos - 1]; - out[26 + outpos] = ((in[24 + inpos] >>> 12) - | ((in[25 + inpos] & 1023) << (30 - 10)) - ) + out[26 + outpos - 1]; - out[27 + outpos] = ((in[25 + inpos] >>> 10) - | ((in[26 + inpos] & 255) << (30 - 8)) - ) + out[27 + outpos - 1]; - out[28 + outpos] = ((in[26 + inpos] >>> 8) - | ((in[27 + inpos] & 63) << (30 - 6)) - ) + out[28 + outpos - 1]; - out[29 + outpos] = ((in[27 + inpos] >>> 6) - | ((in[28 + inpos] & 15) << (30 - 4)) - ) + out[29 + outpos - 1]; - out[30 + outpos] = ((in[28 + inpos] >>> 4) - | ((in[29 + inpos] & 3) << (30 - 2)) - ) + out[30 + outpos - 1]; - out[31 + outpos] = ((in[29 + inpos] >>> 2) - ) + out[31 + outpos - 1]; - } - - - protected static void integratedunpack31(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - out[0 + outpos] = (((in[0 + inpos] >>> 0) & 2147483647) - ) + initoffset; - out[1 + outpos] = ((in[0 + inpos] >>> 31) - | ((in[1 + inpos] & 1073741823) << (31 - 30)) - ) + out[1 + outpos - 1]; - out[2 + outpos] = ((in[1 + inpos] >>> 30) - | ((in[2 + inpos] & 536870911) << (31 - 29)) - ) + out[2 + outpos - 1]; - out[3 + outpos] = ((in[2 + inpos] >>> 29) - | ((in[3 + inpos] & 268435455) << (31 - 28)) - ) + out[3 + outpos - 1]; - out[4 + outpos] = ((in[3 + inpos] >>> 28) - | ((in[4 + inpos] & 134217727) << (31 - 27)) - ) + out[4 + outpos - 1]; - out[5 + outpos] = ((in[4 + inpos] >>> 27) - | ((in[5 + inpos] & 67108863) << (31 - 26)) - ) + out[5 + outpos - 1]; - out[6 + outpos] = ((in[5 + inpos] >>> 26) - | ((in[6 + inpos] & 33554431) << (31 - 25)) - ) + out[6 + outpos - 1]; - out[7 + outpos] = ((in[6 + inpos] >>> 25) - | ((in[7 + inpos] & 16777215) << (31 - 24)) - ) + out[7 + outpos - 1]; - out[8 + outpos] = ((in[7 + inpos] >>> 24) - | ((in[8 + inpos] & 8388607) << (31 - 23)) - ) + out[8 + outpos - 1]; - out[9 + outpos] = ((in[8 + inpos] >>> 23) - | ((in[9 + inpos] & 4194303) << (31 - 22)) - ) + out[9 + outpos - 1]; - out[10 + outpos] = ((in[9 + inpos] >>> 22) - | ((in[10 + inpos] & 2097151) << (31 - 21)) - ) + out[10 + outpos - 1]; - out[11 + outpos] = ((in[10 + inpos] >>> 21) - | ((in[11 + inpos] & 1048575) << (31 - 20)) - ) + out[11 + outpos - 1]; - out[12 + outpos] = ((in[11 + inpos] >>> 20) - | ((in[12 + inpos] & 524287) << (31 - 19)) - ) + out[12 + outpos - 1]; - out[13 + outpos] = ((in[12 + inpos] >>> 19) - | ((in[13 + inpos] & 262143) << (31 - 18)) - ) + out[13 + outpos - 1]; - out[14 + outpos] = ((in[13 + inpos] >>> 18) - | ((in[14 + inpos] & 131071) << (31 - 17)) - ) + out[14 + outpos - 1]; - out[15 + outpos] = ((in[14 + inpos] >>> 17) - | ((in[15 + inpos] & 65535) << (31 - 16)) - ) + out[15 + outpos - 1]; - out[16 + outpos] = ((in[15 + inpos] >>> 16) - | ((in[16 + inpos] & 32767) << (31 - 15)) - ) + out[16 + outpos - 1]; - out[17 + outpos] = ((in[16 + inpos] >>> 15) - | ((in[17 + inpos] & 16383) << (31 - 14)) - ) + out[17 + outpos - 1]; - out[18 + outpos] = ((in[17 + inpos] >>> 14) - | ((in[18 + inpos] & 8191) << (31 - 13)) - ) + out[18 + outpos - 1]; - out[19 + outpos] = ((in[18 + inpos] >>> 13) - | ((in[19 + inpos] & 4095) << (31 - 12)) - ) + out[19 + outpos - 1]; - out[20 + outpos] = ((in[19 + inpos] >>> 12) - | ((in[20 + inpos] & 2047) << (31 - 11)) - ) + out[20 + outpos - 1]; - out[21 + outpos] = ((in[20 + inpos] >>> 11) - | ((in[21 + inpos] & 1023) << (31 - 10)) - ) + out[21 + outpos - 1]; - out[22 + outpos] = ((in[21 + inpos] >>> 10) - | ((in[22 + inpos] & 511) << (31 - 9)) - ) + out[22 + outpos - 1]; - out[23 + outpos] = ((in[22 + inpos] >>> 9) - | ((in[23 + inpos] & 255) << (31 - 8)) - ) + out[23 + outpos - 1]; - out[24 + outpos] = ((in[23 + inpos] >>> 8) - | ((in[24 + inpos] & 127) << (31 - 7)) - ) + out[24 + outpos - 1]; - out[25 + outpos] = ((in[24 + inpos] >>> 7) - | ((in[25 + inpos] & 63) << (31 - 6)) - ) + out[25 + outpos - 1]; - out[26 + outpos] = ((in[25 + inpos] >>> 6) - | ((in[26 + inpos] & 31) << (31 - 5)) - ) + out[26 + outpos - 1]; - out[27 + outpos] = ((in[26 + inpos] >>> 5) - | ((in[27 + inpos] & 15) << (31 - 4)) - ) + out[27 + outpos - 1]; - out[28 + outpos] = ((in[27 + inpos] >>> 4) - | ((in[28 + inpos] & 7) << (31 - 3)) - ) + out[28 + outpos - 1]; - out[29 + outpos] = ((in[28 + inpos] >>> 3) - | ((in[29 + inpos] & 3) << (31 - 2)) - ) + out[29 + outpos - 1]; - out[30 + outpos] = ((in[29 + inpos] >>> 2) - | ((in[30 + inpos] & 1) << (31 - 1)) - ) + out[30 + outpos - 1]; - out[31 + outpos] = ((in[30 + inpos] >>> 1) - ) + out[31 + outpos - 1]; - } - - - protected static void integratedunpack32(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - System.arraycopy(in, inpos, out, outpos, 32); // no sense in doing delta coding - } - - - protected static void integratedpack32(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - System.arraycopy(in, inpos, out, outpos, 32); // no sense in doing delta coding - } - - - protected static void integratedunpack0(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - Arrays.fill(out, outpos, outpos + 32, initoffset); - } - - - protected static void integratedpack0(final int initoffset, final int[] in, int inpos, final int[] out, int outpos) { - // nothing - } - - - protected static void integratedunpack(final int initoffset, final int[] in, int inpos, final int[] out, int outpos, final int bit) { - switch (bit) { - case 0: - integratedunpack0(initoffset, in, inpos, out, outpos); - break; - case 1: - integratedunpack1(initoffset, in, inpos, out, outpos); - break; - case 2: - integratedunpack2(initoffset, in, inpos, out, outpos); - break; - case 3: - integratedunpack3(initoffset, in, inpos, out, outpos); - break; - case 4: - integratedunpack4(initoffset, in, inpos, out, outpos); - break; - case 5: - integratedunpack5(initoffset, in, inpos, out, outpos); - break; - case 6: - integratedunpack6(initoffset, in, inpos, out, outpos); - break; - case 7: - integratedunpack7(initoffset, in, inpos, out, outpos); - break; - case 8: - integratedunpack8(initoffset, in, inpos, out, outpos); - break; - case 9: - integratedunpack9(initoffset, in, inpos, out, outpos); - break; - case 10: - integratedunpack10(initoffset, in, inpos, out, outpos); - break; - case 11: - integratedunpack11(initoffset, in, inpos, out, outpos); - break; - case 12: - integratedunpack12(initoffset, in, inpos, out, outpos); - break; - case 13: - integratedunpack13(initoffset, in, inpos, out, outpos); - break; - case 14: - integratedunpack14(initoffset, in, inpos, out, outpos); - break; - case 15: - integratedunpack15(initoffset, in, inpos, out, outpos); - break; - case 16: - integratedunpack16(initoffset, in, inpos, out, outpos); - break; - case 17: - integratedunpack17(initoffset, in, inpos, out, outpos); - break; - case 18: - integratedunpack18(initoffset, in, inpos, out, outpos); - break; - case 19: - integratedunpack19(initoffset, in, inpos, out, outpos); - break; - case 20: - integratedunpack20(initoffset, in, inpos, out, outpos); - break; - case 21: - integratedunpack21(initoffset, in, inpos, out, outpos); - break; - case 22: - integratedunpack22(initoffset, in, inpos, out, outpos); - break; - case 23: - integratedunpack23(initoffset, in, inpos, out, outpos); - break; - case 24: - integratedunpack24(initoffset, in, inpos, out, outpos); - break; - case 25: - integratedunpack25(initoffset, in, inpos, out, outpos); - break; - case 26: - integratedunpack26(initoffset, in, inpos, out, outpos); - break; - case 27: - integratedunpack27(initoffset, in, inpos, out, outpos); - break; - case 28: - integratedunpack28(initoffset, in, inpos, out, outpos); - break; - case 29: - integratedunpack29(initoffset, in, inpos, out, outpos); - break; - case 30: - integratedunpack30(initoffset, in, inpos, out, outpos); - break; - case 31: - integratedunpack31(initoffset, in, inpos, out, outpos); - break; - case 32: - integratedunpack32(initoffset, in, inpos, out, outpos); - break; - default: - throw new IllegalArgumentException("Unsupported bit width."); - } - } - - - protected static void integratedpack(final int initoffset, final int[] in, int inpos, final int[] out, int outpos, final int bit) { - switch (bit) { - case 0: - integratedpack0(initoffset, in, inpos, out, outpos); - break; - case 1: - integratedpack1(initoffset, in, inpos, out, outpos); - break; - case 2: - integratedpack2(initoffset, in, inpos, out, outpos); - break; - case 3: - integratedpack3(initoffset, in, inpos, out, outpos); - break; - case 4: - integratedpack4(initoffset, in, inpos, out, outpos); - break; - case 5: - integratedpack5(initoffset, in, inpos, out, outpos); - break; - case 6: - integratedpack6(initoffset, in, inpos, out, outpos); - break; - case 7: - integratedpack7(initoffset, in, inpos, out, outpos); - break; - case 8: - integratedpack8(initoffset, in, inpos, out, outpos); - break; - case 9: - integratedpack9(initoffset, in, inpos, out, outpos); - break; - case 10: - integratedpack10(initoffset, in, inpos, out, outpos); - break; - case 11: - integratedpack11(initoffset, in, inpos, out, outpos); - break; - case 12: - integratedpack12(initoffset, in, inpos, out, outpos); - break; - case 13: - integratedpack13(initoffset, in, inpos, out, outpos); - break; - case 14: - integratedpack14(initoffset, in, inpos, out, outpos); - break; - case 15: - integratedpack15(initoffset, in, inpos, out, outpos); - break; - case 16: - integratedpack16(initoffset, in, inpos, out, outpos); - break; - case 17: - integratedpack17(initoffset, in, inpos, out, outpos); - break; - case 18: - integratedpack18(initoffset, in, inpos, out, outpos); - break; - case 19: - integratedpack19(initoffset, in, inpos, out, outpos); - break; - case 20: - integratedpack20(initoffset, in, inpos, out, outpos); - break; - case 21: - integratedpack21(initoffset, in, inpos, out, outpos); - break; - case 22: - integratedpack22(initoffset, in, inpos, out, outpos); - break; - case 23: - integratedpack23(initoffset, in, inpos, out, outpos); - break; - case 24: - integratedpack24(initoffset, in, inpos, out, outpos); - break; - case 25: - integratedpack25(initoffset, in, inpos, out, outpos); - break; - case 26: - integratedpack26(initoffset, in, inpos, out, outpos); - break; - case 27: - integratedpack27(initoffset, in, inpos, out, outpos); - break; - case 28: - integratedpack28(initoffset, in, inpos, out, outpos); - break; - case 29: - integratedpack29(initoffset, in, inpos, out, outpos); - break; - case 30: - integratedpack30(initoffset, in, inpos, out, outpos); - break; - case 31: - integratedpack31(initoffset, in, inpos, out, outpos); - break; - case 32: -if(out.length < outpos + 32) throw new RuntimeException(outpos + " "+out.length); -if(in.length < inpos + 32) throw new RuntimeException(); - -integratedpack32(initoffset, in, inpos, out, outpos); - break; - default: - throw new IllegalArgumentException("Unsupported bit width."); - } - } - -} diff --git a/src/main/java/me/lemire/integercompression/IntegratedComposition.java b/src/main/java/me/lemire/integercompression/IntegratedComposition.java deleted file mode 100644 index d2bd59f..0000000 --- a/src/main/java/me/lemire/integercompression/IntegratedComposition.java +++ /dev/null @@ -1,63 +0,0 @@ -/** - * This code is released under the - * Apache License Version 2.0 http://www.apache.org/licenses/. - * - * (c) Daniel Lemire, http://lemire.me/en/ - */ -package me.lemire.integercompression; - -/** - * Helper class to compose schemes. - * - * @author Daniel Lemire - */ -public class IntegratedComposition implements IntegratedIntegerCODEC { - IntegratedIntegerCODEC F1, F2; - - /** - * Compose a scheme from a first one (f1) and a second one (f2). - * The first one is called first and then the second one tries to - * compress whatever remains from the first run. - * - * By convention, the first scheme should be such that if, during - * decoding, a 32-bit zero is first encountered, then there is no - * output. - * - * @param f1 first codec - * @param f2 second codec - */ - public IntegratedComposition(IntegratedIntegerCODEC f1, IntegratedIntegerCODEC f2) { - F1 = f1; - F2 = f2; - } - - @Override - public void compress(int[] in, IntWrapper inpos, int inlength, int[] out, - IntWrapper outpos) { - if(inlength == 0) return; - final int init = inpos.get(); - F1.compress(in, inpos, inlength, out, outpos); - if (outpos.get() == 0) { - out[0] = 0; - outpos.increment(); - } - inlength -= inpos.get() - init; - F2.compress(in, inpos, inlength, out, outpos); - } - - @Override - public void uncompress(int[] in, IntWrapper inpos, int inlength, int[] out, - IntWrapper outpos) { - if(inlength == 0) return; - int init = inpos.get(); - F1.uncompress(in, inpos, inlength, out, outpos); - inlength -= inpos.get() - init; - F2.uncompress(in, inpos, inlength, out, outpos); - } - - @Override - public String toString() { - return F1.toString() + "+" + F2.toString(); - } - -} diff --git a/src/main/java/me/lemire/integercompression/IntegratedIntegerCODEC.java b/src/main/java/me/lemire/integercompression/IntegratedIntegerCODEC.java deleted file mode 100644 index dcfe0c4..0000000 --- a/src/main/java/me/lemire/integercompression/IntegratedIntegerCODEC.java +++ /dev/null @@ -1,19 +0,0 @@ -/** - * This code is released under the - * Apache License Version 2.0 http://www.apache.org/licenses/. - * - * (c) Daniel Lemire, http://lemire.me/en/ - */ -package me.lemire.integercompression; - - -/** - * This is just like IntegerCODEC, except that it indicates - * that delta coding is "integrated", so that you don't - * need a separate step for delta coding. - * - * @author Daniel Lemire - */ -public interface IntegratedIntegerCODEC extends IntegerCODEC { - -} diff --git a/src/main/java/me/lemire/integercompression/IntegratedVariableByte.java b/src/main/java/me/lemire/integercompression/IntegratedVariableByte.java deleted file mode 100644 index f4aa11b..0000000 --- a/src/main/java/me/lemire/integercompression/IntegratedVariableByte.java +++ /dev/null @@ -1,81 +0,0 @@ - -/** - * This code is released under the - * Apache License Version 2.0 http://www.apache.org/licenses/. - * - * (c) Daniel Lemire, http://lemire.me/en/ - */ -package me.lemire.integercompression; - -import java.nio.ByteBuffer; -import java.nio.IntBuffer; - -/** - * @author Daniel Lemire - * - */ -public class IntegratedVariableByte implements IntegratedIntegerCODEC { - @Override - public void compress(int[] in, IntWrapper inpos, int inlength, int[] out, - IntWrapper outpos) { - if(inlength == 0) return; - int initoffset = 0; - ByteBuffer buf = ByteBuffer.allocateDirect(inlength * 8); - for (int k = inpos.get(); k < inpos.get() + inlength; ++k) { - int val = in[k] - initoffset; - initoffset = in[k]; - do { - int b = (val & 127); - val >>>= 7; - if (val != 0) { - b |= 128; - } - buf.put((byte) b); - } while (val != 0); - } - while (buf.position() % 4 != 0) - buf.put((byte) 128); - final int length = buf.position(); - buf.flip(); - IntBuffer ibuf = buf.asIntBuffer(); - ibuf.get(out, outpos.get(), length / 4); - outpos.add(length / 4); - inpos.add(inlength); - } - - @Override - public void uncompress(int[] in, IntWrapper inpos, int inlength, - int[] out, IntWrapper outpos) { - if(inlength == 0) return; - int s = 0; - int p = inpos.get(); - int finalp = inpos.get() + inlength; - int tmpoutpos = outpos.get(); - int initoffset = 0; - for (int v = 0, shift = 0; p < finalp; ) { - int c = (byte) (in[p] >>> (24 - s)); - s += 8; - if (s == 32) { - s = 0; - p++; - } - v += ((c & 127) << shift); - if ((c & 128) == 0) { - out[tmpoutpos] = v + initoffset; - initoffset = out[tmpoutpos]; - tmpoutpos++; - v = 0; - shift = 0; - } else - shift += 7; - } - outpos.set(tmpoutpos); - inpos.add(inlength); - } - - @Override - public String toString() { - return this.getClass().getSimpleName(); - } - -} diff --git a/src/main/java/me/lemire/integercompression/JustCopy.java b/src/main/java/me/lemire/integercompression/JustCopy.java index 2ef2f7a..f57282c 100644 --- a/src/main/java/me/lemire/integercompression/JustCopy.java +++ b/src/main/java/me/lemire/integercompression/JustCopy.java @@ -10,29 +10,48 @@ /** * @author Daniel Lemire - * + * */ -public final class JustCopy implements IntegerCODEC { - - @Override - public void compress(int[] in, IntWrapper inpos, int inlength, int[] out, IntWrapper outpos) { - System.arraycopy(in, inpos.get(), out, outpos.get(), inlength); - inpos.add(inlength); - outpos.add(inlength); - } - - @Override - public void uncompress(int[] in, IntWrapper inpos, int inlength, int[] out, IntWrapper outpos) { - System.arraycopy(in, inpos.get(), out, outpos.get(), inlength); - inpos.add(inlength); - outpos.add(inlength); - } - - - @Override - public String toString() { - return this.getClass().getSimpleName(); - } - +public final class JustCopy implements IntegerCODEC, SkippableIntegerCODEC { + + @Override + public void headlessCompress(int[] in, IntWrapper inpos, int inlength, + int[] out, IntWrapper outpos) { + System.arraycopy(in, inpos.get(), out, outpos.get(), inlength); + inpos.add(inlength); + outpos.add(inlength); + } + + @Override + public void uncompress(int[] in, IntWrapper inpos, int inlength, + int[] out, IntWrapper outpos) { + headlessUncompress(in,inpos,inlength,out,outpos,inlength); + } + + @Override + public String toString() { + return this.getClass().getSimpleName(); + } + + @Override + public void headlessUncompress(int[] in, IntWrapper inpos, int inlength, + int[] out, IntWrapper outpos, int num) { + System.arraycopy(in, inpos.get(), out, outpos.get(), num); + inpos.add(num); + outpos.add(num); + + } + + @Override + public int maxHeadlessCompressedLength(IntWrapper compressedPositions, int inlength) { + compressedPositions.add(inlength); + return inlength; + } + + @Override + public void compress(int[] in, IntWrapper inpos, int inlength, + int[] out, IntWrapper outpos) { + headlessCompress(in,inpos,inlength,out,outpos); + } } diff --git a/src/main/java/me/lemire/integercompression/Kamikaze.java b/src/main/java/me/lemire/integercompression/Kamikaze.java new file mode 100644 index 0000000..4cab30b --- /dev/null +++ b/src/main/java/me/lemire/integercompression/Kamikaze.java @@ -0,0 +1,72 @@ +package me.lemire.integercompression; + +import com.kamikaze.pfordelta.PForDelta; + +/** + * IntegerCODEC wrapper for Kamikaze's PForDelta. + * + * Note: this class is only included for speed benchmarks. + * It is not recommended. Use at your own risks. + * + * @author Matteo Catena + * + */ +public class Kamikaze implements SkippableIntegerCODEC, IntegerCODEC { + + private int BLOCK_SIZE = 128; + + @Override + public void headlessCompress(int[] in, IntWrapper inpos, int inlength, int[] out, + IntWrapper outpos) { + inlength = Util.greatestMultiple(inlength, BLOCK_SIZE); + if (inlength > 0) { + int[] out2 = PForDelta.compressOneBlockOpt(in, inlength); + inpos.add(inlength); + System.arraycopy(out2, 0, out, outpos.get(), out2.length); + outpos.add(out2.length); + } + } + + @Override + public void headlessUncompress(int[] in, IntWrapper inpos, int inlength, int[] out, + IntWrapper outpos, int num) { + num = Util.greatestMultiple(num, BLOCK_SIZE); + if (num > 0) { + int d = PForDelta.decompressOneBlock(out, in, num); + inpos.add(d / 32); + outpos.add(num); + } + } + + @Override + public int maxHeadlessCompressedLength(IntWrapper compressedPositions, int inlength) { + throw new UnsupportedOperationException("Calculating the max compressed length is not supported yet."); + } + + @Override + public String toString() { + return "Kamikaze's PForDelta"; + } + + @Override + public void compress(int[] in, IntWrapper inpos, int inlength, int[] out, + IntWrapper outpos) { + inlength = Util.greatestMultiple(inlength, BLOCK_SIZE); + if (inlength == 0) + return; + out[outpos.get()] = inlength; + outpos.increment(); + headlessCompress(in, inpos, inlength, out, outpos); + } + + @Override + public void uncompress(int[] in, IntWrapper inpos, int inlength, int[] out, + IntWrapper outpos) { + if (inlength == 0) + return; + final int outlength = in[inpos.get()]; + inpos.increment(); + headlessUncompress(in, inpos, inlength, out, outpos, outlength); + + } +} diff --git a/src/main/java/me/lemire/integercompression/NewPFD.java b/src/main/java/me/lemire/integercompression/NewPFD.java index d6cae1f..3da3002 100644 --- a/src/main/java/me/lemire/integercompression/NewPFD.java +++ b/src/main/java/me/lemire/integercompression/NewPFD.java @@ -7,155 +7,190 @@ package me.lemire.integercompression; + /** - * NewPFD/NewPFOR implemented by Daniel Lemire - *

+ * NewPFD/NewPFOR: fast patching scheme by Yan et al. + *

* Follows: - *

+ *

* H. Yan, S. Ding, T. Suel, Inverted index compression and query processing - * with optimized document ordering, in: WWW �09, 2009, pp. 401�410. - *

+ * with optimized document ordering, in: WWW 09, 2009, pp. 401-410. + *

* using Simple16 as the secondary coder. - * + * + * It encodes integers in blocks of 128 integers. For arrays containing + * an arbitrary number of integers, you should use it in conjunction + * with another CODEC: + * + *
IntegerCODEC ic = 
+ *  new Composition(new NewPDF(), new VariableByte()).
+ * + * Note that this does not use differential coding: if you are working on sorted + * lists, you must compute the deltas separately. (Yes, this is true even though + * the "D" at the end of the name probably stands for delta.) + * + * For multi-threaded applications, each thread should use its own NewPFD + * object. + * * @author Daniel Lemire */ -public final class NewPFD implements IntegerCODEC { - final int PageSize; - final static int BlockSize = 128; +public final class NewPFD implements IntegerCODEC,SkippableIntegerCODEC { + final static int BLOCK_SIZE = 128; - int[] exceptbuffer = new int[2 * BlockSize]; - - /** - * Constructor for the NewPFD CODEC. - */ - public NewPFD() { - PageSize = 65536; - } + int[] exceptbuffer = new int[2 * BLOCK_SIZE]; - @Override - public void compress(int[] in, IntWrapper inpos, int inlength, int[] out, - IntWrapper outpos) { - inlength = inlength / BlockSize * BlockSize; - if(inlength == 0) return; - final int finalinpos = inpos.get() + inlength; - out[outpos.get()] = inlength; - outpos.increment(); - while (inpos.get() != finalinpos) { - int thissize = finalinpos > PageSize + inpos.get() ? PageSize - : (finalinpos - inpos.get()); - encodePage(in, inpos, thissize, out, outpos); + /** + * Constructor for the NewPFD CODEC. + */ + public NewPFD() { } - } + @Override + public void headlessCompress(int[] in, IntWrapper inpos, int inlength, + int[] out, IntWrapper outpos) { + inlength = Util.greatestMultiple(inlength, BLOCK_SIZE); + if (inlength == 0) + return; + encodePage(in, inpos, inlength, out, outpos); + } - protected static final int[] bits = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, - 12, 13, 16, 20, 32}; - protected static final int[] invbits = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, - 12, 13, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16, - 16, 16, 16, 16}; + protected static final int[] bits = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 16, 20, 32 }; + protected static final int[] invbits = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16 }; - protected static void getBestBFromData(int[] in, int pos, IntWrapper bestb, - IntWrapper bestexcept) { - final int mb = Util.maxbits(in, pos, BlockSize); - int mini = 0; - if (mini + 28 < bits[invbits[mb]]) - mini = bits[invbits[mb]] - 28; // 28 is the max for exceptions - int besti = bits.length - 1; - int exceptcounter = 0; - for (int i = mini; i < bits.length - 1; ++i) { - int tmpcounter = 0; - for (int k = pos; k < BlockSize + pos; ++k) - if ((in[k] >>> bits[i]) != 0) - ++tmpcounter; - if (tmpcounter * 10 <= BlockSize) { - besti = i; - exceptcounter = tmpcounter; - break; - } + protected static void getBestBFromData(int[] in, int pos, + IntWrapper bestb, IntWrapper bestexcept) { + final int mb = Util.maxbits(in, pos, BLOCK_SIZE); + int mini = 0; + if (mini + 28 < bits[invbits[mb]]) + mini = bits[invbits[mb]] - 28; // 28 is the max for + // exceptions + int besti = bits.length - 1; + int exceptcounter = 0; + for (int i = mini; i < bits.length - 1; ++i) { + int tmpcounter = 0; + for (int k = pos; k < BLOCK_SIZE + pos; ++k) + if ((in[k] >>> bits[i]) != 0) + ++tmpcounter; + if (tmpcounter * 10 <= BLOCK_SIZE) { + besti = i; + exceptcounter = tmpcounter; + break; + } + } + bestb.set(besti); + bestexcept.set(exceptcounter); } - bestb.set(besti); - bestexcept.set(exceptcounter); - } - private void encodePage(int[] in, IntWrapper inpos, int thissize, - int[] out, IntWrapper outpos) { - int tmpoutpos = outpos.get(); - int tmpinpos = inpos.get(); - IntWrapper bestb = new IntWrapper(); - IntWrapper bestexcept = new IntWrapper(); - for (final int finalinpos = tmpinpos + thissize; tmpinpos + BlockSize <= finalinpos; tmpinpos += BlockSize) { - getBestBFromData(in, tmpinpos, bestb, bestexcept); - final int tmpbestb = bestb.get(); - final int nbrexcept = bestexcept.get(); - int exceptsize = 0; - final int remember = tmpoutpos; - tmpoutpos++; - if (nbrexcept > 0) { - for (int i = 0, c = 0; i < BlockSize; ++i) { - if ((in[tmpinpos + i] >>> bits[tmpbestb])!=0) { - exceptbuffer[c + nbrexcept] = i; - exceptbuffer[c] = in[tmpinpos + i] >>> bits[tmpbestb]; - ++c; - } + private void encodePage(int[] in, IntWrapper inpos, int thissize, + int[] out, IntWrapper outpos) { + int tmpoutpos = outpos.get(); + int tmpinpos = inpos.get(); + IntWrapper bestb = new IntWrapper(); + IntWrapper bestexcept = new IntWrapper(); + for (final int finalinpos = tmpinpos + thissize; tmpinpos + + BLOCK_SIZE <= finalinpos; tmpinpos += BLOCK_SIZE) { + getBestBFromData(in, tmpinpos, bestb, bestexcept); + final int tmpbestb = bestb.get(); + final int nbrexcept = bestexcept.get(); + int exceptsize = 0; + final int remember = tmpoutpos; + tmpoutpos++; + if (nbrexcept > 0) { + for (int i = 0, c = 0; i < BLOCK_SIZE; ++i) { + if ((in[tmpinpos + i] >>> bits[tmpbestb]) != 0) { + exceptbuffer[c + nbrexcept] = i; + exceptbuffer[c] = in[tmpinpos + + i] >>> bits[tmpbestb]; + ++c; + } + } + exceptsize = S16.compress(exceptbuffer, 0, + 2 * nbrexcept, out, tmpoutpos); + tmpoutpos += exceptsize; + } + out[remember] = tmpbestb | (nbrexcept << 8) + | (exceptsize << 16); + for (int k = 0; k < BLOCK_SIZE; k += 32) { + BitPacking.fastpack(in, tmpinpos + k, out, + tmpoutpos, bits[tmpbestb]); + tmpoutpos += bits[tmpbestb]; + } } - exceptsize = S16.compress(exceptbuffer, 0, 2 * nbrexcept, out, - tmpoutpos); - tmpoutpos += exceptsize; - } - out[remember] = tmpbestb | (nbrexcept << 8) | (exceptsize << 16); - for (int k = 0; k < BlockSize; k += 32) { - BitPacking.fastpack(in, tmpinpos + k, out, tmpoutpos, - bits[tmpbestb]); - tmpoutpos += bits[tmpbestb]; - } + inpos.set(tmpinpos); + outpos.set(tmpoutpos); + } + + @Override + public void headlessUncompress(int[] in, IntWrapper inpos, int inlength, + int[] out, IntWrapper outpos, int mynvalue) { + if (inlength == 0) + return; + mynvalue = Util.greatestMultiple(mynvalue, BLOCK_SIZE); + decodePage(in, inpos, out, outpos, mynvalue); } - inpos.set(tmpinpos); - outpos.set(tmpoutpos); - } - @Override - public void uncompress(int[] in, IntWrapper inpos, int inlength, int[] out, - IntWrapper outpos) { - if(inlength == 0) return; - int mynvalue = in[inpos.get()]; - inpos.increment(); - final int finalout = outpos.get() + mynvalue; - while (outpos.get() != finalout) { - int thissize = finalout > PageSize + outpos.get() ? PageSize - : (finalout - outpos.get()); - decodePage(in, inpos, out, outpos, thissize); + @Override + public int maxHeadlessCompressedLength(IntWrapper compressedPositions, int inlength) { + inlength = Util.greatestMultiple(inlength, BLOCK_SIZE); + int blockCount = inlength / BLOCK_SIZE; + // +1 for the header + // getBestBFromData limits the memory used for exceptions so that the total size of the block does not exceed BLOCK_SIZE integers. + int maxBlockSizeInInts = 1 + BLOCK_SIZE; + compressedPositions.add(inlength); + return maxBlockSizeInInts * blockCount; } - } - private void decodePage(int[] in, IntWrapper inpos, int[] out, - IntWrapper outpos, int thissize) { - int tmpoutpos = outpos.get(); - int tmpinpos = inpos.get(); + private void decodePage(int[] in, IntWrapper inpos, int[] out, + IntWrapper outpos, int thissize) { + int tmpoutpos = outpos.get(); + int tmpinpos = inpos.get(); - for (int run = 0; run < thissize / BlockSize; ++run, tmpoutpos += BlockSize) { - final int b = in[tmpinpos] & 0xFF; - final int cexcept = (in[tmpinpos] >>> 8) & 0xFF; - final int exceptsize = (in[tmpinpos] >>> 16); - ++tmpinpos; - S16.uncompress(in, tmpinpos, exceptsize, exceptbuffer, 0, - 2 * cexcept); - tmpinpos += exceptsize; - for (int k = 0; k < BlockSize; k += 32) { - BitPacking - .fastunpack(in, tmpinpos, out, tmpoutpos + k, bits[b]); - tmpinpos += bits[b]; - } - for (int k = 0; k < cexcept; ++k) { - out[tmpoutpos + exceptbuffer[k + cexcept]] |= (exceptbuffer[k] << bits[b]); - } + for (int run = 0; run < thissize / BLOCK_SIZE; ++run, tmpoutpos += BLOCK_SIZE) { + final int b = in[tmpinpos] & 0xFF; + final int cexcept = (in[tmpinpos] >>> 8) & 0xFF; + final int exceptsize = (in[tmpinpos] >>> 16); + ++tmpinpos; + S16.uncompress(in, tmpinpos, exceptsize, exceptbuffer, + 0, 2 * cexcept); + tmpinpos += exceptsize; + for (int k = 0; k < BLOCK_SIZE; k += 32) { + BitPacking.fastunpack(in, tmpinpos, out, + tmpoutpos + k, bits[b]); + tmpinpos += bits[b]; + } + for (int k = 0; k < cexcept; ++k) { + out[tmpoutpos + exceptbuffer[k + cexcept]] |= (exceptbuffer[k] << bits[b]); + } + } + outpos.set(tmpoutpos); + inpos.set(tmpinpos); + } + @Override + public void compress(int[] in, IntWrapper inpos, int inlength, int[] out, + IntWrapper outpos) { + inlength = Util.greatestMultiple(inlength, BLOCK_SIZE); + if (inlength == 0) + return; + out[outpos.get()] = inlength; + outpos.increment(); + headlessCompress(in, inpos, inlength, out, outpos); } - outpos.set(tmpoutpos); - inpos.set(tmpinpos); - } - @Override - public String toString() { - return this.getClass().getSimpleName(); - } + @Override + public void uncompress(int[] in, IntWrapper inpos, int inlength, int[] out, + IntWrapper outpos) { + if (inlength == 0) + return; + final int outlength = in[inpos.get()]; + inpos.increment(); + headlessUncompress(in, inpos, inlength, out, outpos, outlength); + } + @Override + public String toString() { + return this.getClass().getSimpleName(); + } } diff --git a/src/main/java/me/lemire/integercompression/NewPFDS16.java b/src/main/java/me/lemire/integercompression/NewPFDS16.java index 73f4e31..526b8fb 100644 --- a/src/main/java/me/lemire/integercompression/NewPFDS16.java +++ b/src/main/java/me/lemire/integercompression/NewPFDS16.java @@ -7,155 +7,189 @@ package me.lemire.integercompression; + /** - * NewPFD/NewPFOR implemented by Daniel Lemire - *

+ * NewPFD/NewPFOR based on Simple16 by Yan et al. + *

* Follows: - *

+ *

* H. Yan, S. Ding, T. Suel, Inverted index compression and query processing * with optimized document ordering, in: WWW 09, 2009, pp. 401-410. - *

+ *

* using Simple16 as the secondary coder. - * + * + * It encodes integers in blocks of 128 integers. For arrays containing + * an arbitrary number of integers, you should use it in conjunction + * with another CODEC: + * + *

IntegerCODEC ic =
+ *   new Composition(new PDFS16(), new VariableByte()).
+ * + * Note that this does not use differential coding: if you are working on sorted + * lists, you must compute the deltas separately. + * + * For multi-threaded applications, each thread should use its own NewPFDS16 + * object. + * * @author Daniel Lemire */ -public final class NewPFDS16 implements IntegerCODEC { - final int PageSize; - final static int BlockSize = 128; - - int[] exceptbuffer = new int[2 * BlockSize]; +public final class NewPFDS16 implements IntegerCODEC,SkippableIntegerCODEC { + final static int BLOCK_SIZE= 128; - /** - * Constructor for the NewPFDS16 CODEC. - */ - public NewPFDS16() { - PageSize = 65536; - } + int[] exceptbuffer = new int[2 * BLOCK_SIZE]; - @Override - public void compress(int[] in, IntWrapper inpos, int inlength, int[] out, - IntWrapper outpos) { - inlength = inlength / BlockSize * BlockSize; - if(inlength == 0) return; - final int finalinpos = inpos.get() + inlength; - out[outpos.get()] = inlength; - outpos.increment(); - while (inpos.get() != finalinpos) { - int thissize = finalinpos > PageSize + inpos.get() ? PageSize - : (finalinpos - inpos.get()); - encodePage(in, inpos, thissize, out, outpos); + /** + * Constructor for the NewPFDS16 CODEC. + */ + public NewPFDS16() { } - } + @Override + public void headlessCompress(int[] in, IntWrapper inpos, int inlength, + int[] out, IntWrapper outpos) { + inlength = Util.greatestMultiple(inlength, BLOCK_SIZE); + if (inlength == 0) + return; + encodePage(in, inpos, inlength, out, outpos); + } - protected static final int[] bits = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, - 12, 13, 16, 20, 32}; - protected static final int[] invbits = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, - 12, 13, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16, - 16, 16, 16, 16}; + private static final int[] bits = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 16, 20, 32 }; + private static final int[] invbits = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16 }; - protected static void getBestBFromData(int[] in, int pos, IntWrapper bestb, - IntWrapper bestexcept) { - final int mb = Util.maxbits(in, pos, BlockSize); - int mini = 0; - if (mini + 28 < bits[invbits[mb]]) - mini = bits[invbits[mb]] - 28; // 28 is the max for exceptions - int besti = bits.length - 1; - int exceptcounter = 0; - for (int i = mini; i < bits.length - 1; ++i) { - int tmpcounter = 0; - for (int k = pos; k < BlockSize + pos; ++k) - if ((in[k] >>> bits[i])!=0) - ++tmpcounter; - if (tmpcounter * 10 <= BlockSize) { - besti = i; - exceptcounter = tmpcounter; - break; - } + private static void getBestBFromData(int[] in, int pos, + IntWrapper bestb, IntWrapper bestexcept) { + final int mb = Util.maxbits(in, pos, BLOCK_SIZE); + int mini = 0; + if (mini + 28 < bits[invbits[mb]]) + mini = bits[invbits[mb]] - 28; // 28 is the max for + // exceptions + int besti = bits.length - 1; + int exceptcounter = 0; + for (int i = mini; i < bits.length - 1; ++i) { + int tmpcounter = 0; + for (int k = pos; k < BLOCK_SIZE + pos; ++k) + if ((in[k] >>> bits[i]) != 0) + ++tmpcounter; + if (tmpcounter * 10 <= BLOCK_SIZE) { + besti = i; + exceptcounter = tmpcounter; + break; + } + } + bestb.set(besti); + bestexcept.set(exceptcounter); } - bestb.set(besti); - bestexcept.set(exceptcounter); - } - private void encodePage(int[] in, IntWrapper inpos, int thissize, - int[] out, IntWrapper outpos) { - int tmpoutpos = outpos.get(); - int tmpinpos = inpos.get(); - IntWrapper bestb = new IntWrapper(); - IntWrapper bestexcept = new IntWrapper(); - for (final int finalinpos = tmpinpos + thissize; tmpinpos + BlockSize <= finalinpos; tmpinpos += BlockSize) { - getBestBFromData(in, tmpinpos, bestb, bestexcept); - final int tmpbestb = bestb.get(); - final int nbrexcept = bestexcept.get(); - int exceptsize = 0; - final int remember = tmpoutpos; - tmpoutpos++; - if (nbrexcept > 0) { - for (int i = 0, c = 0; i < BlockSize; ++i) { - if ((in[tmpinpos + i]>>> bits[tmpbestb])!= 0) { - exceptbuffer[c + nbrexcept] = i; - exceptbuffer[c] = in[tmpinpos + i] >>> bits[tmpbestb]; - ++c; - } + private void encodePage(int[] in, IntWrapper inpos, int thissize, + int[] out, IntWrapper outpos) { + int tmpoutpos = outpos.get(); + int tmpinpos = inpos.get(); + IntWrapper bestb = new IntWrapper(); + IntWrapper bestexcept = new IntWrapper(); + for (final int finalinpos = tmpinpos + thissize; tmpinpos + + BLOCK_SIZE <= finalinpos; tmpinpos += BLOCK_SIZE) { + getBestBFromData(in, tmpinpos, bestb, bestexcept); + final int tmpbestb = bestb.get(); + final int nbrexcept = bestexcept.get(); + int exceptsize = 0; + final int remember = tmpoutpos; + tmpoutpos++; + if (nbrexcept > 0) { + for (int i = 0, c = 0; i < BLOCK_SIZE; ++i) { + if ((in[tmpinpos + i] >>> bits[tmpbestb]) != 0) { + exceptbuffer[c + nbrexcept] = i; + exceptbuffer[c] = in[tmpinpos + + i] >>> bits[tmpbestb]; + ++c; + } + } + exceptsize = S16.compress(exceptbuffer, 0, + 2 * nbrexcept, out, tmpoutpos); + tmpoutpos += exceptsize; + } + out[remember] = tmpbestb | (nbrexcept << 8) + | (exceptsize << 16); + for (int k = 0; k < BLOCK_SIZE; k += 32) { + BitPacking.fastpack(in, tmpinpos + k, out, + tmpoutpos, bits[tmpbestb]); + tmpoutpos += bits[tmpbestb]; + } } - exceptsize = S16.compress(exceptbuffer, 0, 2 * nbrexcept, out, - tmpoutpos); - tmpoutpos += exceptsize; - } - out[remember] = tmpbestb | (nbrexcept << 8) | (exceptsize << 16); - for (int k = 0; k < BlockSize; k += 32) { - BitPacking.fastpack(in, tmpinpos + k, out, tmpoutpos, - bits[tmpbestb]); - tmpoutpos += bits[tmpbestb]; - } + inpos.set(tmpinpos); + outpos.set(tmpoutpos); } - inpos.set(tmpinpos); - outpos.set(tmpoutpos); - } - @Override - public void uncompress(int[] in, IntWrapper inpos, int inlength, int[] out, - IntWrapper outpos) { - if(inlength == 0) return; - final int mynvalue = in[inpos.get()]; - inpos.increment(); - int finalout = outpos.get() + mynvalue; - while (outpos.get() != finalout) { - int thissize = finalout > PageSize + outpos.get() ? PageSize - : (finalout - outpos.get()); - decodePage(in, inpos, out, outpos, thissize); + @Override + public void headlessUncompress(int[] in, IntWrapper inpos, int inlength, + int[] out, IntWrapper outpos, int mynvalue) { + if (inlength == 0) + return; + mynvalue = Util.greatestMultiple(mynvalue, BLOCK_SIZE); + decodePage(in, inpos, out, outpos, mynvalue); } - } - private void decodePage(int[] in, IntWrapper inpos, int[] out, - IntWrapper outpos, int thissize) { - int tmpoutpos = outpos.get(); - int tmpinpos = inpos.get(); + @Override + public int maxHeadlessCompressedLength(IntWrapper compressedPositions, int inlength) { + inlength = Util.greatestMultiple(inlength, BLOCK_SIZE); + int blockCount = inlength / BLOCK_SIZE; + // +1 for the header + // getBestBFromData limits the memory used for exceptions so that the total size of the block does not exceed BLOCK_SIZE integers. + int maxBlockSizeInInts = 1 + BLOCK_SIZE; + compressedPositions.add(inlength); + return maxBlockSizeInInts * blockCount; + } - for (int run = 0; run < thissize / BlockSize; ++run, tmpoutpos += BlockSize) { - final int b = in[tmpinpos] & 0xFF; - final int cexcept = (in[tmpinpos] >>> 8) & 0xFF; - final int exceptsize = (in[tmpinpos] >>> 16); - ++tmpinpos; - S16.uncompress(in, tmpinpos, exceptsize, exceptbuffer, 0, - 2 * cexcept); - tmpinpos += exceptsize; - for (int k = 0; k < BlockSize; k += 32) { - BitPacking - .fastunpack(in, tmpinpos, out, tmpoutpos + k, bits[b]); - tmpinpos += bits[b]; - } - for (int k = 0; k < cexcept; ++k) { - out[tmpoutpos + exceptbuffer[k + cexcept]] |= (exceptbuffer[k] << bits[b]); - } + private void decodePage(int[] in, IntWrapper inpos, int[] out, + IntWrapper outpos, int thissize) { + int tmpoutpos = outpos.get(); + int tmpinpos = inpos.get(); + + for (int run = 0; run < thissize / BLOCK_SIZE; ++run, tmpoutpos += BLOCK_SIZE) { + final int b = in[tmpinpos] & 0xFF; + final int cexcept = (in[tmpinpos] >>> 8) & 0xFF; + final int exceptsize = (in[tmpinpos] >>> 16); + ++tmpinpos; + S16.uncompress(in, tmpinpos, exceptsize, exceptbuffer, + 0, 2 * cexcept); + tmpinpos += exceptsize; + for (int k = 0; k < BLOCK_SIZE; k += 32) { + BitPacking.fastunpack(in, tmpinpos, out, + tmpoutpos + k, bits[b]); + tmpinpos += bits[b]; + } + for (int k = 0; k < cexcept; ++k) { + out[tmpoutpos + exceptbuffer[k + cexcept]] |= (exceptbuffer[k] << bits[b]); + } + } + outpos.set(tmpoutpos); + inpos.set(tmpinpos); + } + @Override + public void compress(int[] in, IntWrapper inpos, int inlength, int[] out, + IntWrapper outpos) { + inlength = Util.greatestMultiple(inlength, BLOCK_SIZE); + if (inlength == 0) + return; + out[outpos.get()] = inlength; + outpos.increment(); + headlessCompress(in, inpos, inlength, out, outpos); } - outpos.set(tmpoutpos); - inpos.set(tmpinpos); - } - @Override - public String toString() { - return this.getClass().getSimpleName(); - } + @Override + public void uncompress(int[] in, IntWrapper inpos, int inlength, int[] out, + IntWrapper outpos) { + if (inlength == 0) + return; + final int outlength = in[inpos.get()]; + inpos.increment(); + headlessUncompress(in, inpos, inlength, out, outpos, outlength); + } + @Override + public String toString() { + return this.getClass().getSimpleName(); + } } diff --git a/src/main/java/me/lemire/integercompression/NewPFDS9.java b/src/main/java/me/lemire/integercompression/NewPFDS9.java index 5465d27..bd802b6 100644 --- a/src/main/java/me/lemire/integercompression/NewPFDS9.java +++ b/src/main/java/me/lemire/integercompression/NewPFDS9.java @@ -7,155 +7,188 @@ package me.lemire.integercompression; + /** - * NewPFD/NewPFOR implemented by Daniel Lemire - *

+ * NewPFD/NewPFOR based on Simple9 by Yan et al. + *

* Follows: - *

+ *

* H. Yan, S. Ding, T. Suel, Inverted index compression and query processing * with optimized document ordering, in: WWW 09, 2009, pp. 401-410. - *

+ *

* using Simple9 as the secondary coder. - * + * + * It encodes integers in blocks of 128 integers. For arrays containing + * an arbitrary number of integers, you should use it in conjunction + * with another CODEC: + * + *
IntegerCODEC ic = new Composition(new PDFS9(), new VariableByte()).
+ * + * Note that this does not use differential coding: if you are working on sorted + * lists, you must compute the deltas separately. + * + * For multi-threaded applications, each thread should use its own NewPFDS9 + * object. + * * @author Daniel Lemire */ -public final class NewPFDS9 implements IntegerCODEC { - final int PageSize; - final static int BlockSize = 128; - - int[] exceptbuffer = new int[2 * BlockSize]; +public final class NewPFDS9 implements IntegerCODEC,SkippableIntegerCODEC { + final static int BLOCK_SIZE = 128; - /** - * Constructor for the NewPFDS9 CODEC. - */ - public NewPFDS9() { - PageSize = 65536; - } + int[] exceptbuffer = new int[2 * BLOCK_SIZE]; - @Override - public void compress(int[] in, IntWrapper inpos, int inlength, int[] out, - IntWrapper outpos) { - inlength = inlength / BlockSize * BlockSize; - if(inlength == 0) return; - final int finalinpos = inpos.get() + inlength; - out[outpos.get()] = inlength; - outpos.increment(); - while (inpos.get() != finalinpos) { - int thissize = finalinpos > PageSize + inpos.get() ? PageSize - : (finalinpos - inpos.get()); - encodePage(in, inpos, thissize, out, outpos); + /** + * Constructor for the NewPFDS9 CODEC. + */ + public NewPFDS9() { } - } + @Override + public void headlessCompress(int[] in, IntWrapper inpos, int inlength, + int[] out, IntWrapper outpos) { + inlength = Util.greatestMultiple(inlength, BLOCK_SIZE); + if (inlength == 0) + return; + encodePage(in, inpos, inlength, out, outpos); + } - protected static final int[] bits = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, - 12, 13, 16, 20, 32}; - protected static final int[] invbits = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, - 12, 13, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16, - 16, 16, 16, 16}; + private static final int[] bits = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 16, 20, 32 }; + private static final int[] invbits = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16 }; - protected static void getBestBFromData(int[] in, int pos, IntWrapper bestb, - IntWrapper bestexcept) { - final int mb = Util.maxbits(in, pos, BlockSize); - int mini = 0; - if (mini + 28 < bits[invbits[mb]]) - mini = bits[invbits[mb]] - 28; // 28 is the max for exceptions - int besti = bits.length - 1; - int exceptcounter = 0; - for (int i = mini; i < bits.length - 1; ++i) { - int tmpcounter = 0; - for (int k = pos; k < BlockSize + pos; ++k) - if ((in[k] >>> bits[i])!=0) - ++tmpcounter; - if (tmpcounter * 10 <= BlockSize) { - besti = i; - exceptcounter = tmpcounter; - break; - } + private static void getBestBFromData(int[] in, int pos, + IntWrapper bestb, IntWrapper bestexcept) { + final int mb = Util.maxbits(in, pos, BLOCK_SIZE); + int mini = 0; + if (mini + 28 < bits[invbits[mb]]) + mini = bits[invbits[mb]] - 28; // 28 is the max for + // exceptions + int besti = bits.length - 1; + int exceptcounter = 0; + for (int i = mini; i < bits.length - 1; ++i) { + int tmpcounter = 0; + for (int k = pos; k < BLOCK_SIZE + pos; ++k) + if ((in[k] >>> bits[i]) != 0) + ++tmpcounter; + if (tmpcounter * 10 <= BLOCK_SIZE) { + besti = i; + exceptcounter = tmpcounter; + break; + } + } + bestb.set(besti); + bestexcept.set(exceptcounter); } - bestb.set(besti); - bestexcept.set(exceptcounter); - } - private void encodePage(int[] in, IntWrapper inpos, int thissize, - int[] out, IntWrapper outpos) { - int tmpoutpos = outpos.get(); - int tmpinpos = inpos.get(); - IntWrapper bestb = new IntWrapper(); - IntWrapper bestexcept = new IntWrapper(); - for (final int finalinpos = tmpinpos + thissize; tmpinpos + BlockSize <= finalinpos; tmpinpos += BlockSize) { - getBestBFromData(in, tmpinpos, bestb, bestexcept); - final int tmpbestb = bestb.get(); - final int nbrexcept = bestexcept.get(); - int exceptsize = 0; - final int remember = tmpoutpos; - tmpoutpos++; - if (nbrexcept > 0) { - for (int i = 0, c = 0; i < BlockSize; ++i) { - if ((in[tmpinpos + i]>>> bits[tmpbestb])!= 0) { - exceptbuffer[c + nbrexcept] = i; - exceptbuffer[c] = in[tmpinpos + i] >>> bits[tmpbestb]; - ++c; - } + private void encodePage(int[] in, IntWrapper inpos, int thissize, + int[] out, IntWrapper outpos) { + int tmpoutpos = outpos.get(); + int tmpinpos = inpos.get(); + IntWrapper bestb = new IntWrapper(); + IntWrapper bestexcept = new IntWrapper(); + for (final int finalinpos = tmpinpos + thissize; tmpinpos + + BLOCK_SIZE <= finalinpos; tmpinpos += BLOCK_SIZE) { + getBestBFromData(in, tmpinpos, bestb, bestexcept); + final int tmpbestb = bestb.get(); + final int nbrexcept = bestexcept.get(); + int exceptsize = 0; + final int remember = tmpoutpos; + tmpoutpos++; + if (nbrexcept > 0) { + for (int i = 0, c = 0; i < BLOCK_SIZE; ++i) { + if ((in[tmpinpos + i] >>> bits[tmpbestb]) != 0) { + exceptbuffer[c + nbrexcept] = i; + exceptbuffer[c] = in[tmpinpos + + i] >>> bits[tmpbestb]; + ++c; + } + } + exceptsize = S9.compress(exceptbuffer, 0, + 2 * nbrexcept, out, tmpoutpos); + tmpoutpos += exceptsize; + } + out[remember] = tmpbestb | (nbrexcept << 8) + | (exceptsize << 16); + for (int k = 0; k < BLOCK_SIZE; k += 32) { + BitPacking.fastpack(in, tmpinpos + k, out, + tmpoutpos, bits[tmpbestb]); + tmpoutpos += bits[tmpbestb]; + } } - exceptsize = S9.compress(exceptbuffer, 0, 2 * nbrexcept, out, - tmpoutpos); - tmpoutpos += exceptsize; - } - out[remember] = tmpbestb | (nbrexcept << 8) | (exceptsize << 16); - for (int k = 0; k < BlockSize; k += 32) { - BitPacking.fastpack(in, tmpinpos + k, out, tmpoutpos, - bits[tmpbestb]); - tmpoutpos += bits[tmpbestb]; - } + inpos.set(tmpinpos); + outpos.set(tmpoutpos); } - inpos.set(tmpinpos); - outpos.set(tmpoutpos); - } - @Override - public void uncompress(int[] in, IntWrapper inpos, int inlength, int[] out, - IntWrapper outpos) { - if(inlength == 0) return; - final int mynvalue = in[inpos.get()]; - inpos.increment(); - int finalout = outpos.get() + mynvalue; - while (outpos.get() != finalout) { - int thissize = finalout > PageSize + outpos.get() ? PageSize - : (finalout - outpos.get()); - decodePage(in, inpos, out, outpos, thissize); + @Override + public void headlessUncompress(int[] in, IntWrapper inpos, int inlength, + int[] out, IntWrapper outpos, int mynvalue) { + if (inlength == 0) + return; + mynvalue = Util.greatestMultiple(mynvalue, BLOCK_SIZE); + decodePage(in, inpos, out, outpos, mynvalue); } - } - private void decodePage(int[] in, IntWrapper inpos, int[] out, - IntWrapper outpos, int thissize) { - int tmpoutpos = outpos.get(); - int tmpinpos = inpos.get(); + @Override + public int maxHeadlessCompressedLength(IntWrapper compressedPositions, int inlength) { + inlength = Util.greatestMultiple(inlength, BLOCK_SIZE); + int blockCount = inlength / BLOCK_SIZE; + // +1 for the header + // getBestBFromData limits the memory used for exceptions so that the total size of the block does not exceed BLOCK_SIZE integers. + int maxBlockSizeInInts = 1 + BLOCK_SIZE; + compressedPositions.add(inlength); + return maxBlockSizeInInts * blockCount; + } - for (int run = 0; run < thissize / BlockSize; ++run, tmpoutpos += BlockSize) { - final int b = in[tmpinpos] & 0xFF; - final int cexcept = (in[tmpinpos] >>> 8) & 0xFF; - final int exceptsize = (in[tmpinpos] >>> 16); - ++tmpinpos; - S9.uncompress(in, tmpinpos, exceptsize, exceptbuffer, 0, - 2 * cexcept); - tmpinpos += exceptsize; - for (int k = 0; k < BlockSize; k += 32) { - BitPacking - .fastunpack(in, tmpinpos, out, tmpoutpos + k, bits[b]); - tmpinpos += bits[b]; - } - for (int k = 0; k < cexcept; ++k) { - out[tmpoutpos + exceptbuffer[k + cexcept]] |= (exceptbuffer[k] << bits[b]); - } + private void decodePage(int[] in, IntWrapper inpos, int[] out, + IntWrapper outpos, int thissize) { + int tmpoutpos = outpos.get(); + int tmpinpos = inpos.get(); + + for (int run = 0; run < thissize / BLOCK_SIZE; ++run, tmpoutpos += BLOCK_SIZE) { + final int b = in[tmpinpos] & 0xFF; + final int cexcept = (in[tmpinpos] >>> 8) & 0xFF; + final int exceptsize = (in[tmpinpos] >>> 16); + ++tmpinpos; + S9.uncompress(in, tmpinpos, exceptsize, exceptbuffer, + 0, 2 * cexcept); + tmpinpos += exceptsize; + for (int k = 0; k < BLOCK_SIZE; k += 32) { + BitPacking.fastunpack(in, tmpinpos, out, + tmpoutpos + k, bits[b]); + tmpinpos += bits[b]; + } + for (int k = 0; k < cexcept; ++k) { + out[tmpoutpos + exceptbuffer[k + cexcept]] |= (exceptbuffer[k] << bits[b]); + } + } + outpos.set(tmpoutpos); + inpos.set(tmpinpos); + } + @Override + public void compress(int[] in, IntWrapper inpos, int inlength, int[] out, + IntWrapper outpos) { + inlength = Util.greatestMultiple(inlength, BLOCK_SIZE); + if (inlength == 0) + return; + out[outpos.get()] = inlength; + outpos.increment(); + headlessCompress(in, inpos, inlength, out, outpos); } - outpos.set(tmpoutpos); - inpos.set(tmpinpos); - } - @Override - public String toString() { - return this.getClass().getSimpleName(); - } + @Override + public void uncompress(int[] in, IntWrapper inpos, int inlength, int[] out, + IntWrapper outpos) { + if (inlength == 0) + return; + final int outlength = in[inpos.get()]; + inpos.increment(); + headlessUncompress(in, inpos, inlength, out, outpos, outlength); + } + @Override + public String toString() { + return this.getClass().getSimpleName(); + } } diff --git a/src/main/java/me/lemire/integercompression/OptPFD.java b/src/main/java/me/lemire/integercompression/OptPFD.java index 6696bf7..cfda92e 100644 --- a/src/main/java/me/lemire/integercompression/OptPFD.java +++ b/src/main/java/me/lemire/integercompression/OptPFD.java @@ -6,171 +6,206 @@ */ package me.lemire.integercompression; + /** - * OptPFD implemented by Daniel Lemire - *

+ * OptPFD: fast patching scheme by Yan et al. + *

* Follows: - *

+ *

* H. Yan, S. Ding, T. Suel, Inverted index compression and query processing - * with optimized document ordering, in: WWW �09, 2009, pp. 401�410. - *

+ * with optimized document ordering, in: WWW 09, 2009, pp. 401-410. + *

* using Simple16 as the secondary coder. - * + * + * It encodes integers in blocks of 128 integers. For arrays containing + * an arbitrary number of integers, you should use it in conjunction + * with another CODEC: + * + *
IntegerCODEC ic = new Composition(new OptPFD(), new VariableByte()).
+ * + * Note that this does not use differential coding: if you are working on sorted + * lists, you must compute the deltas separately. (Yes, this is true even though + * the "D" at the end of the name probably stands for delta.) + * + * For multi-threaded applications, each thread should use its own OptPFD + * object. + * * @author Daniel Lemire */ -public final class OptPFD implements IntegerCODEC { - final int PageSize; - final static int BlockSize = 128; - - int[] exceptbuffer = new int[2 * BlockSize]; - int[] sillybuffer = new int[2 * BlockSize]; +public final class OptPFD implements IntegerCODEC,SkippableIntegerCODEC { + final static int BLOCK_SIZE = 128; - /** - * Constructor for the OptPFD CODEC. - */ - public OptPFD() { - PageSize = 65536; - } + int[] exceptbuffer = new int[2 * BLOCK_SIZE]; + + /** + * Constructor for the OptPFD CODEC. + */ + public OptPFD() { + } - @Override - public void compress(int[] in, IntWrapper inpos, int inlength, int[] out, - IntWrapper outpos) { - inlength = inlength / BlockSize * BlockSize; - if(inlength == 0) return; - final int finalinpos = inpos.get() + inlength; - out[outpos.get()] = inlength; - outpos.increment(); - while (inpos.get() != finalinpos) { - int thissize = finalinpos > PageSize + inpos.get() ? PageSize - : (finalinpos - inpos.get()); - encodePage(in, inpos, thissize, out, outpos); + @Override + public void headlessCompress(int[] in, IntWrapper inpos, int inlength, + int[] out, IntWrapper outpos) { + inlength = Util.greatestMultiple(inlength, BLOCK_SIZE); + if (inlength == 0) + return; + encodePage(in, inpos, inlength, out, outpos); } - } + private static final int[] bits = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 16, 20, 32 }; + private static final int[] invbits = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16 }; - protected static final int[] bits = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, - 12, 13, 16, 20, 32}; - protected static final int[] invbits = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, - 12, 13, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16, - 16, 16, 16, 16}; + private void getBestBFromData(int[] in, int pos, IntWrapper bestb, + IntWrapper bestexcept) { + final int mb = Util.maxbits(in, pos, BLOCK_SIZE); + int mini = 0; + if (mini + 28 < bits[invbits[mb]]) + mini = bits[invbits[mb]] - 28; // 28 is the max for + // exceptions + int besti = bits.length - 1; + int bestcost = bits[besti] * 4; + int exceptcounter = 0; + for (int i = mini; i < bits.length - 1; ++i) { + int tmpcounter = 0; + for (int k = pos; k < BLOCK_SIZE + pos; ++k) + if ((in[k] >>> bits[i]) != 0) { + ++tmpcounter; + } + if (tmpcounter == BLOCK_SIZE) + continue; // no need + for (int k = pos, c = 0; k < pos + BLOCK_SIZE; ++k) + if ((in[k] >>> bits[i]) != 0) { + exceptbuffer[tmpcounter + c] = k - pos; + exceptbuffer[c] = in[k] >>> bits[i]; + ++c; + } - void getBestBFromData(int[] in, int pos, IntWrapper bestb, - IntWrapper bestexcept) { - final int mb = Util.maxbits(in, pos, BlockSize); - int mini = 0; - if (mini + 28 < bits[invbits[mb]]) - mini = bits[invbits[mb]] - 28; // 28 is the max for exceptions - int besti = bits.length - 1; - int bestcost = bits[besti] * 4; - int exceptcounter = 0; - for (int i = mini; i < bits.length - 1; ++i) { - int tmpcounter = 0; - for (int k = pos; k < BlockSize + pos; ++k) - if ((in[k] >>> bits[i])!=0) { - ++tmpcounter; - } - if (tmpcounter == BlockSize) - continue; // no need - for (int k = pos, c = 0; k < pos + BlockSize; ++k) - if ((in[k] >>> bits[i])!=0) { - exceptbuffer[tmpcounter + c] = k - pos; - exceptbuffer[c] = in[k] >>> bits[i]; - ++c; + final int thiscost = bits[i] + * 4 + + S16.estimatecompress(exceptbuffer, 0, + 2 * tmpcounter); + if (thiscost <= bestcost) { + bestcost = thiscost; + besti = i; + exceptcounter = tmpcounter; + } } - final int thiscost = bits[i] * 4 - + S16.estimatecompress(exceptbuffer, 0, 2 * tmpcounter); - if (thiscost <= bestcost) { - bestcost = thiscost; - besti = i; - exceptcounter = tmpcounter; - } + bestb.set(besti); + bestexcept.set(exceptcounter); } - bestb.set(besti); - bestexcept.set(exceptcounter); - } - - private void encodePage(int[] in, IntWrapper inpos, int thissize, - int[] out, IntWrapper outpos) { - int tmpoutpos = outpos.get(); - int tmpinpos = inpos.get(); - IntWrapper bestb = new IntWrapper(); - IntWrapper bestexcept = new IntWrapper(); - for (final int finalinpos = tmpinpos + thissize; tmpinpos + BlockSize <= finalinpos; tmpinpos += BlockSize) { - getBestBFromData(in, tmpinpos, bestb, bestexcept); - final int tmpbestb = bestb.get(); - final int nbrexcept = bestexcept.get(); - int exceptsize = 0; - final int remember = tmpoutpos; - tmpoutpos++; - if (nbrexcept > 0) { - int c = 0; - for (int i = 0; i < BlockSize; ++i) { - if ((in[tmpinpos + i] >>> bits[tmpbestb])!=0) { - exceptbuffer[c + nbrexcept] = i; - exceptbuffer[c] = in[tmpinpos + i] >>> bits[tmpbestb]; - ++c; - } + private void encodePage(int[] in, IntWrapper inpos, int thissize, + int[] out, IntWrapper outpos) { + int tmpoutpos = outpos.get(); + int tmpinpos = inpos.get(); + IntWrapper bestb = new IntWrapper(); + IntWrapper bestexcept = new IntWrapper(); + for (final int finalinpos = tmpinpos + thissize; tmpinpos + + BLOCK_SIZE <= finalinpos; tmpinpos += BLOCK_SIZE) { + getBestBFromData(in, tmpinpos, bestb, bestexcept); + final int tmpbestb = bestb.get(); + final int nbrexcept = bestexcept.get(); + int exceptsize = 0; + final int remember = tmpoutpos; + tmpoutpos++; + if (nbrexcept > 0) { + int c = 0; + for (int i = 0; i < BLOCK_SIZE; ++i) { + if ((in[tmpinpos + i] >>> bits[tmpbestb]) != 0) { + exceptbuffer[c + nbrexcept] = i; + exceptbuffer[c] = in[tmpinpos + + i] >>> bits[tmpbestb]; + ++c; + } + } + exceptsize = S16.compress(exceptbuffer, 0, + 2 * nbrexcept, out, tmpoutpos); + tmpoutpos += exceptsize; + } + out[remember] = tmpbestb | (nbrexcept << 8) + | (exceptsize << 16); + for (int k = 0; k < BLOCK_SIZE; k += 32) { + BitPacking.fastpack(in, tmpinpos + k, out, + tmpoutpos, bits[tmpbestb]); + tmpoutpos += bits[tmpbestb]; + } } - exceptsize = S16.compress(exceptbuffer, 0, 2 * nbrexcept, out, - tmpoutpos); - tmpoutpos += exceptsize; - } - out[remember] = tmpbestb | (nbrexcept << 8) | (exceptsize << 16); - for (int k = 0; k < BlockSize; k += 32) { - BitPacking.fastpack(in, tmpinpos + k, out, tmpoutpos, - bits[tmpbestb]); - tmpoutpos += bits[tmpbestb]; - } + inpos.set(tmpinpos); + outpos.set(tmpoutpos); } - inpos.set(tmpinpos); - outpos.set(tmpoutpos); - } - @Override - public void uncompress(int[] in, IntWrapper inpos, int inlength, int[] out, - IntWrapper outpos) { - if(inlength == 0) return; - final int mynvalue = in[inpos.get()]; - inpos.increment(); - final int finalout = outpos.get() + mynvalue; - while (outpos.get() != finalout) { - int thissize = finalout > PageSize + outpos.get() ? PageSize - : (finalout - outpos.get()); - decodePage(in, inpos, out, outpos, thissize); + @Override + public void headlessUncompress(int[] in, IntWrapper inpos, int inlength, + int[] out, IntWrapper outpos, int mynvalue) { + if (inlength == 0) + return; + mynvalue = Util.greatestMultiple(mynvalue, BLOCK_SIZE); + decodePage(in, inpos, out, outpos, mynvalue); } - } - private void decodePage(int[] in, IntWrapper inpos, int[] out, - IntWrapper outpos, int thissize) { - int tmpoutpos = outpos.get(); - int tmpinpos = inpos.get(); + @Override + public int maxHeadlessCompressedLength(IntWrapper compressedPositions, int inlength) { + inlength = Util.greatestMultiple(inlength, BLOCK_SIZE); + int blockCount = inlength / BLOCK_SIZE; + // +1 for the header + // getBestBFromData limits the memory used for exceptions so that the total size of the block does not exceed BLOCK_SIZE integers. + int maxBlockSizeInInts = 1 + BLOCK_SIZE; + compressedPositions.add(inlength); + return maxBlockSizeInInts * blockCount; + } + + private void decodePage(int[] in, IntWrapper inpos, int[] out, + IntWrapper outpos, int thissize) { + int tmpoutpos = outpos.get(); + int tmpinpos = inpos.get(); - for (int run = 0; run < thissize / BlockSize; ++run, tmpoutpos += BlockSize) { - final int b = in[tmpinpos] & 0xFF; - final int cexcept = (in[tmpinpos] >>> 8) & 0xFF; - final int exceptsize = (in[tmpinpos] >>> 16); - ++tmpinpos; - S16.uncompress(in, tmpinpos, exceptsize, exceptbuffer, 0, - 2 * cexcept); - tmpinpos += exceptsize; - for (int k = 0; k < BlockSize; k += 32) { - BitPacking - .fastunpack(in, tmpinpos, out, tmpoutpos + k, bits[b]); - tmpinpos += bits[b]; - } - for (int k = 0; k < cexcept; ++k) { - out[tmpoutpos + exceptbuffer[k + cexcept]] |= (exceptbuffer[k] << bits[b]); - } + for (int run = 0; run < thissize / BLOCK_SIZE; ++run, tmpoutpos += BLOCK_SIZE) { + final int b = in[tmpinpos] & 0xFF; + final int cexcept = (in[tmpinpos] >>> 8) & 0xFF; + final int exceptsize = (in[tmpinpos] >>> 16); + ++tmpinpos; + S16.uncompress(in, tmpinpos, exceptsize, exceptbuffer, + 0, 2 * cexcept); + tmpinpos += exceptsize; + for (int k = 0; k < BLOCK_SIZE; k += 32) { + BitPacking.fastunpack(in, tmpinpos, out, + tmpoutpos + k, bits[b]); + tmpinpos += bits[b]; + } + for (int k = 0; k < cexcept; ++k) { + out[tmpoutpos + exceptbuffer[k + cexcept]] |= (exceptbuffer[k] << bits[b]); + } + } + outpos.set(tmpoutpos); + inpos.set(tmpinpos); + } + @Override + public void compress(int[] in, IntWrapper inpos, int inlength, int[] out, + IntWrapper outpos) { + inlength = inlength / BLOCK_SIZE * BLOCK_SIZE; + if (inlength == 0) + return; + out[outpos.get()] = inlength; + outpos.increment(); + headlessCompress(in, inpos, inlength, out, outpos); } - outpos.set(tmpoutpos); - inpos.set(tmpinpos); - } - @Override - public String toString() { - return this.getClass().getSimpleName(); - } + @Override + public void uncompress(int[] in, IntWrapper inpos, int inlength, int[] out, + IntWrapper outpos) { + if (inlength == 0) + return; + final int outlength = in[inpos.get()]; + inpos.increment(); + headlessUncompress(in, inpos, inlength, out, outpos, outlength); + } + @Override + public String toString() { + return this.getClass().getSimpleName(); + } } diff --git a/src/main/java/me/lemire/integercompression/OptPFDS16.java b/src/main/java/me/lemire/integercompression/OptPFDS16.java index 4580f4b..95c4f62 100644 --- a/src/main/java/me/lemire/integercompression/OptPFDS16.java +++ b/src/main/java/me/lemire/integercompression/OptPFDS16.java @@ -7,169 +7,205 @@ package me.lemire.integercompression; + /** - * OptPFD implemented by Daniel Lemire - *

+ * OptPFD based on Simple16 by Yan et al. + *

* Follows: - *

+ *

* H. Yan, S. Ding, T. Suel, Inverted index compression and query processing - * with optimized document ordering, in: WWW 09, 2009, pp. 401--410. - *

+ * with optimized document ordering, in: WWW 09, 2009, pp. 401-410. + *

* using Simple16 as the secondary coder. - * + * + * It encodes integers in blocks of 128 integers. For arrays containing + * an arbitrary number of integers, you should use it in conjunction + * with another CODEC: + * + *
IntegerCODEC ic = new Composition(new OptPFDS16(), new VariableByte()).
+ * + * Note that this does not use differential coding: if you are working on sorted + * lists, you must compute the deltas separately. + * + * For multi-threaded applications, each thread should use its own OptPFDS16 + * object. + * * @author Daniel Lemire */ -public final class OptPFDS16 implements IntegerCODEC { - final int PageSize; - final static int BlockSize = 128; - int[] exceptbuffer = new int[2 * BlockSize]; - - /** - * Constructor for the OptPFDS16 CODEC. - */ - public OptPFDS16() { - PageSize = 65536; - } - - @Override - public void compress(int[] in, IntWrapper inpos, int inlength, int[] out, - IntWrapper outpos) { - inlength = inlength / BlockSize * BlockSize; - if(inlength == 0) return; - - final int finalinpos = inpos.get() + inlength; - out[outpos.get()] = inlength; - outpos.increment(); - while (inpos.get() != finalinpos) { - int thissize = finalinpos > PageSize + inpos.get() ? PageSize - : (finalinpos - inpos.get()); - encodePage(in, inpos, thissize, out, outpos); +public final class OptPFDS16 implements IntegerCODEC,SkippableIntegerCODEC { + final static int BLOCK_SIZE = 128; + int[] exceptbuffer = new int[2 * BLOCK_SIZE]; + + /** + * Constructor for the OptPFDS16 CODEC. + */ + public OptPFDS16() { + } + + @Override + public void headlessCompress(int[] in, IntWrapper inpos, int inlength, + int[] out, IntWrapper outpos) { + inlength = Util.greatestMultiple(inlength, BLOCK_SIZE); + if (inlength == 0) + return; + + encodePage(in, inpos, inlength, out, outpos); + } - } - - protected static final int[] bits = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, - 12, 13, 16, 20, 32}; - protected static final int[] invbits = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, - 12, 13, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16, - 16, 16, 16, 16}; - - protected void getBestBFromData(int[] in, int pos, IntWrapper bestb, - IntWrapper bestexcept) { - final int mb = Util.maxbits(in, pos, BlockSize); - int mini = 0; - if (mini + 28 < bits[invbits[mb]]) - mini = bits[invbits[mb]] - 28; // 28 is the max for exceptions - int besti = bits.length - 1; - int bestcost = bits[besti] * 4; - int exceptcounter = 0; - for (int i = mini; i < bits.length - 1; ++i) { - int tmpcounter = 0; - for (int k = pos; k < BlockSize + pos; ++k) - if ((in[k] >>> bits[i]) !=0) { - ++tmpcounter; + private static final int[] bits = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 16, 20, 32 }; + private static final int[] invbits = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16 }; + + private void getBestBFromData(int[] in, int pos, IntWrapper bestb, + IntWrapper bestexcept) { + final int mb = Util.maxbits(in, pos, BLOCK_SIZE); + int mini = 0; + if (mini + 28 < bits[invbits[mb]]) + mini = bits[invbits[mb]] - 28; // 28 is the max for + // exceptions + int besti = bits.length - 1; + int bestcost = bits[besti] * 4; + int exceptcounter = 0; + for (int i = mini; i < bits.length - 1; ++i) { + int tmpcounter = 0; + for (int k = pos; k < BLOCK_SIZE + pos; ++k) + if ((in[k] >>> bits[i]) != 0) { + ++tmpcounter; + } + if (tmpcounter == BLOCK_SIZE) + continue; // no need + for (int k = pos, c = 0; k < pos + BLOCK_SIZE; ++k) + if ((in[k] >>> bits[i]) != 0) { + exceptbuffer[tmpcounter + c] = k - pos; + exceptbuffer[c] = in[k] >>> bits[i]; + ++c; + } + + final int thiscost = bits[i] + * 4 + + S16.estimatecompress(exceptbuffer, 0, + 2 * tmpcounter); + if (thiscost <= bestcost) { + bestcost = thiscost; + besti = i; + exceptcounter = tmpcounter; + } } - if (tmpcounter == BlockSize) - continue; // no need - for (int k = pos, c = 0; k < pos + BlockSize; ++k) - if ((in[k] >>> bits[i]) !=0) { - exceptbuffer[tmpcounter + c] = k - pos; - exceptbuffer[c] = in[k] >>> bits[i]; - ++c; + bestb.set(besti); + bestexcept.set(exceptcounter); + } + + private void encodePage(int[] in, IntWrapper inpos, int thissize, + int[] out, IntWrapper outpos) { + int tmpoutpos = outpos.get(); + int tmpinpos = inpos.get(); + IntWrapper bestb = new IntWrapper(); + IntWrapper bestexcept = new IntWrapper(); + for (final int finalinpos = tmpinpos + thissize; tmpinpos + + BLOCK_SIZE <= finalinpos; tmpinpos += BLOCK_SIZE) { + getBestBFromData(in, tmpinpos, bestb, bestexcept); + final int tmpbestb = bestb.get(); + final int nbrexcept = bestexcept.get(); + int exceptsize = 0; + final int remember = tmpoutpos; + tmpoutpos++; + if (nbrexcept > 0) { + int c = 0; + for (int i = 0; i < BLOCK_SIZE; ++i) { + if ((in[tmpinpos + i] >>> bits[tmpbestb]) != 0) { + exceptbuffer[c + nbrexcept] = i; + exceptbuffer[c] = in[tmpinpos + + i] >>> bits[tmpbestb]; + ++c; + } + } + exceptsize = S16.compress(exceptbuffer, 0, + 2 * nbrexcept, out, tmpoutpos); + tmpoutpos += exceptsize; + } + out[remember] = tmpbestb | (nbrexcept << 8) + | (exceptsize << 16); + for (int k = 0; k < BLOCK_SIZE; k += 32) { + BitPacking.fastpack(in, tmpinpos + k, out, + tmpoutpos, bits[tmpbestb]); + tmpoutpos += bits[tmpbestb]; + } } + inpos.set(tmpinpos); + outpos.set(tmpoutpos); + } - final int thiscost = bits[i] * 4 - + S16.estimatecompress(exceptbuffer, 0, 2 * tmpcounter); - if (thiscost <= bestcost) { - bestcost = thiscost; - besti = i; - exceptcounter = tmpcounter; - } + @Override + public void headlessUncompress(int[] in, IntWrapper inpos, int inlength, + int[] out, IntWrapper outpos, int mynvalue) { + if (inlength == 0) + return; + mynvalue = Util.greatestMultiple(mynvalue, BLOCK_SIZE); + decodePage(in, inpos, out, outpos, mynvalue); } - bestb.set(besti); - bestexcept.set(exceptcounter); - } - - private void encodePage(int[] in, IntWrapper inpos, int thissize, - int[] out, IntWrapper outpos) { - int tmpoutpos = outpos.get(); - int tmpinpos = inpos.get(); - IntWrapper bestb = new IntWrapper(); - IntWrapper bestexcept = new IntWrapper(); - for (final int finalinpos = tmpinpos + thissize; tmpinpos + BlockSize <= finalinpos; tmpinpos += BlockSize) { - getBestBFromData(in, tmpinpos, bestb, bestexcept); - final int tmpbestb = bestb.get(); - final int nbrexcept = bestexcept.get(); - int exceptsize = 0; - final int remember = tmpoutpos; - tmpoutpos++; - if (nbrexcept > 0) { - int c = 0; - for (int i = 0; i < BlockSize; ++i) { - if ((in[tmpinpos + i] >>> bits[tmpbestb]) != 0) { - exceptbuffer[c + nbrexcept] = i; - exceptbuffer[c] = in[tmpinpos + i] >>> bits[tmpbestb]; - ++c; - } - } - exceptsize = S16.compress(exceptbuffer, 0, 2 * nbrexcept, out, - tmpoutpos); - tmpoutpos += exceptsize; - } - out[remember] = tmpbestb | (nbrexcept << 8) | (exceptsize << 16); - for (int k = 0; k < BlockSize; k += 32) { - BitPacking.fastpack(in, tmpinpos + k, out, tmpoutpos, - bits[tmpbestb]); - tmpoutpos += bits[tmpbestb]; - } + + @Override + public int maxHeadlessCompressedLength(IntWrapper compressedPositions, int inlength) { + inlength = Util.greatestMultiple(inlength, BLOCK_SIZE); + int blockCount = inlength / BLOCK_SIZE; + // +1 for the header + // getBestBFromData limits the memory used for exceptions so that the total size of the block does not exceed BLOCK_SIZE integers. + int maxBlockSizeInInts = 1 + BLOCK_SIZE; + compressedPositions.add(inlength); + return maxBlockSizeInInts * blockCount; } - inpos.set(tmpinpos); - outpos.set(tmpoutpos); - } - - @Override - public void uncompress(int[] in, IntWrapper inpos, int inlength, int[] out, - IntWrapper outpos) { - if(inlength == 0) return; - final int mynvalue = in[inpos.get()]; - inpos.increment(); - final int finalout = outpos.get() + mynvalue; - while (outpos.get() != finalout) { - int thissize = finalout > PageSize + outpos.get() ? PageSize - : (finalout - outpos.get()); - decodePage(in, inpos, out, outpos, thissize); + + private void decodePage(int[] in, IntWrapper inpos, int[] out, + IntWrapper outpos, int thissize) { + int tmpoutpos = outpos.get(); + int tmpinpos = inpos.get(); + + for (int run = 0; run < thissize / BLOCK_SIZE; ++run, tmpoutpos += BLOCK_SIZE) { + final int b = in[tmpinpos] & 0xFF; + final int cexcept = (in[tmpinpos] >>> 8) & 0xFF; + final int exceptsize = (in[tmpinpos] >>> 16); + ++tmpinpos; + S16.uncompress(in, tmpinpos, exceptsize, exceptbuffer, + 0, 2 * cexcept); + tmpinpos += exceptsize; + for (int k = 0; k < BLOCK_SIZE; k += 32) { + BitPacking.fastunpack(in, tmpinpos, out, + tmpoutpos + k, bits[b]); + tmpinpos += bits[b]; + } + for (int k = 0; k < cexcept; ++k) { + out[tmpoutpos + exceptbuffer[k + cexcept]] |= (exceptbuffer[k] << bits[b]); + } + } + outpos.set(tmpoutpos); + inpos.set(tmpinpos); } - } - - private void decodePage(int[] in, IntWrapper inpos, int[] out, - IntWrapper outpos, int thissize) { - int tmpoutpos = outpos.get(); - int tmpinpos = inpos.get(); - - for (int run = 0; run < thissize / BlockSize; ++run, tmpoutpos += BlockSize) { - final int b = in[tmpinpos] & 0xFF; - final int cexcept = (in[tmpinpos] >>> 8) & 0xFF; - final int exceptsize = (in[tmpinpos] >>> 16); - ++tmpinpos; - S16.uncompress(in, tmpinpos, exceptsize, exceptbuffer, 0, - 2 * cexcept); - tmpinpos += exceptsize; - for (int k = 0; k < BlockSize; k += 32) { - BitPacking - .fastunpack(in, tmpinpos, out, tmpoutpos + k, bits[b]); - tmpinpos += bits[b]; - } - for (int k = 0; k < cexcept; ++k) { - out[tmpoutpos + exceptbuffer[k + cexcept]] |= (exceptbuffer[k] << bits[b]); - } + @Override + public void compress(int[] in, IntWrapper inpos, int inlength, int[] out, + IntWrapper outpos) { + inlength = inlength / BLOCK_SIZE * BLOCK_SIZE; + if (inlength == 0) + return; + out[outpos.get()] = inlength; + outpos.increment(); + headlessCompress(in, inpos, inlength, out, outpos); } - outpos.set(tmpoutpos); - inpos.set(tmpinpos); - } - @Override - public String toString() { - return this.getClass().getSimpleName(); - } + @Override + public void uncompress(int[] in, IntWrapper inpos, int inlength, int[] out, + IntWrapper outpos) { + if (inlength == 0) + return; + final int outlength = in[inpos.get()]; + inpos.increment(); + headlessUncompress(in, inpos, inlength, out, outpos, outlength); + } + @Override + public String toString() { + return this.getClass().getSimpleName(); + } -} \ No newline at end of file +} diff --git a/src/main/java/me/lemire/integercompression/OptPFDS9.java b/src/main/java/me/lemire/integercompression/OptPFDS9.java index 22faf7e..0e2563b 100644 --- a/src/main/java/me/lemire/integercompression/OptPFDS9.java +++ b/src/main/java/me/lemire/integercompression/OptPFDS9.java @@ -7,169 +7,205 @@ package me.lemire.integercompression; + /** - * OptPFD implemented by Daniel Lemire - *

+ * OptPFD based on Simple9 by Yan et al. + *

* Follows: - *

+ *

* H. Yan, S. Ding, T. Suel, Inverted index compression and query processing - * with optimized document ordering, in: WWW 09, 2009, pp. 401--410. - *

+ * with optimized document ordering, in: WWW 09, 2009, pp. 401-410. + *

* using Simple9 as the secondary coder. - * + * + * It encodes integers in blocks of 128 integers. For arrays containing + * an arbitrary number of integers, you should use it in conjunction + * with another CODEC: + * + *
 IntegerCODEC ic = new Composition(new OptPFDS9(), new VariableByte()).
+ * + * Note that this does not use differential coding: if you are working on sorted + * lists, you must compute the deltas separately. + * + * For multi-threaded applications, each thread should use its own OptPFDS9 + * object. + * * @author Daniel Lemire */ -public final class OptPFDS9 implements IntegerCODEC { - final int PageSize; - final static int BlockSize = 128; - int[] exceptbuffer = new int[2 * BlockSize]; - - /** - * Constructor for the OptPFDS9 CODEC. - */ - public OptPFDS9() { - PageSize = 65536; - } - - @Override - public void compress(int[] in, IntWrapper inpos, int inlength, int[] out, - IntWrapper outpos) { - inlength = inlength / BlockSize * BlockSize; - if(inlength == 0) return; - - final int finalinpos = inpos.get() + inlength; - out[outpos.get()] = inlength; - outpos.increment(); - while (inpos.get() != finalinpos) { - int thissize = finalinpos > PageSize + inpos.get() ? PageSize - : (finalinpos - inpos.get()); - encodePage(in, inpos, thissize, out, outpos); +public final class OptPFDS9 implements IntegerCODEC, SkippableIntegerCODEC { + final static int BLOCK_SIZE = 128; + int[] exceptbuffer = new int[2 * BLOCK_SIZE]; + + /** + * Constructor for the OptPFDS9 CODEC. + */ + public OptPFDS9() { } - } - - protected static final int[] bits = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, - 12, 13, 16, 20, 32}; - protected static final int[] invbits = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, - 12, 13, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16, - 16, 16, 16, 16}; - - protected void getBestBFromData(int[] in, int pos, IntWrapper bestb, - IntWrapper bestexcept) { - final int mb = Util.maxbits(in, pos, BlockSize); - int mini = 0; - if (mini + 28 < bits[invbits[mb]]) - mini = bits[invbits[mb]] - 28; // 28 is the max for exceptions - int besti = bits.length - 1; - int bestcost = bits[besti] * 4; - int exceptcounter = 0; - for (int i = mini; i < bits.length - 1; ++i) { - int tmpcounter = 0; - for (int k = pos; k < BlockSize + pos; ++k) - if ((in[k] >>> bits[i]) !=0) { - ++tmpcounter; + @Override + public void headlessCompress(int[] in, IntWrapper inpos, int inlength, + int[] out, IntWrapper outpos) { + inlength = Util.greatestMultiple(inlength, BLOCK_SIZE); + if (inlength == 0) + return; + encodePage(in, inpos, inlength, out, outpos); + + } + + private static final int[] bits = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 16, 20, 32 }; + private static final int[] invbits = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16 }; + + private void getBestBFromData(int[] in, int pos, IntWrapper bestb, + IntWrapper bestexcept) { + final int mb = Util.maxbits(in, pos, BLOCK_SIZE); + int mini = 0; + if (mini + 28 < bits[invbits[mb]]) + mini = bits[invbits[mb]] - 28; // 28 is the max for + // exceptions + int besti = bits.length - 1; + int bestcost = bits[besti] * 4; + int exceptcounter = 0; + for (int i = mini; i < bits.length - 1; ++i) { + int tmpcounter = 0; + for (int k = pos; k < BLOCK_SIZE + pos; ++k) + if ((in[k] >>> bits[i]) != 0) { + ++tmpcounter; + } + if (tmpcounter == BLOCK_SIZE) + continue; // no need + for (int k = pos, c = 0; k < pos + BLOCK_SIZE; ++k) + if ((in[k] >>> bits[i]) != 0) { + exceptbuffer[tmpcounter + c] = k - pos; + exceptbuffer[c] = in[k] >>> bits[i]; + ++c; + } + + final int thiscost = bits[i] + * 4 + + S9.estimatecompress(exceptbuffer, 0, + 2 * tmpcounter); + if (thiscost <= bestcost) { + bestcost = thiscost; + besti = i; + exceptcounter = tmpcounter; + } } - if (tmpcounter == BlockSize) - continue; // no need - for (int k = pos, c = 0; k < pos + BlockSize; ++k) - if ((in[k] >>> bits[i]) !=0) { - exceptbuffer[tmpcounter + c] = k - pos; - exceptbuffer[c] = in[k] >>> bits[i]; - ++c; + bestb.set(besti); + bestexcept.set(exceptcounter); + } + + private void encodePage(int[] in, IntWrapper inpos, int thissize, + int[] out, IntWrapper outpos) { + int tmpoutpos = outpos.get(); + int tmpinpos = inpos.get(); + IntWrapper bestb = new IntWrapper(); + IntWrapper bestexcept = new IntWrapper(); + for (final int finalinpos = tmpinpos + thissize; tmpinpos + + BLOCK_SIZE <= finalinpos; tmpinpos += BLOCK_SIZE) { + getBestBFromData(in, tmpinpos, bestb, bestexcept); + final int tmpbestb = bestb.get(); + final int nbrexcept = bestexcept.get(); + int exceptsize = 0; + final int remember = tmpoutpos; + tmpoutpos++; + if (nbrexcept > 0) { + int c = 0; + for (int i = 0; i < BLOCK_SIZE; ++i) { + if ((in[tmpinpos + i] >>> bits[tmpbestb]) != 0) { + exceptbuffer[c + nbrexcept] = i; + exceptbuffer[c] = in[tmpinpos + + i] >>> bits[tmpbestb]; + ++c; + } + } + exceptsize = S9.compress(exceptbuffer, 0, + 2 * nbrexcept, out, tmpoutpos); + tmpoutpos += exceptsize; + } + out[remember] = tmpbestb | (nbrexcept << 8) + | (exceptsize << 16); + for (int k = 0; k < BLOCK_SIZE; k += 32) { + BitPacking.fastpack(in, tmpinpos + k, out, + tmpoutpos, bits[tmpbestb]); + tmpoutpos += bits[tmpbestb]; + } } + inpos.set(tmpinpos); + outpos.set(tmpoutpos); + } - final int thiscost = bits[i] * 4 - + S9.estimatecompress(exceptbuffer, 0, 2 * tmpcounter); - if (thiscost <= bestcost) { - bestcost = thiscost; - besti = i; - exceptcounter = tmpcounter; - } + @Override + public void headlessUncompress(int[] in, IntWrapper inpos, int inlength, + int[] out, IntWrapper outpos, int mynvalue) { + if (inlength == 0) + return; + mynvalue = Util.greatestMultiple(mynvalue, BLOCK_SIZE); + decodePage(in, inpos, out, outpos, mynvalue); } - bestb.set(besti); - bestexcept.set(exceptcounter); - } - - private void encodePage(int[] in, IntWrapper inpos, int thissize, - int[] out, IntWrapper outpos) { - int tmpoutpos = outpos.get(); - int tmpinpos = inpos.get(); - IntWrapper bestb = new IntWrapper(); - IntWrapper bestexcept = new IntWrapper(); - for (final int finalinpos = tmpinpos + thissize; tmpinpos + BlockSize <= finalinpos; tmpinpos += BlockSize) { - getBestBFromData(in, tmpinpos, bestb, bestexcept); - final int tmpbestb = bestb.get(); - final int nbrexcept = bestexcept.get(); - int exceptsize = 0; - final int remember = tmpoutpos; - tmpoutpos++; - if (nbrexcept > 0) { - int c = 0; - for (int i = 0; i < BlockSize; ++i) { - if ((in[tmpinpos + i] >>> bits[tmpbestb]) != 0) { - exceptbuffer[c + nbrexcept] = i; - exceptbuffer[c] = in[tmpinpos + i] >>> bits[tmpbestb]; - ++c; - } - } - exceptsize = S9.compress(exceptbuffer, 0, 2 * nbrexcept, out, - tmpoutpos); - tmpoutpos += exceptsize; - } - out[remember] = tmpbestb | (nbrexcept << 8) | (exceptsize << 16); - for (int k = 0; k < BlockSize; k += 32) { - BitPacking.fastpack(in, tmpinpos + k, out, tmpoutpos, - bits[tmpbestb]); - tmpoutpos += bits[tmpbestb]; - } + + @Override + public int maxHeadlessCompressedLength(IntWrapper compressedPositions, int inlength) { + inlength = Util.greatestMultiple(inlength, BLOCK_SIZE); + int blockCount = inlength / BLOCK_SIZE; + // +1 for the header + // getBestBFromData limits the memory used for exceptions so that the total size of the block does not exceed BLOCK_SIZE integers. + int maxBlockSizeInInts = 1 + BLOCK_SIZE; + compressedPositions.add(inlength); + return maxBlockSizeInInts * blockCount; } - inpos.set(tmpinpos); - outpos.set(tmpoutpos); - } - - @Override - public void uncompress(int[] in, IntWrapper inpos, int inlength, int[] out, - IntWrapper outpos) { - if(inlength == 0) return; - final int mynvalue = in[inpos.get()]; - inpos.increment(); - final int finalout = outpos.get() + mynvalue; - while (outpos.get() != finalout) { - int thissize = finalout > PageSize + outpos.get() ? PageSize - : (finalout - outpos.get()); - decodePage(in, inpos, out, outpos, thissize); + + private void decodePage(int[] in, IntWrapper inpos, int[] out, + IntWrapper outpos, int thissize) { + int tmpoutpos = outpos.get(); + int tmpinpos = inpos.get(); + + for (int run = 0; run < thissize / BLOCK_SIZE; ++run, tmpoutpos += BLOCK_SIZE) { + final int b = in[tmpinpos] & 0xFF; + final int cexcept = (in[tmpinpos] >>> 8) & 0xFF; + final int exceptsize = (in[tmpinpos] >>> 16); + ++tmpinpos; + S9.uncompress(in, tmpinpos, exceptsize, exceptbuffer, + 0, 2 * cexcept); + tmpinpos += exceptsize; + for (int k = 0; k < BLOCK_SIZE; k += 32) { + BitPacking.fastunpack(in, tmpinpos, out, + tmpoutpos + k, bits[b]); + tmpinpos += bits[b]; + } + for (int k = 0; k < cexcept; ++k) { + out[tmpoutpos + exceptbuffer[k + cexcept]] |= (exceptbuffer[k] << bits[b]); + } + } + outpos.set(tmpoutpos); + inpos.set(tmpinpos); } - } - - private void decodePage(int[] in, IntWrapper inpos, int[] out, - IntWrapper outpos, int thissize) { - int tmpoutpos = outpos.get(); - int tmpinpos = inpos.get(); - - for (int run = 0; run < thissize / BlockSize; ++run, tmpoutpos += BlockSize) { - final int b = in[tmpinpos] & 0xFF; - final int cexcept = (in[tmpinpos] >>> 8) & 0xFF; - final int exceptsize = (in[tmpinpos] >>> 16); - ++tmpinpos; - S9.uncompress(in, tmpinpos, exceptsize, exceptbuffer, 0, - 2 * cexcept); - tmpinpos += exceptsize; - for (int k = 0; k < BlockSize; k += 32) { - BitPacking - .fastunpack(in, tmpinpos, out, tmpoutpos + k, bits[b]); - tmpinpos += bits[b]; - } - for (int k = 0; k < cexcept; ++k) { - out[tmpoutpos + exceptbuffer[k + cexcept]] |= (exceptbuffer[k] << bits[b]); - } + @Override + public void compress(int[] in, IntWrapper inpos, int inlength, int[] out, + IntWrapper outpos) { + inlength = inlength / BLOCK_SIZE * BLOCK_SIZE; + if (inlength == 0) + return; + out[outpos.get()] = inlength; + outpos.increment(); + headlessCompress(in, inpos, inlength, out, outpos); } - outpos.set(tmpoutpos); - inpos.set(tmpinpos); - } - @Override - public String toString() { - return this.getClass().getSimpleName(); - } + @Override + public void uncompress(int[] in, IntWrapper inpos, int inlength, int[] out, + IntWrapper outpos) { + if (inlength == 0) + return; + final int outlength = in[inpos.get()]; + inpos.increment(); + headlessUncompress(in, inpos, inlength, out, outpos, outlength); + } + + @Override + public String toString() { + return this.getClass().getSimpleName(); + } -} \ No newline at end of file +} diff --git a/src/main/java/me/lemire/integercompression/S16.java b/src/main/java/me/lemire/integercompression/S16.java index 8b51cf1..e40522d 100644 --- a/src/main/java/me/lemire/integercompression/S16.java +++ b/src/main/java/me/lemire/integercompression/S16.java @@ -9,19 +9,33 @@ /** * Version of Simple16 for NewPFD and OptPFD. - *

+ *

* Adapted by D. Lemire from the Apache Lucene project. + *

*/ public final class S16 { - - protected static int compress(final int[] in, int currentPos, int inlength, - final int out[], final int tmpoutpos) { + /** + * Compress an integer array using Simple16 + * + * + * @param in + * array to compress + * @param currentPos + * where to start reading + * @param inlength + * how many integers to read + * @param out + * output array + * @param tmpoutpos + * location in the output array + * @return the number of 32-bit words written (in compressed form) + */ + public static int compress(final int[] in, int currentPos, int inlength, final int out[], final int tmpoutpos) { int outpos = tmpoutpos; final int finalin = currentPos + inlength; while (currentPos < finalin) { - int inoffset = compressblock(out, outpos++, in, currentPos, - inlength); + int inoffset = compressblock(out, outpos++, in, currentPos, inlength); if (inoffset == -1) throw new RuntimeException("Too big a number"); currentPos += inoffset; @@ -29,14 +43,18 @@ protected static int compress(final int[] in, int currentPos, int inlength, } return outpos - tmpoutpos; } + /** - * Estimate size of the compressed output. - * - * @param in array to compress - * @param currentPos where to start reading - * @param inlength how many integers to read - * @return estimated size of the output (in 32-bit integers) - */ + * Estimate size of the compressed output. + * + * @param in + * array to compress + * @param currentPos + * where to start reading + * @param inlength + * how many integers to read + * @return estimated size of the output (in 32-bit integers) + */ public static int estimatecompress(final int[] in, int currentPos, int inlength) { final int finalin = currentPos + inlength; int counter = 0; @@ -53,24 +71,27 @@ public static int estimatecompress(final int[] in, int currentPos, int inlength) /** * Compress an integer array using Simple16 - * - * @param out the compressed output - * @param outOffset the offset of the output in the number of integers - * @param in the integer input array - * @param inOffset the offset of the input in the number of integers - * @param n the number of elements to be compressed + * + * @param out + * the compressed output + * @param outOffset + * the offset of the output in the number of integers + * @param in + * the integer input array + * @param inOffset + * the offset of the input in the number of integers + * @param n + * the number of elements to be compressed * @return the size of the outputs in 32-bit integers - * + * */ - public static final int compressblock(int[] out, int outOffset, int[] in, - int inOffset, int n) { + public static final int compressblock(int[] out, int outOffset, int[] in, int inOffset, int n) { int numIdx, j, num, bits; for (numIdx = 0; numIdx < S16_NUMSIZE; numIdx++) { out[outOffset] = numIdx << S16_BITSSIZE; num = (S16_NUM[numIdx] < n) ? S16_NUM[numIdx] : n; - for (j = 0, bits = 0; (j < num) - && (in[inOffset + j] < SHIFTED_S16_BITS[numIdx][j]); ) { + for (j = 0, bits = 0; (j < num) && (in[inOffset + j] < SHIFTED_S16_BITS[numIdx][j]);) { out[outOffset] |= (in[inOffset + j] << bits); bits += S16_BITS[numIdx][j]; j++; @@ -89,8 +110,7 @@ private static final int fakecompressblock(int[] in, int inOffset, int n) { for (numIdx = 0; numIdx < S16_NUMSIZE; numIdx++) { num = (S16_NUM[numIdx] < n) ? S16_NUM[numIdx] : n; - for (j = 0; (j < num) - && (in[inOffset + j] < SHIFTED_S16_BITS[numIdx][j]); ) { + for (j = 0; (j < num) && (in[inOffset + j] < SHIFTED_S16_BITS[numIdx][j]);) { j++; } @@ -104,33 +124,51 @@ private static final int fakecompressblock(int[] in, int inOffset, int n) { /** * Decompress an integer array using Simple16 - * - * @param out the decompressed output - * @param outOffset the offset of the output in the number of integers - * @param in the compressed input array - * @param inOffset the offset of the input in the number of integers - * @param n the number of elements to be compressed + * + * @param out + * the decompressed output + * @param outOffset + * the offset of the output in the number of integers + * @param in + * the compressed input array + * @param inOffset + * the offset of the input in the number of integers + * @param n + * the number of elements to be compressed * @return the number of processed integers */ - public static final int decompressblock(int[] out, int outOffset, int[] in, - int inOffset, int n) { + public static final int decompressblock(int[] out, int outOffset, int[] in, int inOffset, int n) { int numIdx, j = 0, bits = 0; numIdx = in[inOffset] >>> S16_BITSSIZE; int num = S16_NUM[numIdx] < n ? S16_NUM[numIdx] : n; for (j = 0, bits = 0; j < num; j++) { - out[outOffset + j] = (in[inOffset] >>> bits) - & (0xffffffff >>> (32 - S16_BITS[numIdx][j])); + out[outOffset + j] = (in[inOffset] >>> bits) & (0xffffffff >>> (32 - S16_BITS[numIdx][j])); bits += S16_BITS[numIdx][j]; } return num; } - protected static void uncompress(final int[] in, int tmpinpos, final int inlength, - final int[] out, int currentPos, int outlength) { + /** + * Uncompressed data from an input array into an output array + * + * @param in + * input array (in compressed form) + * @param tmpinpos + * starting location in the compressed input array + * @param inlength + * how much data we wish the read (in 32-bit words) + * @param out + * output array (in decompressed form) + * @param currentPos + * current position in the output array + * @param outlength + * available data in the output array + */ + public static void uncompress(final int[] in, int tmpinpos, final int inlength, final int[] out, int currentPos, + int outlength) { final int finalpos = tmpinpos + inlength; while (tmpinpos < finalpos) { - final int howmany = decompressblock(out, currentPos, in, tmpinpos, - outlength); + final int howmany = decompressblock(out, currentPos, in, tmpinpos, outlength); outlength -= howmany; currentPos += howmany; tmpinpos += 1; @@ -151,20 +189,17 @@ private static int[][] shiftme(int[][] x) { private static final int S16_NUMSIZE = 16; private static final int S16_BITSSIZE = 28; // the possible number of bits used to represent one integer - private static final int[] S16_NUM = {28, 21, 21, 21, 14, 9, 8, 7, 6, 6, - 5, 5, 4, 3, 2, 1}; - // the corresponding number of elements for each value of the number of bits + private static final int[] S16_NUM = { 28, 21, 21, 21, 14, 9, 8, 7, 6, 6, 5, 5, 4, 3, 2, 1 }; + // the corresponding number of elements for each value of the number of + // bits private static final int[][] S16_BITS = { - {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1}, - {2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}, - {1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1}, - {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2}, - {2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2}, - {4, 3, 3, 3, 3, 3, 3, 3, 3}, {3, 4, 4, 4, 4, 3, 3, 3}, - {4, 4, 4, 4, 4, 4, 4}, {5, 5, 5, 5, 4, 4}, - {4, 4, 5, 5, 5, 5}, {6, 6, 6, 5, 5}, {5, 5, 6, 6, 6}, - {7, 7, 7, 7}, {10, 9, 9,}, {14, 14}, {28}}; + { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, + { 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, + { 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1 }, + { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2 }, + { 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 }, { 4, 3, 3, 3, 3, 3, 3, 3, 3 }, { 3, 4, 4, 4, 4, 3, 3, 3 }, + { 4, 4, 4, 4, 4, 4, 4 }, { 5, 5, 5, 5, 4, 4 }, { 4, 4, 5, 5, 5, 5 }, { 6, 6, 6, 5, 5 }, { 5, 5, 6, 6, 6 }, + { 7, 7, 7, 7 }, { 10, 9, 9, }, { 14, 14 }, { 28 } }; private static final int[][] SHIFTED_S16_BITS = shiftme(S16_BITS); } diff --git a/src/main/java/me/lemire/integercompression/S9.java b/src/main/java/me/lemire/integercompression/S9.java index 72fc062..7e03e42 100644 --- a/src/main/java/me/lemire/integercompression/S9.java +++ b/src/main/java/me/lemire/integercompression/S9.java @@ -8,25 +8,31 @@ /** * This is a version of Simple9 optimized for NewPFOR, OptPFOR - * + *

+ * Adapted by D. Lemire from the Apache Lucene project. + *

+ * * @author Daniel Lemire */ public final class S9 { - /** - * Estimate size of the compressed output. - * - * @param in array to compress - * @param currentPos where to start reading - * @param inlength how many integers to read - * @return estimated size of the output (in 32-bit integers) - */ + + + /** + * Estimate size of the compressed output. + * + * @param in + * array to compress + * @param currentPos + * where to start reading + * @param inlength + * how many integers to read + * @return estimated size of the output (in 32-bit integers) + */ public static int estimatecompress(int[] in, int currentPos, int inlength) { int tmpoutpos = 0; int finalpos = currentPos + inlength; - outer: - while (currentPos < finalpos) { - mainloop: - for (int selector = 0; selector < 8; selector++) { + outer: while (currentPos < finalpos) { + mainloop: for (int selector = 0; selector < 8; selector++) { int compressedNum = codeNum[selector]; if (finalpos <= currentPos + compressedNum - 1) @@ -35,7 +41,7 @@ public static int estimatecompress(int[] in, int currentPos, int inlength) { int max = 1 << b; int i = 0; for (; i < compressedNum; i++) - if (max <= in[currentPos + i]) + if (Util.smallerorequalthan(max , in[currentPos + i])) continue mainloop; currentPos += compressedNum; ++tmpoutpos; @@ -51,14 +57,27 @@ public static int estimatecompress(int[] in, int currentPos, int inlength) { return tmpoutpos; } - protected static int compress(int[] in, int currentPos, int inlength, int out[], - int tmpoutpos) { + /** + * Compress an integer array using Simple9 + * + * + * @param in + * array to compress + * @param currentPos + * where to start reading + * @param inlength + * how many integers to read + * @param out + * output array + * @param tmpoutpos + * location in the output array + * @return the number of 32-bit words written (in compressed form) + */ + public static int compress(int[] in, int currentPos, int inlength, int out[], int tmpoutpos) { int origtmpoutpos = tmpoutpos; int finalpos = currentPos + inlength; - outer: - while (currentPos < finalpos) { - mainloop: - for (int selector = 0; selector < 8; selector++) { + outer: while (currentPos < finalpos) { + mainloop: for (int selector = 0; selector < 8; selector++) { int res = 0; int compressedNum = codeNum[selector]; if (finalpos <= currentPos + compressedNum - 1) @@ -67,7 +86,7 @@ protected static int compress(int[] in, int currentPos, int inlength, int out[], int max = 1 << b; int i = 0; for (; i < compressedNum; i++) { - if (max <= in[currentPos + i]) + if (Util.smallerorequalthan(max, in[currentPos + i])) continue mainloop; res = (res << b) + in[currentPos + i]; } @@ -86,93 +105,99 @@ protected static int compress(int[] in, int currentPos, int inlength, int out[], return tmpoutpos - origtmpoutpos; } - protected static void uncompress(int[] in, int tmpinpos, int inlength, - int[] out, int currentPos, int outlength) { + /** + * Uncompressed data from an input array into an output array + * + * @param in + * input array (in compressed form) + * @param tmpinpos + * starting location in the compressed input array + * @param inlength + * how much data we wish the read (in 32-bit words) + * @param out + * output array (in decompressed form) + * @param currentPos + * current position in the output array + * @param outlength + * available data in the output array + */ + public static void uncompress(int[] in, int tmpinpos, int inlength, int[] out, int currentPos, int outlength) { int finallength = currentPos + outlength; while (currentPos < finallength) { int val = in[tmpinpos++]; int header = val >>> 28; switch (header) { - case 0: { // number : 28, bitwidth : 1 - final int howmany = finallength - currentPos < 28 ? finallength - - currentPos : 28; - for (int k = 0; k < howmany; ++k) { - out[currentPos++] = (val << (k + 4)) >>> 31; - } - break; - } - case 1: { // number : 14, bitwidth : 2 - final int howmany = finallength - currentPos < 14 ? finallength - - currentPos : 14; - for (int k = 0; k < howmany; ++k) { - out[currentPos++] = (val << (2 * k + 4)) >>> 30; - } - break; + case 0: { // number : 28, bitwidth : 1 + final int howmany = finallength - currentPos < 28 ? finallength - currentPos : 28; + for (int k = 0; k < howmany; ++k) { + out[currentPos++] = (val << (k + 4)) >>> 31; } - case 2: { // number : 9, bitwidth : 3 - final int howmany = finallength - currentPos < 9 ? finallength - - currentPos : 9; - for (int k = 0; k < howmany; ++k) { - out[currentPos++] = (val << (3 * k + 5)) >>> 29; - } - break; - } - case 3: { // number : 7, bitwidth : 4 - final int howmany = finallength - currentPos < 7 ? finallength - - currentPos : 7; - for (int k = 0; k < howmany; ++k) { - out[currentPos++] = (val << (4 * k + 4)) >>> 28; - } - break; + break; + } + case 1: { // number : 14, bitwidth : 2 + final int howmany = finallength - currentPos < 14 ? finallength - currentPos : 14; + for (int k = 0; k < howmany; ++k) { + out[currentPos++] = (val << (2 * k + 4)) >>> 30; } - case 4: { // number : 5, bitwidth : 5 - final int howmany = finallength - currentPos < 5 ? finallength - - currentPos : 5; - for (int k = 0; k < howmany; ++k) { - out[currentPos++] = (val << (5 * k + 7)) >>> 27; - } - break; + break; + } + case 2: { // number : 9, bitwidth : 3 + final int howmany = finallength - currentPos < 9 ? finallength - currentPos : 9; + for (int k = 0; k < howmany; ++k) { + out[currentPos++] = (val << (3 * k + 5)) >>> 29; } - case 5: { // number : 4, bitwidth : 7 - final int howmany = finallength - currentPos < 4 ? finallength - - currentPos : 4; - for (int k = 0; k < howmany; ++k) { - out[currentPos++] = (val << (7 * k + 4)) >>> 25; - } - break; + break; + } + case 3: { // number : 7, bitwidth : 4 + final int howmany = finallength - currentPos < 7 ? finallength - currentPos : 7; + for (int k = 0; k < howmany; ++k) { + out[currentPos++] = (val << (4 * k + 4)) >>> 28; } - case 6: { // number : 3, bitwidth : 9 - final int howmany = finallength - currentPos < 3 ? finallength - - currentPos : 3; - for (int k = 0; k < howmany; ++k) { - out[currentPos++] = (val << (9 * k + 5)) >>> 23; - } - break; + break; + } + case 4: { // number : 5, bitwidth : 5 + final int howmany = finallength - currentPos < 5 ? finallength - currentPos : 5; + for (int k = 0; k < howmany; ++k) { + out[currentPos++] = (val << (5 * k + 7)) >>> 27; } - case 7: { // number : 2, bitwidth : 14 - final int howmany = finallength - currentPos < 2 ? finallength - - currentPos : 2; - for (int k = 0; k < howmany; ++k) { - out[currentPos++] = (val << (14 * k + 4)) >>> 18; - } - break; + break; + } + case 5: { // number : 4, bitwidth : 7 + final int howmany = finallength - currentPos < 4 ? finallength - currentPos : 4; + for (int k = 0; k < howmany; ++k) { + out[currentPos++] = (val << (7 * k + 4)) >>> 25; } - case 8: { // number : 1, bitwidth : 28 - out[currentPos++] = (val << 4) >>> 4; - break; + break; + } + case 6: { // number : 3, bitwidth : 9 + final int howmany = finallength - currentPos < 3 ? finallength - currentPos : 3; + for (int k = 0; k < howmany; ++k) { + out[currentPos++] = (val << (9 * k + 5)) >>> 23; } - default: { - throw new RuntimeException("shouldn't happen"); + break; + } + case 7: { // number : 2, bitwidth : 14 + final int howmany = finallength - currentPos < 2 ? finallength - currentPos : 2; + for (int k = 0; k < howmany; ++k) { + out[currentPos++] = (val << (14 * k + 4)) >>> 18; } + break; + } + case 8: { // number : 1, bitwidth : 28 + out[currentPos++] = (val << 4) >>> 4; + break; + } + default: { + throw new RuntimeException("shouldn't happen"); + } } } } - private final static int bitLength[] = {1, 2, 3, 4, 5, 7, 9, 14, 28}; - - private final static int codeNum[] = {28, 14, 9, 7, 5, 4, 3, 2, 1}; + private final static int bitLength[] = { 1, 2, 3, 4, 5, 7, 9, 14, 28 }; + private final static int codeNum[] = { 28, 14, 9, 7, 5, 4, 3, 2, 1 }; } diff --git a/src/main/java/me/lemire/integercompression/Simple16.java b/src/main/java/me/lemire/integercompression/Simple16.java new file mode 100644 index 0000000..2b7f27f --- /dev/null +++ b/src/main/java/me/lemire/integercompression/Simple16.java @@ -0,0 +1,191 @@ +package me.lemire.integercompression; + +/** + * This is an implementation of the popular Simple16 scheme. It is limited to + * 28-bit integers (between 0 and 2^28-1). + * + * Note that this does not use differential coding: if you are working on sorted + * lists, you must compute the deltas separately. + * + *

+ * Adapted by D. Lemire from the Apache Lucene project. + *

+ */ +public final class Simple16 implements IntegerCODEC, SkippableIntegerCODEC { + + public void headlessCompress(int[] in, IntWrapper inpos, int inlength, int out[], IntWrapper outpos) { + int i_inpos = inpos.get(); + int i_outpos = outpos.get(); + final int finalin = i_inpos + inlength; + while (i_inpos < finalin) { + int inoffset = compressblock(out, i_outpos++, in, i_inpos, inlength); + if (inoffset == -1) + throw new RuntimeException("Too big a number"); + i_inpos += inoffset; + inlength -= inoffset; + } + inpos.set(i_inpos); + outpos.set(i_outpos); + } + + /** + * Compress an integer array using Simple16 + * + * @param out + * the compressed output + * @param outOffset + * the offset of the output in the number of integers + * @param in + * the integer input array + * @param inOffset + * the offset of the input in the number of integers + * @param n + * the number of elements to be compressed + * @return the number of compressed integers + */ + public static final int compressblock(int[] out, int outOffset, int[] in, int inOffset, int n) { + int numIdx, j, num, bits; + for (numIdx = 0; numIdx < S16_NUMSIZE; numIdx++) { + out[outOffset] = numIdx << S16_BITSSIZE; + num = (S16_NUM[numIdx] < n) ? S16_NUM[numIdx] : n; + + for (j = 0, bits = 0; (j < num) && (in[inOffset + j] < SHIFTED_S16_BITS[numIdx][j]);) { + out[outOffset] |= (in[inOffset + j] << bits); + bits += S16_BITS[numIdx][j]; + j++; + } + + if (j == num) { + return num; + } + } + + return -1; + } + + /** + * Decompress an integer array using Simple16 + * + * @param out + * the decompressed output + * @param outOffset + * the offset of the output in the number of integers + * @param in + * the compressed input array + * @param inOffset + * the offset of the input in the number of integers + * @param n + * the number of elements to be compressed + * @return the number of processed integers + */ + public static final int decompressblock(int[] out, int outOffset, int[] in, int inOffset, int n) { + int numIdx, j = 0, bits = 0; + numIdx = in[inOffset] >>> S16_BITSSIZE; + int num = S16_NUM[numIdx] < n ? S16_NUM[numIdx] : n; + for (j = 0, bits = 0; j < num; j++) { + out[outOffset + j] = (in[inOffset] >>> bits) & (0xffffffff >>> (32 - S16_BITS[numIdx][j])); + bits += S16_BITS[numIdx][j]; + } + return num; + } + + @Override + public void headlessUncompress(int[] in, IntWrapper inpos, int inlength, int[] out, IntWrapper outpos, int num) { + int i_inpos = inpos.get(); + int i_outpos = outpos.get(); + while (num > 0) { + final int howmany = decompressblock(out, i_outpos, in, i_inpos, num); + num -= howmany; + i_outpos += howmany; + i_inpos++; + } + inpos.set(i_inpos); + outpos.set(i_outpos); + } + + @Override + public int maxHeadlessCompressedLength(IntWrapper compressedPositions, int inlength) { + compressedPositions.add(inlength); + return inlength; + } + + /** + * Uncompress data from an array to another array. + * + * Both inpos and outpos parameters are modified to indicate new positions + * after read/write. + * + * @param in + * array containing data in compressed form + * @param tmpinpos + * where to start reading in the array + * @param inlength + * length of the compressed data (ignored by some schemes) + * @param out + * array where to write the compressed output + * @param currentPos + * where to write the compressed output in out + * @param outlength + * number of integers we want to decode + */ + public static void uncompress(int[] in, int tmpinpos, int inlength, int[] out, int currentPos, int outlength) { + final int finalpos = tmpinpos + inlength; + while (tmpinpos < finalpos) { + final int howmany = decompressblock(out, currentPos, in, tmpinpos, outlength); + outlength -= howmany; + currentPos += howmany; + tmpinpos += 1; + } + + } + + private static int[][] shiftme(int[][] x) { + int[][] answer = new int[x.length][]; + for (int k = 0; k < x.length; ++k) { + answer[k] = new int[x[k].length]; + for (int z = 0; z < answer[k].length; ++z) + answer[k][z] = 1 << x[k][z]; + } + return answer; + } + + @Override + public void compress(int[] in, IntWrapper inpos, int inlength, int[] out, IntWrapper outpos) { + if (inlength == 0) + return; + out[outpos.get()] = inlength; + outpos.increment(); + headlessCompress(in, inpos, inlength, out, outpos); + } + + @Override + public void uncompress(int[] in, IntWrapper inpos, int inlength, int[] out, IntWrapper outpos) { + if (inlength == 0) + return; + final int outlength = in[inpos.get()]; + inpos.increment(); + headlessUncompress(in, inpos, inlength, out, outpos, outlength); + + } + + @Override + public String toString() { + return this.getClass().getSimpleName(); + } + + private static final int S16_NUMSIZE = 16; + private static final int S16_BITSSIZE = 28; + // the possible number of bits used to represent one integer + private static final int[] S16_NUM = { 28, 21, 21, 21, 14, 9, 8, 7, 6, 6, 5, 5, 4, 3, 2, 1 }; + // the corresponding number of elements for each value of the number of bits + private static final int[][] S16_BITS = { + { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, + { 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, + { 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1 }, + { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2 }, + { 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 }, { 4, 3, 3, 3, 3, 3, 3, 3, 3 }, { 3, 4, 4, 4, 4, 3, 3, 3 }, + { 4, 4, 4, 4, 4, 4, 4 }, { 5, 5, 5, 5, 4, 4 }, { 4, 4, 5, 5, 5, 5 }, { 6, 6, 6, 5, 5 }, { 5, 5, 6, 6, 6 }, + { 7, 7, 7, 7 }, { 10, 9, 9, }, { 14, 14 }, { 28 } }; + private static final int[][] SHIFTED_S16_BITS = shiftme(S16_BITS); + +} diff --git a/src/main/java/me/lemire/integercompression/Simple9.java b/src/main/java/me/lemire/integercompression/Simple9.java index 7b8136a..fd5194d 100644 --- a/src/main/java/me/lemire/integercompression/Simple9.java +++ b/src/main/java/me/lemire/integercompression/Simple9.java @@ -7,23 +7,26 @@ package me.lemire.integercompression; - /** + * This is an implementation of the popular Simple9 scheme. It is limited to + * 28-bit integers (between 0 and 2^28-1). + * + * Note that this does not use differential coding: if you are working on sorted + * lists, you must compute the deltas separately. + * * @author Daniel Lemire - * + * */ -public final class Simple9 implements IntegerCODEC { +public final class Simple9 implements IntegerCODEC, SkippableIntegerCODEC { + + @Override - public void compress(int[] in, IntWrapper inpos, int inlength, int out[], - IntWrapper outpos) { + public void headlessCompress(int[] in, IntWrapper inpos, int inlength, int out[], IntWrapper outpos) { int tmpoutpos = outpos.get(); int currentPos = inpos.get(); - out[tmpoutpos++] = inlength; final int finalin = currentPos + inlength; - outer: - while (currentPos < finalin - 28) { - mainloop: - for (int selector = 0; selector < 8; selector++) { + outer: while (currentPos < finalin - 28) { + mainloop: for (int selector = 0; selector < 8; selector++) { int res = 0; int compressedNum = codeNum[selector]; @@ -45,10 +48,8 @@ public void compress(int[] in, IntWrapper inpos, int inlength, int out[], throw new RuntimeException("Too big a number"); out[tmpoutpos++] = in[currentPos++] | (selector << 28); } - outer: - while (currentPos < finalin) { - mainloop: - for (int selector = 0; selector < 8; selector++) { + outer: while (currentPos < finalin) { + mainloop: for (int selector = 0; selector < 8; selector++) { int res = 0; int compressedNum = codeNum[selector]; if (finalin <= currentPos + compressedNum - 1) @@ -79,194 +80,187 @@ public void compress(int[] in, IntWrapper inpos, int inlength, int out[], } @Override - public void uncompress(int[] in, IntWrapper inpos, int inlength, - int[] out, IntWrapper outpos) { + public void headlessUncompress(int[] in, IntWrapper inpos, int inlength, int[] out, IntWrapper outpos, + int outlength) { int currentPos = outpos.get(); int tmpinpos = inpos.get(); - final int finalout = currentPos + in[tmpinpos++]; + final int finalout = currentPos + outlength; while (currentPos < finalout - 28) { int val = in[tmpinpos++]; int header = val >>> 28; switch (header) { - case 0: { // number : 28, bitwidth : 1 - out[currentPos++] = (val << 4) >>> 31; - out[currentPos++] = (val << 5) >>> 31; - out[currentPos++] = (val << 6) >>> 31; - out[currentPos++] = (val << 7) >>> 31; - out[currentPos++] = (val << 8) >>> 31; - out[currentPos++] = (val << 9) >>> 31; - out[currentPos++] = (val << 10) >>> 31; - out[currentPos++] = (val << 11) >>> 31; - out[currentPos++] = (val << 12) >>> 31; - out[currentPos++] = (val << 13) >>> 31; // 10 - out[currentPos++] = (val << 14) >>> 31; - out[currentPos++] = (val << 15) >>> 31; - out[currentPos++] = (val << 16) >>> 31; - out[currentPos++] = (val << 17) >>> 31; - out[currentPos++] = (val << 18) >>> 31; - out[currentPos++] = (val << 19) >>> 31; - out[currentPos++] = (val << 20) >>> 31; - out[currentPos++] = (val << 21) >>> 31; - out[currentPos++] = (val << 22) >>> 31; - out[currentPos++] = (val << 23) >>> 31; // 20 - out[currentPos++] = (val << 24) >>> 31; - out[currentPos++] = (val << 25) >>> 31; - out[currentPos++] = (val << 26) >>> 31; - out[currentPos++] = (val << 27) >>> 31; - out[currentPos++] = (val << 28) >>> 31; - out[currentPos++] = (val << 29) >>> 31; - out[currentPos++] = (val << 30) >>> 31; - out[currentPos++] = (val << 31) >>> 31; - break; - } - case 1: { // number : 14, bitwidth : 2 - out[currentPos++] = (val << 4) >>> 30; - out[currentPos++] = (val << 6) >>> 30; - out[currentPos++] = (val << 8) >>> 30; - out[currentPos++] = (val << 10) >>> 30; - out[currentPos++] = (val << 12) >>> 30; - out[currentPos++] = (val << 14) >>> 30; - out[currentPos++] = (val << 16) >>> 30; - out[currentPos++] = (val << 18) >>> 30; - out[currentPos++] = (val << 20) >>> 30; - out[currentPos++] = (val << 22) >>> 30; // 10 - out[currentPos++] = (val << 24) >>> 30; - out[currentPos++] = (val << 26) >>> 30; - out[currentPos++] = (val << 28) >>> 30; - out[currentPos++] = (val << 30) >>> 30; - break; - } - case 2: { // number : 9, bitwidth : 3 - out[currentPos++] = (val << 5) >>> 29; - out[currentPos++] = (val << 8) >>> 29; - out[currentPos++] = (val << 11) >>> 29; - out[currentPos++] = (val << 14) >>> 29; - out[currentPos++] = (val << 17) >>> 29; - out[currentPos++] = (val << 20) >>> 29; - out[currentPos++] = (val << 23) >>> 29; - out[currentPos++] = (val << 26) >>> 29; - out[currentPos++] = (val << 29) >>> 29; - break; - } - case 3: { // number : 7, bitwidth : 4 - out[currentPos++] = (val << 4) >>> 28; - out[currentPos++] = (val << 8) >>> 28; - out[currentPos++] = (val << 12) >>> 28; - out[currentPos++] = (val << 16) >>> 28; - out[currentPos++] = (val << 20) >>> 28; - out[currentPos++] = (val << 24) >>> 28; - out[currentPos++] = (val << 28) >>> 28; - break; - } - case 4: { // number : 5, bitwidth : 5 - out[currentPos++] = (val << 7) >>> 27; - out[currentPos++] = (val << 12) >>> 27; - out[currentPos++] = (val << 17) >>> 27; - out[currentPos++] = (val << 22) >>> 27; - out[currentPos++] = (val << 27) >>> 27; - break; - } - case 5: { // number : 4, bitwidth : 7 - out[currentPos++] = (val << 4) >>> 25; - out[currentPos++] = (val << 11) >>> 25; - out[currentPos++] = (val << 18) >>> 25; - out[currentPos++] = (val << 25) >>> 25; - break; - } - case 6: { // number : 3, bitwidth : 9 - out[currentPos++] = (val << 5) >>> 23; - out[currentPos++] = (val << 14) >>> 23; - out[currentPos++] = (val << 23) >>> 23; - break; - } - case 7: { // number : 2, bitwidth : 14 - out[currentPos++] = (val << 4) >>> 18; - out[currentPos++] = (val << 18) >>> 18; - break; - } - case 8: { // number : 1, bitwidth : 28 - out[currentPos++] = (val << 4) >>> 4; - break; - } - default: { - throw new RuntimeException("shouldn't happen"); - } + case 0: { // number : 28, bitwidth : 1 + out[currentPos++] = (val << 4) >>> 31; + out[currentPos++] = (val << 5) >>> 31; + out[currentPos++] = (val << 6) >>> 31; + out[currentPos++] = (val << 7) >>> 31; + out[currentPos++] = (val << 8) >>> 31; + out[currentPos++] = (val << 9) >>> 31; + out[currentPos++] = (val << 10) >>> 31; + out[currentPos++] = (val << 11) >>> 31; + out[currentPos++] = (val << 12) >>> 31; + out[currentPos++] = (val << 13) >>> 31; // 10 + out[currentPos++] = (val << 14) >>> 31; + out[currentPos++] = (val << 15) >>> 31; + out[currentPos++] = (val << 16) >>> 31; + out[currentPos++] = (val << 17) >>> 31; + out[currentPos++] = (val << 18) >>> 31; + out[currentPos++] = (val << 19) >>> 31; + out[currentPos++] = (val << 20) >>> 31; + out[currentPos++] = (val << 21) >>> 31; + out[currentPos++] = (val << 22) >>> 31; + out[currentPos++] = (val << 23) >>> 31; // 20 + out[currentPos++] = (val << 24) >>> 31; + out[currentPos++] = (val << 25) >>> 31; + out[currentPos++] = (val << 26) >>> 31; + out[currentPos++] = (val << 27) >>> 31; + out[currentPos++] = (val << 28) >>> 31; + out[currentPos++] = (val << 29) >>> 31; + out[currentPos++] = (val << 30) >>> 31; + out[currentPos++] = (val << 31) >>> 31; + break; + } + case 1: { // number : 14, bitwidth : 2 + out[currentPos++] = (val << 4) >>> 30; + out[currentPos++] = (val << 6) >>> 30; + out[currentPos++] = (val << 8) >>> 30; + out[currentPos++] = (val << 10) >>> 30; + out[currentPos++] = (val << 12) >>> 30; + out[currentPos++] = (val << 14) >>> 30; + out[currentPos++] = (val << 16) >>> 30; + out[currentPos++] = (val << 18) >>> 30; + out[currentPos++] = (val << 20) >>> 30; + out[currentPos++] = (val << 22) >>> 30; // 10 + out[currentPos++] = (val << 24) >>> 30; + out[currentPos++] = (val << 26) >>> 30; + out[currentPos++] = (val << 28) >>> 30; + out[currentPos++] = (val << 30) >>> 30; + break; + } + case 2: { // number : 9, bitwidth : 3 + out[currentPos++] = (val << 5) >>> 29; + out[currentPos++] = (val << 8) >>> 29; + out[currentPos++] = (val << 11) >>> 29; + out[currentPos++] = (val << 14) >>> 29; + out[currentPos++] = (val << 17) >>> 29; + out[currentPos++] = (val << 20) >>> 29; + out[currentPos++] = (val << 23) >>> 29; + out[currentPos++] = (val << 26) >>> 29; + out[currentPos++] = (val << 29) >>> 29; + break; + } + case 3: { // number : 7, bitwidth : 4 + out[currentPos++] = (val << 4) >>> 28; + out[currentPos++] = (val << 8) >>> 28; + out[currentPos++] = (val << 12) >>> 28; + out[currentPos++] = (val << 16) >>> 28; + out[currentPos++] = (val << 20) >>> 28; + out[currentPos++] = (val << 24) >>> 28; + out[currentPos++] = (val << 28) >>> 28; + break; + } + case 4: { // number : 5, bitwidth : 5 + out[currentPos++] = (val << 7) >>> 27; + out[currentPos++] = (val << 12) >>> 27; + out[currentPos++] = (val << 17) >>> 27; + out[currentPos++] = (val << 22) >>> 27; + out[currentPos++] = (val << 27) >>> 27; + break; + } + case 5: { // number : 4, bitwidth : 7 + out[currentPos++] = (val << 4) >>> 25; + out[currentPos++] = (val << 11) >>> 25; + out[currentPos++] = (val << 18) >>> 25; + out[currentPos++] = (val << 25) >>> 25; + break; + } + case 6: { // number : 3, bitwidth : 9 + out[currentPos++] = (val << 5) >>> 23; + out[currentPos++] = (val << 14) >>> 23; + out[currentPos++] = (val << 23) >>> 23; + break; + } + case 7: { // number : 2, bitwidth : 14 + out[currentPos++] = (val << 4) >>> 18; + out[currentPos++] = (val << 18) >>> 18; + break; + } + case 8: { // number : 1, bitwidth : 28 + out[currentPos++] = (val << 4) >>> 4; + break; + } + default: { + throw new RuntimeException("shouldn't happen: limited to 28-bit integers"); + } } } while (currentPos < finalout) { int val = in[tmpinpos++]; int header = val >>> 28; switch (header) { - case 0: { // number : 28, bitwidth : 1 - final int howmany = finalout - currentPos; - for (int k = 0; k < howmany; ++k) { - out[currentPos++] = (val << (k + 4)) >>> 31; - } - break; - } - case 1: { // number : 14, bitwidth : 2 - final int howmany = finalout - currentPos < 14 ? finalout - currentPos - : 14; - for (int k = 0; k < howmany; ++k) { - out[currentPos++] = (val << (2 * k + 4)) >>> 30; - } - break; - } - case 2: { // number : 9, bitwidth : 3 - final int howmany = finalout - currentPos < 9 ? finalout - currentPos - : 9; - for (int k = 0; k < howmany; ++k) { - out[currentPos++] = (val << (3 * k + 5)) >>> 29; - } - break; + case 0: { // number : 28, bitwidth : 1 + final int howmany = finalout - currentPos; + for (int k = 0; k < howmany; ++k) { + out[currentPos++] = (val << (k + 4)) >>> 31; } - case 3: { // number : 7, bitwidth : 4 - final int howmany = finalout - currentPos < 7 ? finalout - currentPos - : 7; - for (int k = 0; k < howmany; ++k) { - out[currentPos++] = (val << (4 * k + 4)) >>> 28; - } - break; + break; + } + case 1: { // number : 14, bitwidth : 2 + final int howmany = finalout - currentPos < 14 ? finalout - currentPos : 14; + for (int k = 0; k < howmany; ++k) { + out[currentPos++] = (val << (2 * k + 4)) >>> 30; } - case 4: { // number : 5, bitwidth : 5 - final int howmany = finalout - currentPos < 5 ? finalout - currentPos - : 5; - for (int k = 0; k < howmany; ++k) { - out[currentPos++] = (val << (5 * k + 7)) >>> 27; - } - break; + break; + } + case 2: { // number : 9, bitwidth : 3 + final int howmany = finalout - currentPos < 9 ? finalout - currentPos : 9; + for (int k = 0; k < howmany; ++k) { + out[currentPos++] = (val << (3 * k + 5)) >>> 29; } - case 5: { // number : 4, bitwidth : 7 - final int howmany = finalout - currentPos < 4 ? finalout - currentPos - : 4; - for (int k = 0; k < howmany; ++k) { - out[currentPos++] = (val << (7 * k + 4)) >>> 25; - } - break; + break; + } + case 3: { // number : 7, bitwidth : 4 + final int howmany = finalout - currentPos < 7 ? finalout - currentPos : 7; + for (int k = 0; k < howmany; ++k) { + out[currentPos++] = (val << (4 * k + 4)) >>> 28; } - case 6: { // number : 3, bitwidth : 9 - final int howmany = finalout - currentPos < 3 ? finalout - currentPos - : 3; - for (int k = 0; k < howmany; ++k) { - out[currentPos++] = (val << (9 * k + 5)) >>> 23; - } - break; + break; + } + case 4: { // number : 5, bitwidth : 5 + final int howmany = finalout - currentPos < 5 ? finalout - currentPos : 5; + for (int k = 0; k < howmany; ++k) { + out[currentPos++] = (val << (5 * k + 7)) >>> 27; } - case 7: { // number : 2, bitwidth : 14 - final int howmany = finalout - currentPos < 2 ? finalout - currentPos - : 2; - for (int k = 0; k < howmany; ++k) { - out[currentPos++] = (val << (14 * k + 4)) >>> 18; - } - break; + break; + } + case 5: { // number : 4, bitwidth : 7 + final int howmany = finalout - currentPos < 4 ? finalout - currentPos : 4; + for (int k = 0; k < howmany; ++k) { + out[currentPos++] = (val << (7 * k + 4)) >>> 25; } - case 8: { // number : 1, bitwidth : 28 - out[currentPos++] = (val << 4) >>> 4; - break; + break; + } + case 6: { // number : 3, bitwidth : 9 + final int howmany = finalout - currentPos < 3 ? finalout - currentPos : 3; + for (int k = 0; k < howmany; ++k) { + out[currentPos++] = (val << (9 * k + 5)) >>> 23; } - default: { - throw new RuntimeException("shouldn't happen"); + break; + } + case 7: { // number : 2, bitwidth : 14 + final int howmany = finalout - currentPos < 2 ? finalout - currentPos : 2; + for (int k = 0; k < howmany; ++k) { + out[currentPos++] = (val << (14 * k + 4)) >>> 18; } + break; + } + case 8: { // number : 1, bitwidth : 28 + out[currentPos++] = (val << 4) >>> 4; + break; + } + default: { + throw new RuntimeException("shouldn't happen"); + } } } outpos.set(currentPos); @@ -274,10 +268,34 @@ public void uncompress(int[] in, IntWrapper inpos, int inlength, } - private final static int bitLength[] = {1, 2, 3, 4, 5, 7, 9, 14, 28}; + @Override + public int maxHeadlessCompressedLength(IntWrapper compressedPositions, int inlength) { + compressedPositions.add(inlength); + return inlength; + } + + @Override + public void compress(int[] in, IntWrapper inpos, int inlength, int[] out, IntWrapper outpos) { + if (inlength == 0) + return; + out[outpos.get()] = inlength; + outpos.increment(); + headlessCompress(in, inpos, inlength, out, outpos); + } + + @Override + public void uncompress(int[] in, IntWrapper inpos, int inlength, int[] out, IntWrapper outpos) { + if (inlength == 0) + return; + final int outlength = in[inpos.get()]; + inpos.increment(); + headlessUncompress(in, inpos, inlength, out, outpos, outlength); + + } - private final static int codeNum[] = {28, 14, 9, 7, 5, 4, 3, 2, 1}; + private final static int bitLength[] = { 1, 2, 3, 4, 5, 7, 9, 14, 28 }; + private final static int codeNum[] = { 28, 14, 9, 7, 5, 4, 3, 2, 1 }; @Override public String toString() { diff --git a/src/main/java/me/lemire/integercompression/SkippableComposition.java b/src/main/java/me/lemire/integercompression/SkippableComposition.java new file mode 100644 index 0000000..fc3c18e --- /dev/null +++ b/src/main/java/me/lemire/integercompression/SkippableComposition.java @@ -0,0 +1,81 @@ +/** + * This is code is released under the + * Apache License Version 2.0 http://www.apache.org/licenses/. + * + * (c) Daniel Lemire, http://lemire.me/en/ + */ +package me.lemire.integercompression; + + +/** + * Helper class to compose schemes. + * + * @author Daniel Lemire + */ +public class SkippableComposition implements SkippableIntegerCODEC { + SkippableIntegerCODEC F1, F2; + + /** + * Compose a scheme from a first one (f1) and a second one (f2). The first + * one is called first and then the second one tries to compress whatever + * remains from the first run. + * + * By convention, the first scheme should be such that if, during decoding, + * a 32-bit zero is first encountered, then there is no output. + * + * @param f1 + * first codec + * @param f2 + * second codec + */ + public SkippableComposition(SkippableIntegerCODEC f1, + SkippableIntegerCODEC f2) { + F1 = f1; + F2 = f2; + } + + @Override + public void headlessCompress(int[] in, IntWrapper inpos, int inlength, int[] out, + IntWrapper outpos) { + int init = inpos.get(); + int outposInit = outpos.get(); + F1.headlessCompress(in, inpos, inlength, out, outpos); + if (outpos.get() == outposInit) { + out[outposInit] = 0; + outpos.increment(); + } + inlength -= inpos.get() - init; + F2.headlessCompress(in, inpos, inlength, out, outpos); + } + + @Override + public void headlessUncompress(int[] in, IntWrapper inpos, int inlength, int[] out, + IntWrapper outpos, int num) { + int init = inpos.get(); + int outposInit = outpos.get(); + + F1.headlessUncompress(in, inpos, inlength, out, outpos, num); + if (inpos.get() == init) { + inpos.increment(); + } + inlength -= inpos.get() - init; + num -= outpos.get() - outposInit; + F2.headlessUncompress(in, inpos, inlength, out, outpos, num); + } + + @Override + public int maxHeadlessCompressedLength(IntWrapper compressedPositions, int inlength) { + int init = compressedPositions.get(); + int maxLength = F1.maxHeadlessCompressedLength(compressedPositions, inlength); + maxLength += 1; // Add +1 for the potential F2 header. Question: is this header actually needed in the headless version? + inlength -= compressedPositions.get() - init; + maxLength += F2.maxHeadlessCompressedLength(compressedPositions, inlength); + return maxLength; + } + + @Override + public String toString() { + return F1.toString() + "+" + F2.toString(); + } + +} diff --git a/src/main/java/me/lemire/integercompression/SkippableIntegerCODEC.java b/src/main/java/me/lemire/integercompression/SkippableIntegerCODEC.java new file mode 100644 index 0000000..b9bdc04 --- /dev/null +++ b/src/main/java/me/lemire/integercompression/SkippableIntegerCODEC.java @@ -0,0 +1,89 @@ +/** + * This is code is released under the + * Apache License Version 2.0 http://www.apache.org/licenses/. + * + * (c) Daniel Lemire, http://lemire.me/en/ + */ + +package me.lemire.integercompression; + + +/** + * Interface describing a standard CODEC to compress integers. This is a + * variation on the IntegerCODEC interface meant to be used for random access + * (i.e., given a large array, you can segment it and decode just the subarray you need). + * + * The main difference is that you must specify the number of integers you wish to + * uncompress. This information should be stored elsewhere. + * + * This interface was designed by the Terrier team for their search engine. + * + * @author Daniel Lemire + * + */ +public interface SkippableIntegerCODEC { + /** + * Compress data from an array to another array. + * + * Both inpos and outpos are modified to represent how much data was read + * and written to. If 12 ints (inlength = 12) are compressed to 3 ints, then + * inpos will be incremented by 12 while outpos will be incremented by 3. We + * use IntWrapper to pass the values by reference. + * + * Implementation note: contrary to {@link IntegerCODEC#compress}, + * this may skip writing information about the number of encoded integers. + * + * @param in + * input array + * @param inpos + * where to start reading in the array + * @param inlength + * how many integers to compress + * @param out + * output array + * @param outpos + * where to write in the output array + */ + public void headlessCompress(int[] in, IntWrapper inpos, int inlength, int[] out, + IntWrapper outpos); + + /** + * Uncompress data from an array to another array. + * + * Both inpos and outpos parameters are modified to indicate new positions + * after read/write. + * + * @param in + * array containing data in compressed form + * @param inpos + * where to start reading in the array + * @param inlength + * length of the compressed data (ignored by some schemes) + * @param out + * array where to write the uncompressed output + * @param outpos + * where to start writing the uncompressed output in out + * @param num + * number of integers we want to decode. May be less than the actual number of compressed integers + */ + public void headlessUncompress(int[] in, IntWrapper inpos, int inlength, int[] out, + IntWrapper outpos, int num); + + /** + * Compute the maximum number of integers that might be required to store + * the compressed form of a given input array segment, without headers. + *

+ * This is useful to pre-allocate the output buffer before calling + * {@link #headlessCompress(int[], IntWrapper, int, int[], IntWrapper)}. + *

+ * + * @param compressedPositions + * since not all schemes compress every input integer, this parameter + * returns how many input integers will actually be compressed. + * This is useful when composing multiple schemes. + * @param inlength + * number of integers to be compressed + * @return the maximum number of integers needed in the output array + */ + int maxHeadlessCompressedLength(IntWrapper compressedPositions, int inlength); +} diff --git a/src/main/java/me/lemire/integercompression/Util.java b/src/main/java/me/lemire/integercompression/Util.java index f55dfbd..63fc918 100644 --- a/src/main/java/me/lemire/integercompression/Util.java +++ b/src/main/java/me/lemire/integercompression/Util.java @@ -10,17 +10,87 @@ * Routine utility functions. * * @author Daniel Lemire - * + * */ public final class Util { - protected static int maxbits(int[] i, int pos, int length) { + + + + // check whether x is small than y as unsigned ints (supported by Java 8 natively); + protected static final boolean smallerorequalthan(int x, int y) { + return (x + Integer.MIN_VALUE) <= (y + Integer.MIN_VALUE); + } + + /** + * Compute the maximum of the integer logarithms (ceil(log(x+1)) of a range + * of value + * + * @param i + * source array + * @param pos + * starting position + * @param length + * number of integers to consider + * @return integer logarithm + */ + public static int maxbits(int[] i, int pos, int length) { int mask = 0; for (int k = pos; k < pos + length; ++k) mask |= i[k]; return bits(mask); } - protected static int maxdiffbits(int initoffset, int[] i, int pos, int length) { + protected static int maxbits32(int[] i, int pos) { + int mask = i[pos]; + mask |= i[pos + 1]; + mask |= i[pos + 2]; + mask |= i[pos + 3]; + mask |= i[pos + 4]; + mask |= i[pos + 5]; + mask |= i[pos + 6]; + mask |= i[pos + 7]; + mask |= i[pos + 8]; + mask |= i[pos + 9]; + mask |= i[pos + 10]; + mask |= i[pos + 11]; + mask |= i[pos + 12]; + mask |= i[pos + 13]; + mask |= i[pos + 14]; + mask |= i[pos + 15]; + mask |= i[pos + 16]; + mask |= i[pos + 17]; + mask |= i[pos + 18]; + mask |= i[pos + 19]; + mask |= i[pos + 20]; + mask |= i[pos + 21]; + mask |= i[pos + 22]; + mask |= i[pos + 23]; + mask |= i[pos + 24]; + mask |= i[pos + 25]; + mask |= i[pos + 26]; + mask |= i[pos + 27]; + mask |= i[pos + 28]; + mask |= i[pos + 29]; + mask |= i[pos + 30]; + mask |= i[pos + 31]; + return bits(mask); + } + + /** + * Compute the maximum of the integer logarithms (ceil(log(x+1)) of a the + * successive differences (deltas) of a range of value + * + * @param initoffset + * initial vallue for the computation of the deltas + * @param i + * source array + * @param pos + * starting position + * @param length + * number of integers to consider + * @return integer logarithm + */ + public static int maxdiffbits(int initoffset, int[] i, int pos, int length) { int mask = 0; mask |= (i[pos] - initoffset); for (int k = pos + 1; k < pos + length; ++k) { @@ -29,11 +99,112 @@ protected static int maxdiffbits(int initoffset, int[] i, int pos, int length) { return bits(mask); } - protected static int bits(int i) { + /** + * Compute the integer logarithms (ceil(log(x+1)) of a value + * + * @param i + * source value + * @return integer logarithm + */ + public static int bits(int i) { return 32 - Integer.numberOfLeadingZeros(i); } - protected static int floorBy(int value, int factor) { + protected static int packsize(int num, int b) { + if (b > 16) + return num; + int howmanyfit = 32 / b; + return (num + howmanyfit - 1) / howmanyfit; + } + + protected static int pack(int[] outputarray, int arraypos, int[] data, int datapos, + int num, int b) { + if (num == 0) + return arraypos; + if (b > 16) { + System.arraycopy(data, datapos, outputarray, arraypos, num); + return num + arraypos; + } + for (int k = 0; k < packsize(num, b); ++k) + outputarray[k + arraypos] = 0; + int inwordpointer = 0; + for (int k = 0; k < num; ++k) { + outputarray[arraypos] |= (data[k + datapos] << inwordpointer); + inwordpointer += b; + final int increment = ((inwordpointer + b - 1) >> 5); + arraypos += increment; + inwordpointer &= ~(-increment); + } + return arraypos + (inwordpointer > 0 ? 1 : 0); + } + + protected static int unpack(int[] sourcearray, int arraypos, int[] data, int datapos, + int num, int b) { + if (b > 16) { + System.arraycopy(sourcearray, arraypos, data, 0, num); + return num + arraypos; + } + final int mask = (1 << b) - 1; + int inwordpointer = 0; + for (int k = 0; k < num; ++k) { + data[k + datapos] = ((sourcearray[arraypos] >>> inwordpointer) & mask); + inwordpointer += b; + final int increment = ((inwordpointer + b - 1) >> 5); + arraypos += increment; + inwordpointer &= ~(-increment); + } + return arraypos + (inwordpointer > 0 ? 1 : 0); + } + + protected static int packsizew(int num, int b) { + int howmanyfit = 32 / b; + if (num <= howmanyfit) + return 1; + return num; + } + + protected static int packw(int[] outputarray, int arraypos, int[] data, + int num, int b) { + int howmanyfit = 32 / b; + if (num > howmanyfit) { + System.arraycopy(data, 0, outputarray, arraypos, num); + return num + arraypos; + } + outputarray[arraypos] = 0; + int inwordpointer = 0; + for (int k = 0; k < num; ++k) { + outputarray[arraypos] |= (data[k] << inwordpointer); + inwordpointer += b; + } + return arraypos + 1; + } + + protected static int unpackw(int[] sourcearray, int arraypos, int[] data, + int num, int b) { + int howmanyfit = 32 / b; + if (num > howmanyfit) { + System.arraycopy(sourcearray, arraypos, data, 0, num); + return num + arraypos; + } + final int mask = (1 << b) - 1; + int val = sourcearray[arraypos]; + for (int k = 0; k < num; ++k) { + data[k] = (val & mask); + val >>>= b; + } + return arraypos + 1; + } + + /** + * return floor(value / factor) * factor + * + * @param value + * numerator + * @param factor + * denominator + * @return greatest multiple of factor no larger than value + */ + public static int greatestMultiple(int value, int factor) { return value - value % factor; } } diff --git a/src/main/java/me/lemire/integercompression/VariableByte.java b/src/main/java/me/lemire/integercompression/VariableByte.java index f1de669..c9b04d0 100644 --- a/src/main/java/me/lemire/integercompression/VariableByte.java +++ b/src/main/java/me/lemire/integercompression/VariableByte.java @@ -7,32 +7,69 @@ package me.lemire.integercompression; import java.nio.ByteBuffer; +import java.nio.ByteOrder; import java.nio.IntBuffer; /** - * Implementation of variable-byte. Possibly inefficient. - * + * Implementation of variable-byte. For best performance, use it using the + * ByteIntegerCODEC interface. + * + * Note that this does not use differential coding: if you are working on sorted + * lists, you must compute the deltas separately. + * * @author Daniel Lemire */ -public class VariableByte implements IntegerCODEC { +public class VariableByte implements IntegerCODEC, ByteIntegerCODEC, SkippableIntegerCODEC { + + private static final int MAX_BYTES_PER_INT = 5; + + private static byte extract7bits(int i, long val) { + return (byte) ((val >> (7 * i)) & ((1 << 7) - 1)); + } + + private static byte extract7bitsmaskless(int i, long val) { + return (byte) ((val >> (7 * i))); + } @Override public void compress(int[] in, IntWrapper inpos, int inlength, int[] out, - IntWrapper outpos) { - if(inlength == 0) return; - ByteBuffer buf = ByteBuffer.allocateDirect(inlength * 8); + IntWrapper outpos) { + headlessCompress(in, inpos, inlength, out, outpos); + } + + @Override + public void headlessCompress(int[] in, IntWrapper inpos, int inlength, int[] out, + IntWrapper outpos) { + if (inlength == 0) + return; + ByteBuffer buf = makeBuffer(inlength * 8); + buf.order(ByteOrder.LITTLE_ENDIAN); for (int k = inpos.get(); k < inpos.get() + inlength; ++k) { - int val = in[k]; - do { - int b = (val & 127); - val >>>= 7; - if (val != 0) { - b |= 128; - } - buf.put((byte) b); - } while (val != 0); + final long val = in[k] & 0xFFFFFFFFL; // To be consistent with + // unsigned integers in C/C++ + if (val < (1 << 7)) { + buf.put((byte) (val | (1 << 7))); + } else if (val < (1 << 14)) { + buf.put((byte) extract7bits(0, val)); + buf.put((byte) (extract7bitsmaskless(1, (val)) | (1 << 7))); + } else if (val < (1 << 21)) { + buf.put((byte) extract7bits(0, val)); + buf.put((byte) extract7bits(1, val)); + buf.put((byte) (extract7bitsmaskless(2, (val)) | (1 << 7))); + } else if (val < (1 << 28)) { + buf.put((byte) extract7bits(0, val)); + buf.put((byte) extract7bits(1, val)); + buf.put((byte) extract7bits(2, val)); + buf.put((byte) (extract7bitsmaskless(3, (val)) | (1 << 7))); + } else { + buf.put((byte) extract7bits(0, val)); + buf.put((byte) extract7bits(1, val)); + buf.put((byte) extract7bits(2, val)); + buf.put((byte) extract7bits(3, val)); + buf.put((byte) (extract7bitsmaskless(4, (val)) | (1 << 7))); + } } while (buf.position() % 4 != 0) - buf.put((byte) 128); + buf.put((byte) 0); final int length = buf.position(); buf.flip(); IntBuffer ibuf = buf.asIntBuffer(); @@ -42,21 +79,59 @@ public void compress(int[] in, IntWrapper inpos, int inlength, int[] out, } @Override - public void uncompress(int[] in, IntWrapper inpos, int inlength, - int[] out, IntWrapper outpos) { + public void compress(int[] in, IntWrapper inpos, int inlength, byte[] out, + IntWrapper outpos) { + if (inlength == 0) + return; + int outpostmp = outpos.get(); + for (int k = inpos.get(); k < inpos.get() + inlength; ++k) { + final long val = in[k] & 0xFFFFFFFFL; // To be consistent with + // unsigned integers in C/C++ + if (val < (1 << 7)) { + out[outpostmp++] = (byte) (val | (1 << 7)); + } else if (val < (1 << 14)) { + out[outpostmp++] = (byte) extract7bits(0, val); + out[outpostmp++] = (byte) (extract7bitsmaskless(1, (val)) | (1 << 7)); + } else if (val < (1 << 21)) { + out[outpostmp++] = (byte) extract7bits(0, val); + out[outpostmp++] = (byte) extract7bits(1, val); + out[outpostmp++] = (byte) (extract7bitsmaskless(2, (val)) | (1 << 7)); + } else if (val < (1 << 28)) { + out[outpostmp++] = (byte) extract7bits(0, val); + out[outpostmp++] = (byte) extract7bits(1, val); + out[outpostmp++] = (byte) extract7bits(2, val); + out[outpostmp++] = (byte) (extract7bitsmaskless(3, (val)) | (1 << 7)); + } else { + out[outpostmp++] = (byte) extract7bits(0, val); + out[outpostmp++] = (byte) extract7bits(1, val); + out[outpostmp++] = (byte) extract7bits(2, val); + out[outpostmp++] = (byte) extract7bits(3, val); + out[outpostmp++] = (byte) (extract7bitsmaskless(4, (val)) | (1 << 7)); + } + } + outpos.set(outpostmp); + inpos.add(inlength); + } + + @Override + public void uncompress(int[] in, IntWrapper inpos, int inlength, int[] out, + IntWrapper outpos) { int s = 0; + int val = 0; int p = inpos.get(); int finalp = inpos.get() + inlength; int tmpoutpos = outpos.get(); - for (int v = 0, shift = 0; p < finalp; ) { - int c = (byte) (in[p] >>> (24 - s)); + for (int v = 0, shift = 0; p < finalp;) { + val = in[p]; + int c = (byte) (val >>> s); + // Shift to next byte s += 8; - if (s == 32) { - s = 0; - p++; - } + // Shift to next integer if s==32 + p += s>>5; + // cycle from 31 to 0 + s = s & 31; v += ((c & 127) << shift); - if ((c & 128) == 0) { + if ((c & 128) == 128) { out[tmpoutpos++] = v; v = 0; shift = 0; @@ -67,9 +142,93 @@ public void uncompress(int[] in, IntWrapper inpos, int inlength, inpos.add(inlength); } + @Override + public void uncompress(byte[] in, IntWrapper inpos, int inlength, + int[] out, IntWrapper outpos) { + int p = inpos.get(); + int finalp = inpos.get() + inlength; + int tmpoutpos = outpos.get(); + for (int v = 0; p < finalp; out[tmpoutpos++] = v) { + v = in[p] & 0x7F; + if (in[p] < 0) { + p += 1; + continue; + } + v = ((in[p + 1] & 0x7F) << 7) | v; + if (in[p + 1] < 0) { + p += 2; + continue; + } + v = ((in[p + 2] & 0x7F) << 14) | v; + if (in[p + 2] < 0 ) { + p += 3; + continue; + } + v = ((in[p + 3] & 0x7F) << 21) | v; + if (in[p + 3] < 0) { + p += 4; + continue; + } + v = ((in[p + 4] & 0x7F) << 28) | v; + p += 5; + } + outpos.set(tmpoutpos); + inpos.add(p); + } + @Override public String toString() { return this.getClass().getSimpleName(); } + @Override + public void headlessUncompress(int[] in, IntWrapper inpos, int inlength, int[] out, + IntWrapper outpos, int num) { + int s = 0; + int val = 0; + int p = inpos.get(); + int tmpoutpos = outpos.get(); + int finaloutpos = num + tmpoutpos; + for (int v = 0, shift = 0; tmpoutpos < finaloutpos;) { + val = in[p]; + int c = val >>> s; + // Shift to next byte + s += 8; + // Shift to next integer if s==32 + p += s>>5; + // cycle from 31 to 0 + s = s & 31; + v += ((c & 127) << shift); + if ((c & 128) == 128) { + out[tmpoutpos++] = v; + v = 0; + shift = 0; + } else + shift += 7; + } + outpos.set(tmpoutpos); + inpos.set(p + (s!=0 ? 1 : 0)); + } + + @Override + public int maxHeadlessCompressedLength(IntWrapper compressedPositions, int inlength) { + int maxLengthInBytes = inlength * MAX_BYTES_PER_INT; + int maxLengthInInts = (maxLengthInBytes + Integer.BYTES - 1) / Integer.BYTES; + compressedPositions.add(inlength); + return maxLengthInInts; + } + + /** + * Creates a new buffer of the requested size. + * + * In case you need a different way to allocate buffers, you can override this method + * with a custom behavior. The default implementation allocates a new Java direct + * {@link ByteBuffer} on each invocation. + * + * @param sizeInBytes + * @return + */ + protected ByteBuffer makeBuffer(int sizeInBytes) { + return ByteBuffer.allocateDirect(sizeInBytes); + } } diff --git a/src/main/java/me/lemire/integercompression/benchmarktools/Benchmark.java b/src/main/java/me/lemire/integercompression/benchmarktools/Benchmark.java new file mode 100644 index 0000000..ef4a386 --- /dev/null +++ b/src/main/java/me/lemire/integercompression/benchmarktools/Benchmark.java @@ -0,0 +1,691 @@ +/** + * This code is released under the + * Apache License Version 2.0 http://www.apache.org/licenses/. + * + * (c) Daniel Lemire, http://lemire.me/en/ + */ +package me.lemire.integercompression.benchmarktools; + +import com.kamikaze.pfordelta.PForDelta; + +import me.lemire.integercompression.BinaryPacking; +import me.lemire.integercompression.ByteIntegerCODEC; +import me.lemire.integercompression.Composition; +import me.lemire.integercompression.DeltaZigzagBinaryPacking; +import me.lemire.integercompression.DeltaZigzagVariableByte; +import me.lemire.integercompression.FastPFOR; +import me.lemire.integercompression.FastPFOR128; +import me.lemire.integercompression.GroupSimple9; +import me.lemire.integercompression.IntWrapper; +import me.lemire.integercompression.IntegerCODEC; +import me.lemire.integercompression.JustCopy; +import me.lemire.integercompression.NewPFD; +import me.lemire.integercompression.NewPFDS16; +import me.lemire.integercompression.NewPFDS9; +import me.lemire.integercompression.OptPFD; +import me.lemire.integercompression.OptPFDS16; +import me.lemire.integercompression.OptPFDS9; +import me.lemire.integercompression.Simple16; +import me.lemire.integercompression.Simple9; +import me.lemire.integercompression.VariableByte; +import me.lemire.integercompression.differential.Delta; +import me.lemire.integercompression.differential.IntegratedBinaryPacking; +import me.lemire.integercompression.differential.IntegratedByteIntegerCODEC; +import me.lemire.integercompression.differential.IntegratedComposition; +import me.lemire.integercompression.differential.IntegratedIntegerCODEC; +import me.lemire.integercompression.differential.IntegratedVariableByte; +import me.lemire.integercompression.differential.XorBinaryPacking; +import me.lemire.integercompression.synth.ClusteredDataGenerator; + +import java.io.File; +import java.io.FileNotFoundException; +import java.io.PrintWriter; +import java.text.DecimalFormat; +import java.util.ArrayList; +import java.util.Arrays; + +/** + * + * Simple class meant to compare the speed of different schemes. + * + * @author Daniel Lemire + * + */ +public class Benchmark { + + /** + * Standard benchmark + * + * @param csvLog + * Writer for CSV log. + * @param c + * the codec + * @param data + * arrays of input data + * @param repeat + * How many times to repeat the test + * @param verbose + * whether to output result on screen + */ + private static void testCodec(PrintWriter csvLog, int sparsity, + IntegerCODEC c, int[][] data, int repeat, boolean verbose) { + if (verbose) { + System.out.println("# " + c.toString()); + System.out + .println("# bits per int, compress speed (mis), decompression speed (mis) "); + } + + int N = data.length; + + int totalSize = 0; + int maxLength = 0; + for (int k = 0; k < N; ++k) { + totalSize += data[k].length; + if (data[k].length > maxLength) { + maxLength = data[k].length; + } + } + + // 4x + 1024 to account for the possibility of some negative + // compression. + int[] compressBuffer = new int[4 * maxLength + 1024]; + int[] decompressBuffer = new int[maxLength + 1024]; + + // These variables hold time in microseconds (10^-6). + long compressTime = 0; + long decompressTime = 0; + + int size = 0; + IntWrapper inpos = new IntWrapper(); + IntWrapper outpos = new IntWrapper(); + + for (int r = 0; r < repeat; ++r) { + size = 0; + for (int k = 0; k < N; ++k) { + int[] backupdata = Arrays.copyOf(data[k], + data[k].length); + + // compress data. + long beforeCompress = System.nanoTime() / 1000; + inpos.set(1); + outpos.set(0); + if (!(c instanceof IntegratedIntegerCODEC)) { + Delta.delta(backupdata); + } + c.compress(backupdata, inpos, backupdata.length + - inpos.get(), compressBuffer, outpos); + long afterCompress = System.nanoTime() / 1000; + + // measure time of compression. + compressTime += afterCompress - beforeCompress; + final int thiscompsize = outpos.get() + 1; + size += thiscompsize; + + // extract (uncompress) data + long beforeDecompress = System.nanoTime() / 1000; + inpos.set(0); + outpos.set(1); + decompressBuffer[0] = backupdata[0]; + c.uncompress(compressBuffer, inpos, + thiscompsize - 1, decompressBuffer, + outpos); + if (!(c instanceof IntegratedIntegerCODEC)) + Delta.fastinverseDelta(decompressBuffer); + long afterDecompress = System.nanoTime() / 1000; + + // measure time of extraction (uncompression). + decompressTime += afterDecompress + - beforeDecompress; + if (outpos.get() != data[k].length) + throw new RuntimeException( + "we have a bug (diff length) " + + c + " expected " + + data[k].length + + " got " + + outpos.get()); + + // verify: compare original array with + // compressed and + // uncompressed. + + for (int m = 0; m < outpos.get(); ++m) { + if (decompressBuffer[m] != data[k][m]) { + throw new RuntimeException( + "we have a bug (actual difference), expected " + + data[k][m] + + " found " + + decompressBuffer[m] + + " at " + m + " out of " + outpos.get()); + } + } + } + } + + if (verbose) { + double bitsPerInt = size * 32.0 / totalSize; + long compressSpeed = totalSize * repeat + / (compressTime); + long decompressSpeed = totalSize * repeat + / (decompressTime); + System.out.println(String.format( + "\t%1$.2f\t%2$d\t%3$d", bitsPerInt, + compressSpeed, decompressSpeed)); + csvLog.format("\"%1$s\",%2$d,%3$.2f,%4$d,%5$d\n", + c.toString(), sparsity, bitsPerInt, + compressSpeed, decompressSpeed); + csvLog.flush(); + } + } + + /** + * Standard benchmark byte byte-aligned schemes + * + * @param csvLog + * Writer for CSV log. + * @param c + * the codec + * @param data + * arrays of input data + * @param repeat + * How many times to repeat the test + * @param verbose + * whether to output result on screen + */ + private static void testByteCodec(PrintWriter csvLog, int sparsity, + ByteIntegerCODEC c, int[][] data, int repeat, boolean verbose) { + if (verbose) { + System.out.println("# " + c.toString()); + System.out + .println("# bits per int, compress speed (mis), decompression speed (mis) "); + } + + int N = data.length; + + int totalSize = 0; + int maxLength = 0; + for (int k = 0; k < N; ++k) { + totalSize += data[k].length; + if (data[k].length > maxLength) { + maxLength = data[k].length; + } + } + + byte[] compressBuffer = new byte[8 * maxLength + 1024]; + int[] decompressBuffer = new int[maxLength + 1024]; + + // These variables hold time in microseconds (10^-6). + long compressTime = 0; + long decompressTime = 0; + + int size = 0; + IntWrapper inpos = new IntWrapper(); + IntWrapper outpos = new IntWrapper(); + + for (int r = 0; r < repeat; ++r) { + size = 0; + for (int k = 0; k < N; ++k) { + int[] backupdata = Arrays.copyOf(data[k], + data[k].length); + + // compress data. + long beforeCompress = System.nanoTime() / 1000; + inpos.set(1); + outpos.set(0); + if (!(c instanceof IntegratedByteIntegerCODEC)) { + Delta.delta(backupdata); + } + c.compress(backupdata, inpos, backupdata.length + - inpos.get(), compressBuffer, outpos); + long afterCompress = System.nanoTime() / 1000; + + // measure time of compression. + compressTime += afterCompress - beforeCompress; + final int thiscompsize = outpos.get() + 1; + size += thiscompsize; + + // extract (uncompress) data + long beforeDecompress = System.nanoTime() / 1000; + inpos.set(0); + outpos.set(1); + decompressBuffer[0] = backupdata[0]; + c.uncompress(compressBuffer, inpos, + thiscompsize - 1, decompressBuffer, + outpos); + if (!(c instanceof IntegratedByteIntegerCODEC)) + Delta.fastinverseDelta(decompressBuffer); + long afterDecompress = System.nanoTime() / 1000; + + // measure time of extraction (uncompression). + decompressTime += afterDecompress + - beforeDecompress; + if (outpos.get() != data[k].length) + throw new RuntimeException( + "we have a bug (diff length) " + + c + " expected " + + data[k].length + + " got " + + outpos.get()); + + // verify: compare original array with + // compressed and + // uncompressed. + for (int m = 0; m < outpos.get(); ++m) { + if (decompressBuffer[m] != data[k][m]) { + throw new RuntimeException( + "we have a bug (actual difference), expected " + + data[k][m] + + " found " + + decompressBuffer[m] + + " at " + m); + } + } + } + } + + if (verbose) { + double bitsPerInt = size * 8.0 / totalSize; + long compressSpeed = totalSize * repeat + / (compressTime); + long decompressSpeed = totalSize * repeat + / (decompressTime); + System.out.println(String.format( + "\t%1$.2f\t%2$d\t%3$d", bitsPerInt, + compressSpeed, decompressSpeed)); + csvLog.format("\"%1$s\",%2$d,%3$.2f,%4$d,%5$d\n", + c.toString(), sparsity, bitsPerInt, + compressSpeed, decompressSpeed); + csvLog.flush(); + } + } + + /** + * Main method. + * + * @param args + * command-line arguments + * @throws FileNotFoundException when we fail to create a new file + */ + public static void main(String args[]) throws FileNotFoundException { + System.out + .println("# benchmark based on the ClusterData model from:"); + System.out.println("# Vo Ngoc Anh and Alistair Moffat. "); + System.out.println("# Index compression using 64-bit words."); + System.out + .println("# Softw. Pract. Exper.40, 2 (February 2010), 131-147. "); + System.out.println(); + + PrintWriter writer = null; + try { + File csvFile = new File( + String.format( + "benchmark-%1$tY%1$tm%1$tdT%1$tH%1$tM%1$tS.csv", + System.currentTimeMillis())); + writer = new PrintWriter(csvFile); + System.out + .println("# Results will be written into a CSV file: " + + csvFile.getName()); + System.out.println(); + test(writer, 20, 18, 10); + System.out.println(); + System.out + .println("Results were written into a CSV file: " + + csvFile.getName()); + } finally { + if (writer != null) { + writer.close(); + } + } + } + + /** + * Standard test for the Kamikaze library + * + * @param data + * input data + * @param repeat + * how many times to repeat + * @param verbose + * whether to output data on screen + */ + public static void testKamikaze(int[][] data, int repeat, + boolean verbose) { + DecimalFormat df = new DecimalFormat("0.00"); + DecimalFormat dfspeed = new DecimalFormat("0"); + if (verbose) + System.out.println("# kamikaze PForDelta"); + if (verbose) + System.out + .println("# bits per int, compress speed (mis), decompression speed (mis) "); + long bef, aft; + String line = ""; + int N = data.length; + int totalsize = 0; + int maxlength = 0; + for (int k = 0; k < N; ++k) { + totalsize += data[k].length; + if (data[k].length > maxlength) + maxlength = data[k].length; + } + int[] buffer = new int[maxlength + 1024]; + /* + * 4x + 1024 to account for the possibility of some negative + * compression + */ + int size = 0; + int comptime = 0; + long decomptime = 0; + for (int r = 0; r < repeat; ++r) { + size = 0; + for (int k = 0; k < N; ++k) { + int outpos = 0; + int[] backupdata = Arrays.copyOf(data[k], + data[k].length); + // + bef = System.nanoTime() / 1000; + Delta.delta(backupdata); + ArrayList dataout = new ArrayList( + data[k].length / 128); + for (int K = 0; K < data[k].length; K += 128) { + final int[] compressedbuf = PForDelta + .compressOneBlockOpt(Arrays + .copyOfRange( + backupdata, K, + K + 128), 128); + dataout.add(compressedbuf); + outpos += compressedbuf.length; + } + aft = System.nanoTime() / 1000; + // + comptime += aft - bef; + final int thiscompsize = outpos; + size += thiscompsize; + // + bef = System.nanoTime() / 1000; + ArrayList datauncomp = new ArrayList( + dataout.size()); + int deltaoffset = 0; + + for (int[] compbuf : dataout) { + int[] tmpbuf = new int[128]; + PForDelta.decompressOneBlock(tmpbuf, + compbuf, 128); + tmpbuf[0] += deltaoffset; + Delta.fastinverseDelta(tmpbuf); + deltaoffset = tmpbuf[127]; + datauncomp.add(tmpbuf); + } + aft = System.nanoTime() / 1000; + // + decomptime += aft - bef; + if (datauncomp.size() * 128 != data[k].length) + throw new RuntimeException( + "we have a bug (diff length) " + + " expected " + + data[k].length + + " got " + + datauncomp.size() + * 128); + for (int m = 0; m < data[k].length; ++m) + if (datauncomp.get(m / 128)[m % 128] != data[k][m]) { + throw new RuntimeException( + "we have a bug (actual difference), expected " + + data[k][m] + + " found " + + buffer[m] + + " at " + m); + } + + } + } + + line += "\t" + df.format(size * 32.0 / totalsize); + line += "\t" + dfspeed.format(totalsize * repeat / (comptime)); + line += "\t" + + dfspeed.format(totalsize * repeat / (decomptime)); + if (verbose) + System.out.println(line); + } + + /** + * Generate test data. + * + * @param N + * How many input arrays to generate + * @param nbr + * How big (in log2) should the arrays be + * @param sparsity + * How sparse test data generated + */ + private static int[][] generateTestData(ClusteredDataGenerator dataGen, + int N, int nbr, int sparsity) { + final int[][] data = new int[N][]; + final int dataSize = (1 << (nbr + sparsity)); + for (int i = 0; i < N; ++i) { + data[i] = dataGen.generateClustered((1 << nbr), + dataSize); + } + return data; + } + + /** + * Generates data and calls other tests. + * + * @param csvLog + * Writer for CSV log. + * @param N + * How many input arrays to generate + * @param nbr + * how big (in log2) should the arrays be + * @param repeat + * How many times should we repeat tests. + */ + private static void test(PrintWriter csvLog, int N, int nbr, int repeat) { + csvLog.format("\"Algorithm\",\"Sparsity\",\"Bits per int\",\"Compress speed (MiS)\",\"Decompress speed (MiS)\"\n"); + ClusteredDataGenerator cdg = new ClusteredDataGenerator(); + final int max_sparsity = 31 - nbr; + for (int sparsity = 1; sparsity < max_sparsity; ++sparsity) { + System.out.println("# sparsity " + sparsity); + System.out.println("# generating random data..."); + int[][] data = generateTestData(cdg, N, nbr, sparsity); + System.out.println("# generating random data... ok."); + + testCodec(csvLog, sparsity, new Composition( + new FastPFOR128(), new VariableByte()), data, + repeat, false); + testCodec(csvLog, sparsity, new Composition( + new FastPFOR128(), new VariableByte()), data, + repeat, false); + testCodec(csvLog, sparsity, new Composition( + new FastPFOR128(), new VariableByte()), data, + repeat, true); + System.out.println(); + testCodec(csvLog, sparsity, new Composition( + new FastPFOR(), new VariableByte()), data, + repeat, false); + testCodec(csvLog, sparsity, new Composition( + new FastPFOR(), new VariableByte()), data, + repeat, false); + testCodec(csvLog, sparsity, new Composition( + new FastPFOR(), new VariableByte()), data, + repeat, true); + System.out.println(); + + + // TODO: support CSV log output. + testKamikaze(data, repeat, false); + testKamikaze(data, repeat, false); + testKamikaze(data, repeat, true); + System.out.println(); + + testCodec(csvLog, sparsity, new IntegratedComposition( + new IntegratedBinaryPacking(), + new IntegratedVariableByte()), data, repeat, + false); + testCodec(csvLog, sparsity, new IntegratedComposition( + new IntegratedBinaryPacking(), + new IntegratedVariableByte()), data, repeat, + false); + testCodec(csvLog, sparsity, new IntegratedComposition( + new IntegratedBinaryPacking(), + new IntegratedVariableByte()), data, repeat, + true); + System.out.println(); + + testCodec(csvLog, sparsity, new JustCopy(), data, + repeat, false); + testCodec(csvLog, sparsity, new JustCopy(), data, + repeat, false); + testCodec(csvLog, sparsity, new JustCopy(), data, + repeat, true); + System.out.println(); + + testByteCodec(csvLog, sparsity, new VariableByte(), + data, repeat, false); + testByteCodec(csvLog, sparsity, new VariableByte(), + data, repeat, false); + testByteCodec(csvLog, sparsity, new VariableByte(), + data, repeat, true); + System.out.println(); + + testByteCodec(csvLog, sparsity, + new IntegratedVariableByte(), data, repeat, + false); + testByteCodec(csvLog, sparsity, + new IntegratedVariableByte(), data, repeat, + false); + testByteCodec(csvLog, sparsity, + new IntegratedVariableByte(), data, repeat, + true); + System.out.println(); + + testCodec(csvLog, sparsity, new Composition( + new BinaryPacking(), new VariableByte()), data, + repeat, false); + testCodec(csvLog, sparsity, new Composition( + new BinaryPacking(), new VariableByte()), data, + repeat, false); + testCodec(csvLog, sparsity, new Composition( + new BinaryPacking(), new VariableByte()), data, + repeat, true); + System.out.println(); + + testCodec(csvLog, sparsity, new Composition( + new NewPFD(), new VariableByte()), data, + repeat, false); + testCodec(csvLog, sparsity, new Composition( + new NewPFD(), new VariableByte()), data, + repeat, false); + testCodec(csvLog, sparsity, new Composition( + new NewPFD(), new VariableByte()), data, + repeat, true); + System.out.println(); + + testCodec(csvLog, sparsity, new Composition( + new NewPFDS9(), new VariableByte()), data, + repeat, false); + testCodec(csvLog, sparsity, new Composition( + new NewPFDS9(), new VariableByte()), data, + repeat, false); + testCodec(csvLog, sparsity, new Composition( + new NewPFDS9(), new VariableByte()), data, + repeat, true); + System.out.println(); + + testCodec(csvLog, sparsity, new Composition( + new NewPFDS16(), new VariableByte()), data, + repeat, false); + testCodec(csvLog, sparsity, new Composition( + new NewPFDS16(), new VariableByte()), data, + repeat, false); + testCodec(csvLog, sparsity, new Composition( + new NewPFDS16(), new VariableByte()), data, + repeat, true); + System.out.println(); + + testCodec(csvLog, sparsity, new Composition( + new OptPFD(), new VariableByte()), data, + repeat, false); + testCodec(csvLog, sparsity, new Composition( + new OptPFD(), new VariableByte()), data, + repeat, false); + testCodec(csvLog, sparsity, new Composition( + new OptPFD(), new VariableByte()), data, + repeat, true); + System.out.println(); + + testCodec(csvLog, sparsity, new Composition( + new OptPFDS9(), new VariableByte()), data, + repeat, false); + testCodec(csvLog, sparsity, new Composition( + new OptPFDS9(), new VariableByte()), data, + repeat, false); + testCodec(csvLog, sparsity, new Composition( + new OptPFDS9(), new VariableByte()), data, + repeat, true); + System.out.println(); + + testCodec(csvLog, sparsity, new Composition( + new OptPFDS16(), new VariableByte()), data, + repeat, false); + testCodec(csvLog, sparsity, new Composition( + new OptPFDS16(), new VariableByte()), data, + repeat, false); + testCodec(csvLog, sparsity, new Composition( + new OptPFDS16(), new VariableByte()), data, + repeat, true); + System.out.println(); + + + testCodec(csvLog, sparsity, new Simple16(), data, + repeat, false); + testCodec(csvLog, sparsity, new Simple16(), data, + repeat, false); + testCodec(csvLog, sparsity, new Simple16(), data, + repeat, true); + System.out.println(); + + testCodec(csvLog, sparsity, new Simple9(), data, + repeat, false); + testCodec(csvLog, sparsity, new Simple9(), data, + repeat, false); + testCodec(csvLog, sparsity, new Simple9(), data, + repeat, true); + System.out.println(); + + testCodec(csvLog, sparsity, new GroupSimple9(), data, + repeat, false); + testCodec(csvLog, sparsity, new GroupSimple9(), data, + repeat, false); + testCodec(csvLog, sparsity, new GroupSimple9(), data, + repeat, true); + System.out.println(); + + { + IntegerCODEC c = new Composition( + new XorBinaryPacking(), + new VariableByte()); + testCodec(csvLog, sparsity, c, data, repeat, + false); + testCodec(csvLog, sparsity, c, data, repeat, + false); + testCodec(csvLog, sparsity, c, data, repeat, + true); + System.out.println(); + } + + { + IntegerCODEC c = new Composition( + new DeltaZigzagBinaryPacking(), + new DeltaZigzagVariableByte()); + testCodec(csvLog, sparsity, c, data, repeat, + false); + testCodec(csvLog, sparsity, c, data, repeat, + false); + testCodec(csvLog, sparsity, c, data, repeat, + true); + System.out.println(); + } + + } + } +} diff --git a/src/main/java/me/lemire/integercompression/benchmarktools/BenchmarkBitPacking.java b/src/main/java/me/lemire/integercompression/benchmarktools/BenchmarkBitPacking.java new file mode 100644 index 0000000..3380d36 --- /dev/null +++ b/src/main/java/me/lemire/integercompression/benchmarktools/BenchmarkBitPacking.java @@ -0,0 +1,154 @@ +/** + * This code is released under the + * Apache License Version 2.0 http://www.apache.org/licenses/. + * + * (c) Daniel Lemire, http://lemire.me/en/ + */ +package me.lemire.integercompression.benchmarktools; + +import java.text.DecimalFormat; +import java.util.Arrays; +import java.util.Random; + +import me.lemire.integercompression.BitPacking; +import me.lemire.integercompression.differential.Delta; +import me.lemire.integercompression.differential.IntegratedBitPacking; + +/** + * Class used to benchmark the speed of bit packing. (For expert use.) + * + * @author Daniel Lemire + * + */ +public class BenchmarkBitPacking { + + private static void test(boolean verbose) { + DecimalFormat dfspeed = new DecimalFormat("0"); + final int N = 32; + final int times = 100000; + Random r = new Random(0); + int[] data = new int[N]; + int[] compressed = new int[N]; + int[] uncompressed = new int[N]; + for (int bit = 0; bit < 31; ++bit) { + long comp = 0; + long compwm = 0; + long decomp = 0; + for (int t = 0; t < times; ++t) { + for (int k = 0; k < N; ++k) { + data[k] = r.nextInt(1 << bit); + } + long time1 = System.nanoTime(); + BitPacking + .fastpack(data, 0, compressed, 0, bit); + long time2 = System.nanoTime(); + BitPacking.fastpackwithoutmask(data, 0, + compressed, 0, bit); + long time3 = System.nanoTime(); + BitPacking.fastunpack(compressed, 0, + uncompressed, 0, bit); + long time4 = System.nanoTime(); + comp += time2 - time1; + compwm += time3 - time2; + decomp += time4 - time3; + } + if (verbose) + System.out.println("bit = " + + bit + + " comp. speed = " + + dfspeed.format(N * times * 1000.0 + / (comp)) + + " comp. speed wm = " + + dfspeed.format(N * times * 1000.0 + / (compwm)) + + " decomp. speed = " + + dfspeed.format(N * times * 1000.0 + / (decomp))); + } + } + + private static void testWithDeltas(boolean verbose) { + DecimalFormat dfspeed = new DecimalFormat("0"); + final int N = 32; + final int times = 100000; + Random r = new Random(0); + int[] data = new int[N]; + int[] compressed = new int[N]; + int[] icompressed = new int[N]; + int[] uncompressed = new int[N]; + for (int bit = 1; bit < 31; ++bit) { + long comp = 0; + long decomp = 0; + long icomp = 0; + long idecomp = 0; + for (int t = 0; t < times; ++t) { + data[0] = r.nextInt(1 << bit); + for (int k = 1; k < N; ++k) { + data[k] = r.nextInt(1 << bit) + + data[k - 1]; + } + int[] tmpdata = Arrays + .copyOf(data, data.length); + long time1 = System.nanoTime(); + Delta.delta(tmpdata); + BitPacking.fastpackwithoutmask(tmpdata, 0, + compressed, 0, bit); + long time2 = System.nanoTime(); + BitPacking.fastunpack(compressed, 0, + uncompressed, 0, bit); + Delta.fastinverseDelta(uncompressed); + long time3 = System.nanoTime(); + if (!Arrays.equals(data, uncompressed)) + throw new RuntimeException("bug"); + comp += time2 - time1; + decomp += time3 - time2; + tmpdata = Arrays.copyOf(data, data.length); + time1 = System.nanoTime(); + IntegratedBitPacking.integratedpack(0, tmpdata, + 0, icompressed, 0, bit); + time2 = System.nanoTime(); + IntegratedBitPacking.integratedunpack(0, + icompressed, 0, uncompressed, 0, bit); + time3 = System.nanoTime(); + if (!Arrays.equals(icompressed, compressed)) + throw new RuntimeException("ibug " + + bit); + if (!Arrays.equals(data, uncompressed)) + throw new RuntimeException("bug " + bit); + icomp += time2 - time1; + idecomp += time3 - time2; + } + if (verbose) + System.out.println("bit = " + + bit + + " comp. speed = " + + dfspeed.format(N * times * 1000.0 + / (comp)) + + " decomp. speed = " + + dfspeed.format(N * times * 1000.0 + / (decomp)) + + " icomp. speed = " + + dfspeed.format(N * times * 1000.0 + / (icomp)) + + " idecomp. speed = " + + dfspeed.format(N * times * 1000.0 + / (idecomp))); + } + } + + /** + * Main method + * + * @param args + * command-line arguments + */ + public static void main(String[] args) { + System.out.println("Testing packing and delta "); + testWithDeltas(false); + testWithDeltas(true); + System.out.println("Testing packing alone "); + test(false); + test(true); + } + +} diff --git a/src/main/java/me/lemire/integercompression/benchmarktools/BenchmarkCSV.java b/src/main/java/me/lemire/integercompression/benchmarktools/BenchmarkCSV.java new file mode 100644 index 0000000..3115f0a --- /dev/null +++ b/src/main/java/me/lemire/integercompression/benchmarktools/BenchmarkCSV.java @@ -0,0 +1,314 @@ +package me.lemire.integercompression.benchmarktools; + +import me.lemire.integercompression.*; +import me.lemire.integercompression.differential.IntegratedBinaryPacking; +import me.lemire.integercompression.differential.IntegratedByteIntegerCODEC; +import me.lemire.integercompression.differential.IntegratedComposition; +import me.lemire.integercompression.differential.IntegratedIntegerCODEC; +import me.lemire.integercompression.differential.IntegratedVariableByte; + +import java.io.*; +import java.util.ArrayList; +import java.util.Arrays; + +/** + * This will run benchmarks using a set of posting lists stored as CSV files. + * + * @author lemire + * + */ +public class BenchmarkCSV { + static IntegratedIntegerCODEC codecs[] = { + new IntegratedComposition(new IntegratedBinaryPacking(), + new IntegratedVariableByte()) }; + static IntegratedByteIntegerCODEC bcodecs[] = { new IntegratedVariableByte() }; + static IntegerCODEC regcodecs[] = { + new Composition(new FastPFOR128(), new VariableByte()), + new Composition(new FastPFOR(), new VariableByte()), + new Composition(new BinaryPacking(), new VariableByte()) }; + static ByteIntegerCODEC regbcodecs[] = { new VariableByte() }; + + private static ArrayList loadIntegers(final String filename, final Format f) + throws IOException { + int misparsed = 0; + if (f == Format.ONEARRAYPERLINE) { + ArrayList answer = new ArrayList(); + BufferedReader br = new BufferedReader(new FileReader( + filename)); + String s; + while ((s = br.readLine()) != null) { + String[] numbers = s.split("[,;;]"); // that's + // slow + int[] a = new int[numbers.length]; + for (int k = 0; k < numbers.length; ++k) { + try { + a[k] = Integer + .parseInt(numbers[k] + .trim()); + } catch (java.lang.NumberFormatException nfe) { + if (misparsed == 0) + System.err.println(nfe); + ++misparsed; + } + } + answer.add(a); + } + if (misparsed > 0) + System.out.println("Failed to parse " + + misparsed + " entries"); + br.close(); + return answer; + } else if (f == Format.ONEARRAYPERFILE) { + ArrayList answer = new ArrayList(); + BufferedReader br = new BufferedReader(new FileReader( + filename)); + String s; + while ((s = br.readLine()) != null) { + String[] numbers = s.split("[,;;]");// that's + // slow + for (int k = 0; k < numbers.length; ++k) { + try { + answer.add(Integer + .parseInt(numbers[k] + .trim())); + } catch (java.lang.NumberFormatException nfe) { + if (misparsed == 0) + System.err.println(nfe); + ++misparsed; + } + } + } + int[] actualanswer = new int[answer.size()]; + for (int i = 0; i < answer.size(); ++i) + actualanswer[i] = answer.get(i); + ArrayList wrap = new ArrayList(); + wrap.add(actualanswer); + if (misparsed > 0) + System.out.println("Failed to parse " + + misparsed + " entries"); + br.close(); + return wrap; + } else { + ArrayList answer = new ArrayList(); + BufferedReader br = new BufferedReader(new FileReader( + filename)); + String s; + while ((s = br.readLine()) != null) { + try { + answer.add(Integer.parseInt(s.trim())); + } catch (java.lang.NumberFormatException nfe) { + if (misparsed == 0) + System.err.println(nfe); + ++misparsed; + } + } + int[] actualanswer = new int[answer.size()]; + for (int i = 0; i < answer.size(); ++i) + actualanswer[i] = answer.get(i); + ArrayList wrap = new ArrayList(); + wrap.add(actualanswer); + if (misparsed > 0) + System.out.println("Failed to parse " + + misparsed + " entries"); + br.close(); + return wrap; + } + } + + private enum Format { + ONEARRAYPERLINE, ONEARRAYPERFILE, ONEINTPERLINE + } + + private enum CompressionMode { + AS_IS, DELTA + } + + /** + * @param args command-line arguments + * @throws IOException when some IO error occurs + */ + public static void main(final String[] args) throws IOException { + Format myformat = Format.ONEARRAYPERLINE; + CompressionMode cm = CompressionMode.DELTA; + ArrayList files = new ArrayList(); + for (String s : args) { + if (s.startsWith("-")) {// it is a flag + if (s.equals("--onearrayperfile")) + myformat = Format.ONEARRAYPERFILE; + else if (s.equals("--nodelta")) + cm = CompressionMode.AS_IS; + else if (s.equals("--oneintperline")) + myformat = Format.ONEINTPERLINE; + else + throw new RuntimeException( + "I don't understand: " + s); + } else {// it is a filename + files.add(s); + } + } + if (myformat == Format.ONEARRAYPERFILE) + System.out.println("Treating each file as one array."); + else if (myformat == Format.ONEARRAYPERLINE) + System.out + .println("Each line of each file is an array: use --onearrayperfile or --oneintperline to change."); + else if (myformat == Format.ONEINTPERLINE) + System.out + .println("Treating each file as one array, with one integer per line."); + if (cm == CompressionMode.AS_IS) + System.out + .println("Compressing the integers 'as is' (no differential coding)"); + else + System.out + .println("Using differential coding (arrays will be sorted): use --nodelta to prevent sorting"); + ArrayList data = new ArrayList(); + for (String fn : files) + for (int[] x : loadIntegers(fn, myformat)) + data.add(x); + System.out.println("Loaded " + data.size() + " array(s)"); + if (cm == CompressionMode.DELTA) { + System.out + .println("Sorting the arrray(s) because you are using differential coding"); + for (int[] x : data) + Arrays.sort(x); + } + bench(data, cm, false); + bench(data, cm, false); + bench(data, cm, true); + bytebench(data, cm, false); + bytebench(data, cm, false); + bytebench(data, cm, true); + } + + private static void bench(ArrayList postings, CompressionMode cm, + boolean verbose) { + int maxlength = 0; + for (int[] x : postings) + if (maxlength < x.length) + maxlength = x.length; + if (verbose) + System.out.println("Max array length: " + maxlength); + int[] compbuffer = new int[2 * maxlength + 1024]; + int[] decompbuffer = new int[maxlength]; + if (verbose) + System.out.println("Scheme -- bits/int -- speed (mis)"); + for (IntegerCODEC c : (cm == CompressionMode.DELTA ? codecs + : regcodecs)) { + long bef = 0; + long aft = 0; + long decomptime = 0; + long volumein = 0; + long volumeout = 0; + int[][] compdata = new int[postings.size()][]; + for (int k = 0; k < postings.size(); ++k) { + int[] in = postings.get(k); + IntWrapper inpos = new IntWrapper(0); + IntWrapper outpos = new IntWrapper(0); + c.compress(in, inpos, in.length, compbuffer, + outpos); + int clength = outpos.get(); + inpos = new IntWrapper(0); + outpos = new IntWrapper(0); + c.uncompress(compbuffer, inpos, clength, + decompbuffer, outpos); + volumein += in.length; + volumeout += clength; + + if (outpos.get() != in.length) + throw new RuntimeException("bug"); + for (int z = 0; z < in.length; ++z) + if (in[z] != decompbuffer[z]) + throw new RuntimeException( + "bug"); + compdata[k] = Arrays + .copyOf(compbuffer, clength); + } + bef = System.nanoTime(); + for (int[] cin : compdata) { + IntWrapper inpos = new IntWrapper(0); + IntWrapper outpos = new IntWrapper(0); + c.uncompress(cin, inpos, cin.length, + decompbuffer, outpos); + if (inpos.get() != cin.length) + throw new RuntimeException("bug"); + } + aft = System.nanoTime(); + decomptime += (aft - bef); + double bitsPerInt = volumeout * 32.0 / volumein; + double decompressSpeed = volumein * 1000.0 + / (decomptime); + if (verbose) + System.out.println(c.toString() + + "\t" + + String.format("\t%1$.2f\t%2$.2f", + bitsPerInt, decompressSpeed)); + + } + } + + private static void bytebench(ArrayList postings, + CompressionMode cm, boolean verbose) { + int maxlength = 0; + for (int[] x : postings) + if (maxlength < x.length) + maxlength = x.length; + if (verbose) + System.out.println("Max array length: " + maxlength); + byte[] compbuffer = new byte[6 * (maxlength + 1024)]; + int[] decompbuffer = new int[maxlength]; + if (verbose) + System.out.println("Scheme -- bits/int -- speed (mis)"); + for (ByteIntegerCODEC c : (cm == CompressionMode.DELTA ? bcodecs + : regbcodecs)) { + long bef = 0; + long aft = 0; + long decomptime = 0; + long volumein = 0; + long volumeout = 0; + byte[][] compdata = new byte[postings.size()][]; + for (int k = 0; k < postings.size(); ++k) { + int[] in = postings.get(k); + IntWrapper inpos = new IntWrapper(0); + IntWrapper outpos = new IntWrapper(0); + c.compress(in, inpos, in.length, compbuffer, + outpos); + int clength = outpos.get(); + inpos = new IntWrapper(0); + outpos = new IntWrapper(0); + c.uncompress(compbuffer, inpos, clength, + decompbuffer, outpos); + volumein += in.length; + volumeout += clength; + + if (outpos.get() != in.length) + throw new RuntimeException("bug"); + for (int z = 0; z < in.length; ++z) + if (in[z] != decompbuffer[z]) + throw new RuntimeException( + "bug"); + compdata[k] = Arrays + .copyOf(compbuffer, clength); + } + bef = System.nanoTime(); + for (byte[] cin : compdata) { + IntWrapper inpos = new IntWrapper(0); + IntWrapper outpos = new IntWrapper(0); + c.uncompress(cin, inpos, cin.length, + decompbuffer, outpos); + if (inpos.get() != cin.length) + throw new RuntimeException("bug"); + } + aft = System.nanoTime(); + decomptime += (aft - bef); + double bitsPerInt = volumeout * 8.0 / volumein; + double decompressSpeed = volumein * 1000.0 + / (decomptime); + if (verbose) + System.out.println(c.toString() + + "\t" + + String.format("\t%1$.2f\t%2$.2f", + bitsPerInt, decompressSpeed)); + + } + } + +} diff --git a/src/main/java/me/lemire/integercompression/benchmarktools/BenchmarkOffsettedSeries.java b/src/main/java/me/lemire/integercompression/benchmarktools/BenchmarkOffsettedSeries.java new file mode 100644 index 0000000..c31411d --- /dev/null +++ b/src/main/java/me/lemire/integercompression/benchmarktools/BenchmarkOffsettedSeries.java @@ -0,0 +1,295 @@ +/** + * This code is released under the + * Apache License Version 2.0 http://www.apache.org/licenses/. + */ +package me.lemire.integercompression.benchmarktools; + +import java.io.File; +import java.io.PrintWriter; +import java.util.Arrays; +import java.util.Random; + +import me.lemire.integercompression.BinaryPacking; +import me.lemire.integercompression.DeltaZigzagBinaryPacking; +import me.lemire.integercompression.DeltaZigzagVariableByte; +import me.lemire.integercompression.FastPFOR; +import me.lemire.integercompression.FastPFOR128; +import me.lemire.integercompression.IntWrapper; +import me.lemire.integercompression.IntegerCODEC; +import me.lemire.integercompression.JustCopy; +import me.lemire.integercompression.differential.IntegratedBinaryPacking; +import me.lemire.integercompression.differential.XorBinaryPacking; + +/** + * Simple synthetic benchmark + * + */ +public class BenchmarkOffsettedSeries { + private static final int DEFAULT_MEAN = 1 << 20; + private static final int DEFAULT_RANGE = 1 << 10; + private static final int DEFAULT_REPEAT = 5; + private static final int DEFAULT_WARMUP = 2; + + + /** + * Run benchmark. + * + * @param csvWriter + * Write for results in CSV. + * @param count + * Count of data chunks. + * @param length + * Length of a data chunk. + */ + public static void run(final PrintWriter csvWriter, final int count, final int length) { + IntegerCODEC[] codecs = { new JustCopy(), new BinaryPacking(), + new DeltaZigzagBinaryPacking(), + new DeltaZigzagVariableByte(), + new IntegratedBinaryPacking(), new XorBinaryPacking(), + new FastPFOR128(), new FastPFOR()}; + + csvWriter + .format("\"Dataset\",\"CODEC\",\"Bits per int\"," + + "\"Compress speed (MiS)\",\"Decompress speed (MiS)\"\n"); + + benchmark(csvWriter, codecs, count, length, DEFAULT_MEAN, + DEFAULT_RANGE); + benchmark(csvWriter, codecs, count, length, DEFAULT_MEAN >> 5, + DEFAULT_RANGE); + + IntegerCODEC[] codecs2 = { new JustCopy(), new BinaryPacking(), + new DeltaZigzagBinaryPacking(), + new DeltaZigzagVariableByte(), + new IntegratedBinaryPacking(), new XorBinaryPacking(), + new FastPFOR128(),new FastPFOR(), }; + + int freq = length / 4; + benchmarkSine(csvWriter, codecs2, count, length, + DEFAULT_MEAN >> 0, DEFAULT_RANGE >> 0, freq); + benchmarkSine(csvWriter, codecs2, count, length, + DEFAULT_MEAN >> 5, DEFAULT_RANGE >> 0, freq); + benchmarkSine(csvWriter, codecs2, count, length, + DEFAULT_MEAN >> 10, DEFAULT_RANGE >> 0, freq); + benchmarkSine(csvWriter, codecs2, count, length, + DEFAULT_MEAN >> 0, DEFAULT_RANGE >> 2, freq); + benchmarkSine(csvWriter, codecs2, count, length, + DEFAULT_MEAN >> 5, DEFAULT_RANGE >> 2, freq); + benchmarkSine(csvWriter, codecs2, count, length, + DEFAULT_MEAN >> 10, DEFAULT_RANGE >> 2, freq); + benchmarkSine(csvWriter, codecs2, count, length, + DEFAULT_MEAN >> 0, DEFAULT_RANGE >> 4, freq); + benchmarkSine(csvWriter, codecs2, count, length, + DEFAULT_MEAN >> 5, DEFAULT_RANGE >> 4, freq); + benchmarkSine(csvWriter, codecs2, count, length, + DEFAULT_MEAN >> 10, DEFAULT_RANGE >> 4, freq); + } + + private static void benchmarkSine(final PrintWriter csvWriter, + final IntegerCODEC[] codecs, final int count, final int length, final int mean, + final int range, final int freq) { + String dataProp = String.format( + "(mean=%1$d range=%2$d freq=%3$d)", mean, range, freq); + int[][] data = generateSineDataChunks(0, count, length, mean, + range, freq); + benchmark(csvWriter, "Sine " + dataProp, codecs, data, + DEFAULT_REPEAT, DEFAULT_WARMUP); + benchmark(csvWriter, "Sine+delta " + dataProp, codecs, data, + DEFAULT_REPEAT, DEFAULT_WARMUP); + } + + private static void benchmark(final PrintWriter csvWriter, final IntegerCODEC[] codecs, + final int count, final int length, final int mean, final int range) { + String dataProp = String.format("(mean=%1$d range=%2$d)", mean, + range); + + int[][] randData = generateDataChunks(0, count, length, mean, + range); + int[][] deltaData = deltaDataChunks(randData); + int[][] sortedData = sortDataChunks(randData); + int[][] sortedDeltaData = deltaDataChunks(sortedData); + + benchmark(csvWriter, "Random " + dataProp, codecs, randData, + DEFAULT_REPEAT, DEFAULT_WARMUP); + benchmark(csvWriter, "Random+delta " + dataProp, codecs, + deltaData, DEFAULT_REPEAT, DEFAULT_WARMUP); + benchmark(csvWriter, "Sorted " + dataProp, codecs, sortedData, + DEFAULT_REPEAT, DEFAULT_WARMUP); + benchmark(csvWriter, "Sorted+delta " + dataProp, codecs, + sortedDeltaData, DEFAULT_REPEAT, DEFAULT_WARMUP); + } + + private static void benchmark(final PrintWriter csvWriter, final String dataName, + final IntegerCODEC[] codecs, final int[][] data, final int repeat, final int warmup) { + System.out.println("Processing: " + dataName); + for (IntegerCODEC codec : codecs) { + String codecName = codec.toString(); + for (int i = 0; i < warmup; ++i) { + benchmark(null, null, null, codec, data, repeat); + } + benchmark(csvWriter, dataName, codecName, codec, data, + repeat); + } + } + + private static void benchmark(PrintWriter csvWriter, String dataName, + String codecName, IntegerCODEC codec, int[][] data, int repeat) { + PerformanceLogger logger = new PerformanceLogger(); + + int maxLen = getMaxLen(data); + int[] compressBuffer = new int[4 * maxLen + 1024]; + int[] decompressBuffer = new int[maxLen]; + + for (int i = 0; i < repeat; ++i) { + for (int[] array : data) { + int compSize = compress(logger, codec, array, + compressBuffer); + int decompSize = decompress(logger, codec, + compressBuffer, compSize, + decompressBuffer); + checkArray(array, decompressBuffer, decompSize, + codec); + } + } + + if (csvWriter != null) { + csvWriter.format( + "\"%1$s\",\"%2$s\",%3$.2f,%4$.0f,%5$.0f\n", + dataName, codecName, logger.getBitPerInt(), + logger.getCompressSpeed(), + logger.getDecompressSpeed()); + } + } + + private static void checkArray(int[] expected, int[] actualArray, + int actualLen, IntegerCODEC codec) { + if (actualLen != expected.length) { + throw new RuntimeException("Length mismatch:" + + " expected=" + expected.length + " actual=" + + actualLen + " codec=" + codec.toString()); + } + for (int i = 0; i < expected.length; ++i) { + if (actualArray[i] != expected[i]) { + throw new RuntimeException("Value mismatch: " + + " where=" + i + " expected=" + + expected[i] + " actual=" + + actualArray[i] + " codec=" + + codec.toString()); + } + } + } + + private static int compress(PerformanceLogger logger, IntegerCODEC codec, + int[] src, int[] dst) { + IntWrapper inpos = new IntWrapper(); + IntWrapper outpos = new IntWrapper(); + logger.compressionTimer.start(); + codec.compress(src, inpos, src.length, dst, outpos); + logger.compressionTimer.end(); + int outSize = outpos.get(); + logger.addOriginalSize(src.length); + logger.addCompressedSize(outSize); + return outSize; + } + + private static int decompress(PerformanceLogger logger, IntegerCODEC codec, + int[] src, int srcLen, int[] dst) { + IntWrapper inpos = new IntWrapper(); + IntWrapper outpos = new IntWrapper(); + logger.decompressionTimer.start(); + codec.uncompress(src, inpos, srcLen, dst, outpos); + logger.decompressionTimer.end(); + return outpos.get(); + } + + private static int getMaxLen(int[][] data) { + int maxLen = 0; + for (int[] array : data) { + if (array.length > maxLen) { + maxLen = array.length; + } + } + return maxLen; + } + + private static int[][] generateSineDataChunks(long seed, int count, + int length, int mean, int range, int freq) { + int[][] chunks = new int[count][]; + Random r = new Random(seed); + for (int i = 0; i < count; ++i) { + int[] chunk = chunks[i] = new int[length]; + int phase = r.nextInt(2 * freq); + for (int j = 0; j < length; ++j) { + double angle = 2.0 * Math.PI * (j + phase) + / freq; + chunk[j] = (int) (mean + Math.sin(angle) + * range); + } + } + return chunks; + } + + private static int[][] generateDataChunks(long seed, int count, + int length, int mean, int range) { + int offset = mean - range / 2; + int[][] chunks = new int[count][]; + Random r = new Random(seed); + for (int i = 0; i < count; ++i) { + int[] chunk = chunks[i] = new int[length]; + for (int j = 0; j < length; ++j) { + chunk[j] = r.nextInt(range) + offset; + } + } + return chunks; + } + + private static int[][] deltaDataChunks(int[][] src) { + int[][] dst = new int[src.length][]; + for (int i = 0; i < src.length; ++i) { + int[] s = src[i]; + int[] d = dst[i] = new int[s.length]; + int prev = 0; + for (int j = 0; j < s.length; ++j) { + d[j] = s[j] - prev; + prev = s[j]; + } + } + return dst; + } + + private static int[][] sortDataChunks(int[][] src) { + int[][] dst = new int[src.length][]; + for (int i = 0; i < src.length; ++i) { + dst[i] = Arrays.copyOf(src[i], src[i].length); + Arrays.sort(dst[i]); + } + return dst; + } + + /** + * @param args command-line arguments + * @throws Exception when some problem occurs + */ + public static void main(final String[] args) throws Exception { + File csvFile = new File( + String.format( + "benchmark-offsetted-%1$tY%1$tm%1$tdT%1$tH%1$tM%1$tS.csv", + System.currentTimeMillis())); + PrintWriter writer = null; + try { + writer = new PrintWriter(csvFile); + System.out + .println("# Results will be written into a CSV file: " + + csvFile.getName()); + System.out.println(); + BenchmarkOffsettedSeries.run(writer, 8 * 1024, 1280); + System.out.println(); + System.out + .println("# Results were written into a CSV file: " + + csvFile.getName()); + } finally { + if (writer != null) { + writer.close(); + } + } + } +} diff --git a/src/main/java/me/lemire/integercompression/benchmarktools/BenchmarkSkippable.java b/src/main/java/me/lemire/integercompression/benchmarktools/BenchmarkSkippable.java new file mode 100644 index 0000000..b930568 --- /dev/null +++ b/src/main/java/me/lemire/integercompression/benchmarktools/BenchmarkSkippable.java @@ -0,0 +1,339 @@ +/** + * This code is released under the + * Apache License Version 2.0 http://www.apache.org/licenses/. + * + * (c) Daniel Lemire, http://lemire.me/en/ + */ +package me.lemire.integercompression.benchmarktools; + +import me.lemire.integercompression.BinaryPacking; +import me.lemire.integercompression.FastPFOR; +import me.lemire.integercompression.FastPFOR128; +import me.lemire.integercompression.IntWrapper; +import me.lemire.integercompression.JustCopy; +import me.lemire.integercompression.NewPFD; +import me.lemire.integercompression.NewPFDS16; +import me.lemire.integercompression.NewPFDS9; +import me.lemire.integercompression.OptPFD; +import me.lemire.integercompression.OptPFDS16; +import me.lemire.integercompression.OptPFDS9; +import me.lemire.integercompression.Simple16; +import me.lemire.integercompression.Simple9; +import me.lemire.integercompression.SkippableComposition; +import me.lemire.integercompression.SkippableIntegerCODEC; +import me.lemire.integercompression.VariableByte; +import me.lemire.integercompression.differential.Delta; +import me.lemire.integercompression.differential.IntegratedBinaryPacking; +import me.lemire.integercompression.differential.IntegratedVariableByte; +import me.lemire.integercompression.differential.SkippableIntegratedComposition; +import me.lemire.integercompression.differential.SkippableIntegratedIntegerCODEC; +import me.lemire.integercompression.synth.ClusteredDataGenerator; + +import java.io.File; +import java.io.FileNotFoundException; +import java.io.PrintWriter; +import java.util.Arrays; + +/** + * + * Simple class meant to compare the speed of different schemes. + * + * @author Daniel Lemire + * + */ +public class BenchmarkSkippable { + + private static int compressWithSkipTable(Object c, int[] data, + int[] output, IntWrapper outpos, int[] metadata, int blocksize) { + int metapos = 0; + metadata[metapos++] = data.length; + IntWrapper inpos = new IntWrapper(); + int initvalue = 0; + IntWrapper ival = new IntWrapper(initvalue); + while (inpos.get() < data.length) { + metadata[metapos++] = outpos.get(); + metadata[metapos++] = initvalue; + if (c instanceof SkippableIntegerCODEC) { + int size = blocksize > data.length - inpos.get() ? data.length + - inpos.get() : blocksize; + initvalue = Delta.delta(data, inpos.get(), size, initvalue); + + ((SkippableIntegerCODEC) c).headlessCompress(data, inpos, + blocksize, output, outpos); + } else if (c instanceof SkippableIntegratedIntegerCODEC) { + ival.set(initvalue); + ((SkippableIntegratedIntegerCODEC) c).headlessCompress(data, + inpos, blocksize, output, outpos, ival); + initvalue = ival.get(); + } else { + throw new RuntimeException("Unrecognized codec " + c); + } + } + return metapos; + } + + private static int decompressFromSkipTable(Object c, int[] compressed, + IntWrapper compressedpos, int[] metadata, int blocksize, int[] data) { + int metapos = 0; + int length = metadata[metapos++]; + IntWrapper uncomppos = new IntWrapper(); + IntWrapper ival = new IntWrapper(); + while (uncomppos.get() < length) { + int num = blocksize; + if (num > length - uncomppos.get()) + num = length - uncomppos.get(); + int location = metadata[metapos++]; + int initvalue = metadata[metapos++]; + int outputlocation = uncomppos.get(); + if (location != compressedpos.get()) + throw new RuntimeException("Bug " + location + " " + + compressedpos.get() + " codec " + c); + if (c instanceof SkippableIntegerCODEC) { + ((SkippableIntegerCODEC) c).headlessUncompress(compressed, + compressedpos, compressed.length - uncomppos.get(), + data, uncomppos, num); + initvalue = Delta.fastinverseDelta(data, outputlocation, num, + initvalue); + } else if (c instanceof SkippableIntegratedIntegerCODEC) { + ival.set(initvalue); + ((SkippableIntegratedIntegerCODEC) c).headlessUncompress( + compressed, compressedpos, compressed.length + - uncomppos.get(), data, uncomppos, num, ival); + } else { + throw new RuntimeException("Unrecognized codec " + c); + } + } + return length; + } + + /** + * Standard benchmark + * + * @param csvLog + * Writer for CSV log. + * @param c + * the codec + * @param data + * arrays of input data + * @param repeat + * How many times to repeat the test + * @param verbose + * whether to output result on screen + */ + private static void testCodec(PrintWriter csvLog, int sparsity, Object c, + int[][] data, int repeat, boolean verbose) { + if (verbose) { + System.out.println("# " + c.toString()); + System.out + .println("# bits per int, compress speed (mis), decompression speed (mis) "); + } + + int N = data.length; + + int totalSize = 0; + int maxLength = 0; + for (int k = 0; k < N; ++k) { + totalSize += data[k].length; + if (data[k].length > maxLength) { + maxLength = data[k].length; + } + } + + // 4x + 1024 to account for the possibility of some negative + // compression. + int[] compressBuffer = new int[4 * maxLength + 1024]; + int[] decompressBuffer = new int[maxLength + 1024]; + int[] metadataBuffer = new int[maxLength]; + final int blocksize = 1024; + + // These variables hold time in microseconds (10^-6). + double compressTime = 0; + double decompressTime = 0; + final int times = 5; + + int size = 0; + + for (int r = 0; r < repeat; ++r) { + size = 0; + for (int k = 0; k < N; ++k) { + int[] backupdata = Arrays.copyOf(data[k], data[k].length); + + // compress data. + long beforeCompress = System.nanoTime() / 1000; + IntWrapper outpos = new IntWrapper(); + compressWithSkipTable(c, backupdata, compressBuffer, outpos, + metadataBuffer, blocksize); + long afterCompress = System.nanoTime() / 1000; + + // measure time of compression. + compressTime += afterCompress - beforeCompress; + final int thiscompsize = outpos.get(); + size += thiscompsize; + // dry run + int volume = 0; + { + IntWrapper compressedpos = new IntWrapper(0); + volume = decompressFromSkipTable(c, compressBuffer, + compressedpos, metadataBuffer, blocksize, + decompressBuffer); + + // let us check the answer + if (volume != backupdata.length) + throw new RuntimeException( + "Bad output size with codec " + c); + for (int j = 0; j < volume; ++j) { + if (data[k][j] != decompressBuffer[j]) + throw new RuntimeException("bug in codec " + c); + } + } + // extract (uncompress) data + long beforeDecompress = System.nanoTime() / 1000; + for (int t = 0; t < times; ++t) { + IntWrapper compressedpos = new IntWrapper(0); + volume = decompressFromSkipTable(c, compressBuffer, + compressedpos, metadataBuffer, blocksize, + decompressBuffer); + } + long afterDecompress = System.nanoTime() / 1000; + + // measure time of extraction (uncompression). + decompressTime += (afterDecompress - beforeDecompress) / times; + if (volume != data[k].length) + throw new RuntimeException("we have a bug (diff length) " + + c + " expected " + data[k].length + " got " + + volume); + + // verify: compare original array with + // compressed and + // uncompressed. + for (int m = 0; m < outpos.get(); ++m) { + if (decompressBuffer[m] != data[k][m]) { + throw new RuntimeException( + "we have a bug (actual difference), expected " + + data[k][m] + " found " + + decompressBuffer[m] + " at " + m); + } + } + } + } + + if (verbose) { + double bitsPerInt = size * 32.0 / totalSize; + long compressSpeed = Math + .round(totalSize * repeat / (compressTime)); + long decompressSpeed = Math.round(totalSize * repeat + / (decompressTime)); + System.out.println(String.format("\t%1$.2f\t%2$d\t%3$d", + bitsPerInt, compressSpeed, decompressSpeed)); + csvLog.format("\"%1$s\",%2$d,%3$.2f,%4$d,%5$d\n", c.toString(), + sparsity, bitsPerInt, compressSpeed, decompressSpeed); + csvLog.flush(); + } + } + + /** + * Main method. + * + * @param args + * command-line arguments + * @throws FileNotFoundException + * when we fail to create a new file + */ + public static void main(String args[]) throws FileNotFoundException { + System.out.println("# benchmark based on the ClusterData model from:"); + System.out.println("# Vo Ngoc Anh and Alistair Moffat. "); + System.out.println("# Index compression using 64-bit words."); + System.out + .println("# Softw. Pract. Exper.40, 2 (February 2010), 131-147. "); + System.out.println(); + + PrintWriter writer = null; + try { + File csvFile = new File(String.format( + "benchmark-%1$tY%1$tm%1$tdT%1$tH%1$tM%1$tS.csv", + System.currentTimeMillis())); + writer = new PrintWriter(csvFile); + System.out.println("# Results will be written into a CSV file: " + + csvFile.getName()); + System.out.println(); + test(writer, 20, 18, 10); + System.out.println(); + System.out.println("Results were written into a CSV file: " + + csvFile.getName()); + } finally { + if (writer != null) { + writer.close(); + } + } + } + + /** + * Generate test data. + * + * @param N + * How many input arrays to generate + * @param nbr + * How big (in log2) should the arrays be + * @param sparsity + * How sparse test data generated + */ + private static int[][] generateTestData(ClusteredDataGenerator dataGen, + int N, int nbr, int sparsity) { + final int[][] data = new int[N][]; + final int dataSize = (1 << (nbr + sparsity)); + for (int i = 0; i < N; ++i) { + data[i] = dataGen.generateClustered((1 << nbr), dataSize); + } + return data; + } + + static Object[] codecs = { + + new SkippableIntegratedComposition(new IntegratedBinaryPacking(), + new IntegratedVariableByte()), new JustCopy(), new VariableByte(), + + new SkippableComposition(new BinaryPacking(), new VariableByte()), + new SkippableComposition(new NewPFD(), new VariableByte()), + new SkippableComposition(new NewPFDS9(), new VariableByte()), + new SkippableComposition(new NewPFDS16(), new VariableByte()), + new SkippableComposition(new OptPFD(), new VariableByte()), + new SkippableComposition(new OptPFDS9(), new VariableByte()), + new SkippableComposition(new OptPFDS16(), new VariableByte()), + new SkippableComposition(new FastPFOR(), new VariableByte()), + new SkippableComposition(new FastPFOR128(), new VariableByte()), + new Simple9(), new Simple16() }; + + /** + * Generates data and calls other tests. + * + * @param csvLog + * Writer for CSV log. + * @param N + * How many input arrays to generate + * @param nbr + * how big (in log2) should the arrays be + * @param repeat + * How many times should we repeat tests. + */ + private static void test(PrintWriter csvLog, int N, int nbr, int repeat) { + csvLog.format("\"Algorithm\",\"Sparsity\",\"Bits per int\",\"Compress speed (MiS)\",\"Decompress speed (MiS)\"\n"); + ClusteredDataGenerator cdg = new ClusteredDataGenerator(); + final int max_sparsity = 31 - nbr; + + for (int sparsity = 1; sparsity < max_sparsity; sparsity+=4) { + System.out.println("# sparsity " + sparsity); + System.out.println("# generating random data..."); + int[][] data = generateTestData(cdg, N, nbr, sparsity); + System.out.println("# generating random data... ok."); + for (Object c : codecs) { + testCodec(csvLog, sparsity, c, data, repeat, false); + testCodec(csvLog, sparsity, c, data, repeat, false); + testCodec(csvLog, sparsity, c, data, repeat, true); + testCodec(csvLog, sparsity, c, data, repeat, true); + testCodec(csvLog, sparsity, c, data, repeat, true); + + } + + } + } +} diff --git a/src/main/java/me/lemire/integercompression/benchmarktools/PerformanceLogger.java b/src/main/java/me/lemire/integercompression/benchmarktools/PerformanceLogger.java new file mode 100644 index 0000000..ca97144 --- /dev/null +++ b/src/main/java/me/lemire/integercompression/benchmarktools/PerformanceLogger.java @@ -0,0 +1,75 @@ +/** + * This code is released under the + * Apache License Version 2.0 http://www.apache.org/licenses/. + */ +package me.lemire.integercompression.benchmarktools; + +/** + * PerformanceLogger for IntegerCODEC. + * + * @author MURAOKA Taro http://github.com/koron + */ +public final class PerformanceLogger { + static class Timer { + private long startNano; + private long duration = 0; + + public Timer() { + } + + public void start() { + this.startNano = System.nanoTime(); + } + + public long end() { + return this.duration += System.nanoTime() + - this.startNano; + } + + public long getDuration() { + return this.duration; + } + } + + final Timer compressionTimer = new Timer(); + + final Timer decompressionTimer = new Timer(); + + private long originalSize = 0; + + private long compressedSize = 0; + + long addOriginalSize(long value) { + return this.originalSize += value; + } + + long addCompressedSize(long value) { + return this.compressedSize += value; + } + + long getOriginalSize() { + return this.originalSize; + } + + long getCompressedSize() { + return this.compressedSize; + } + + double getBitPerInt() { + return this.compressedSize * 32.0 / this.originalSize; + } + + private static double getMiS(long size, long nanoTime) { + return (size * 1e-6) / (nanoTime * 1.0e-9); + } + + double getCompressSpeed() { + return getMiS(this.originalSize, + this.compressionTimer.getDuration()); + } + + double getDecompressSpeed() { + return getMiS(this.originalSize, + this.decompressionTimer.getDuration()); + } +} diff --git a/src/main/java/me/lemire/integercompression/differential/Delta.java b/src/main/java/me/lemire/integercompression/differential/Delta.java new file mode 100644 index 0000000..4f7c144 --- /dev/null +++ b/src/main/java/me/lemire/integercompression/differential/Delta.java @@ -0,0 +1,150 @@ +/** + * This code is released under the + * Apache License Version 2.0 http://www.apache.org/licenses/. + * + * (c) Daniel Lemire, http://lemire.me/en/ + */ + +package me.lemire.integercompression.differential; + +/** + * Generic class to compute differential coding. + * + * @author Daniel Lemire + * + */ +public final class Delta { + + /** + * Apply differential coding (in-place). + * + * @param data + * data to be modified + */ + public static void delta(int[] data) { + for (int i = data.length - 1; i > 0; --i) { + data[i] -= data[i - 1]; + } + } + + /** + * Apply differential coding (in-place) given an initial value. + * + * @param data + * data to be modified + * @param start + * starting index + * @param length + * number of integers to process + * @param init + * initial value + * @return next initial vale + */ + public static int delta(int[] data, int start, int length, int init) { + final int nextinit = data[start + length - 1]; + for (int i = length - 1; i > 0; --i) { + data[start + i] -= data[start + i - 1]; + } + data[start] -= init; + return nextinit; + } + + /** + * Compute differential coding given an initial value. Output is written + * to a provided array: must have length "length" or better. + * + * @param data + * data to be modified + * @param start + * starting index + * @param length + * number of integers to process + * @param init + * initial value + * @param out + * output array + * @return next initial vale + */ + public static int delta(int[] data, int start, int length, int init, + int[] out) { + for (int i = length - 1; i > 0; --i) { + out[i] = data[start + i] - data[start + i - 1]; + } + out[0] = data[start] - init; + return data[start + length - 1]; + } + + /** + * Undo differential coding (in-place). Effectively computes a prefix + * sum. + * + * @param data + * to be modified. + */ + public static void inverseDelta(int[] data) { + for (int i = 1; i < data.length; ++i) { + data[i] += data[i - 1]; + } + } + + /** + * Undo differential coding (in-place). Effectively computes a prefix + * sum. Like inverseDelta, only faster. + * + * @param data + * to be modified + */ + public static void fastinverseDelta(int[] data) { + int sz0 = data.length / 4 * 4; + int i = 1; + if (sz0 >= 4) { + int a = data[0]; + for (; i < sz0 - 4; i += 4) { + a = data[i] += a; + a = data[i + 1] += a; + a = data[i + 2] += a; + a = data[i + 3] += a; + } + } + + for (; i != data.length; ++i) { + data[i] += data[i - 1]; + } + } + + /** + * Undo differential coding (in-place). Effectively computes a prefix + * sum. Like inverseDelta, only faster. Uses an initial value. + * + * @param data + * to be modified + * @param start + * starting index + * @param length + * number of integers to process + * @param init + * initial value + * @return next initial value + */ + public static int fastinverseDelta(int[] data, int start, int length, + int init) { + data[start] += init; + int sz0 = length / 4 * 4; + int i = 1; + if (sz0 >= 4) { + int a = data[start]; + for (; i < sz0 - 4; i += 4) { + a = data[start + i] += a; + a = data[start + i + 1] += a; + a = data[start + i + 2] += a; + a = data[start + i + 3] += a; + } + } + + for (; i != length; ++i) { + data[start + i] += data[start + i - 1]; + } + return data[start + length - 1]; + } + +} diff --git a/src/main/java/me/lemire/integercompression/differential/IntegratedBinaryPacking.java b/src/main/java/me/lemire/integercompression/differential/IntegratedBinaryPacking.java new file mode 100644 index 0000000..f50a367 --- /dev/null +++ b/src/main/java/me/lemire/integercompression/differential/IntegratedBinaryPacking.java @@ -0,0 +1,183 @@ +/** + * This code is released under the + * Apache License Version 2.0 http://www.apache.org/licenses/. + * + * (c) Daniel Lemire, http://lemire.me/en/ + */ + +package me.lemire.integercompression.differential; + +import me.lemire.integercompression.BitPacking; +import me.lemire.integercompression.IntWrapper; +import me.lemire.integercompression.Util; + +/** + * Scheme based on a commonly used idea: can be extremely fast. + * + * You should only use this scheme on sorted arrays. Use BinaryPacking if you + * have unsorted arrays. + * + * It encodes integers in blocks of 32 integers. For arrays containing an + * arbitrary number of integers, you should use it in conjunction with another + * CODEC: + * + *
+ * IntegratedIntegerCODEC is = 
+ * new IntegratedComposition(new IntegratedBinaryPacking(), 
+ * new IntegratedVariableByte())
+ * 
+ * + *

+ * For details, please see + *

+ *

+ * Daniel Lemire and Leonid Boytsov, Decoding billions of integers per second + * through vectorization Software: Practice & Experience http://onlinelibrary.wiley.com/doi/10.1002/spe.2203/abstract http://arxiv.org/abs/1209.2137 + *

+ *

+ * Daniel Lemire, Leonid Boytsov, Nathan Kurz, SIMD Compression and the + * Intersection of Sorted Integers http://arxiv.org/abs/1401.6399 + *

+ * + * @author Daniel Lemire + * + */ +public class IntegratedBinaryPacking implements IntegratedIntegerCODEC, + SkippableIntegratedIntegerCODEC { + + public static final int BLOCK_SIZE = 32; + private static final int MAX_BIT_WIDTH = Integer.SIZE; + + @Override + public void compress(int[] in, IntWrapper inpos, int inlength, int[] out, + IntWrapper outpos) { + inlength = Util.greatestMultiple(inlength, BLOCK_SIZE); + if (inlength == 0) + return; + out[outpos.get()] = inlength; + outpos.increment(); + headlessCompress(in, inpos, inlength, out, outpos, new IntWrapper(0)); + } + + @Override + public void uncompress(int[] in, IntWrapper inpos, int inlength, int[] out, + IntWrapper outpos) { + if (inlength == 0) + return; + final int outlength = in[inpos.get()]; + inpos.increment(); + headlessUncompress(in,inpos,inlength,out,outpos,outlength, new IntWrapper(0)); + } + + @Override + public String toString() { + return this.getClass().getSimpleName(); + } + + @Override + public void headlessCompress(int[] in, IntWrapper inpos, int inlength, + int[] out, IntWrapper outpos, IntWrapper initvalue) { + inlength = Util.greatestMultiple(inlength, BLOCK_SIZE); + if (inlength == 0) + return; + int tmpoutpos = outpos.get(); + + int initoffset = initvalue.get(); + initvalue.set(in[inpos.get()+inlength -1]); + int s = inpos.get(); + for (; s + BLOCK_SIZE * 4 - 1 < inpos.get() + inlength; s += BLOCK_SIZE * 4) { + final int mbits1 = Util.maxdiffbits(initoffset, in, s, BLOCK_SIZE); + int initoffset2 = in[s + 31]; + final int mbits2 = Util.maxdiffbits(initoffset2, in, s + BLOCK_SIZE, BLOCK_SIZE); + int initoffset3 = in[s + BLOCK_SIZE + 31]; + final int mbits3 = Util + .maxdiffbits(initoffset3, in, s + 2 * BLOCK_SIZE, BLOCK_SIZE); + int initoffset4 = in[s + 2 * BLOCK_SIZE + 31]; + final int mbits4 = Util + .maxdiffbits(initoffset4, in, s + 3 * BLOCK_SIZE, BLOCK_SIZE); + out[tmpoutpos++] = (mbits1 << 24) | (mbits2 << 16) | (mbits3 << 8) + | (mbits4); + IntegratedBitPacking.integratedpack(initoffset, in, s, out, + tmpoutpos, mbits1); + tmpoutpos += mbits1; + IntegratedBitPacking.integratedpack(initoffset2, in, s + BLOCK_SIZE, out, + tmpoutpos, mbits2); + tmpoutpos += mbits2; + IntegratedBitPacking.integratedpack(initoffset3, in, s + 2 * BLOCK_SIZE, + out, tmpoutpos, mbits3); + tmpoutpos += mbits3; + IntegratedBitPacking.integratedpack(initoffset4, in, s + 3 * BLOCK_SIZE, + out, tmpoutpos, mbits4); + tmpoutpos += mbits4; + initoffset = in[s + 3 * BLOCK_SIZE + 31]; + } + for (; s < inpos.get() + inlength; s += BLOCK_SIZE ) { + final int mbits = Util.maxdiffbits(initoffset, in, s, BLOCK_SIZE); + out[tmpoutpos++] = mbits; + IntegratedBitPacking.integratedpack(initoffset, in, s, out, + tmpoutpos, mbits); + tmpoutpos += mbits; + initoffset = in[s + 31]; + } + inpos.add(inlength); + outpos.set(tmpoutpos); + } + + @Override + public void headlessUncompress(int[] in, IntWrapper inpos, int inlength, + int[] out, IntWrapper outpos, int num, IntWrapper initvalue) { + final int outlength = Util.greatestMultiple(num, BLOCK_SIZE); + int tmpinpos = inpos.get(); + int initoffset = initvalue.get(); + int s = outpos.get(); + for (; s + BLOCK_SIZE * 4 - 1 < outpos.get() + outlength; s += BLOCK_SIZE * 4) { + final int mbits1 = (in[tmpinpos] >>> 24); + final int mbits2 = (in[tmpinpos] >>> 16) & 0xFF; + final int mbits3 = (in[tmpinpos] >>> 8) & 0xFF; + final int mbits4 = (in[tmpinpos]) & 0xFF; + + ++tmpinpos; + IntegratedBitPacking.integratedunpack(initoffset, in, tmpinpos, + out, s, mbits1); + tmpinpos += mbits1; + initoffset = out[s + 31]; + IntegratedBitPacking.integratedunpack(initoffset, in, tmpinpos, + out, s + BLOCK_SIZE, mbits2); + tmpinpos += mbits2; + initoffset = out[s + BLOCK_SIZE + 31]; + IntegratedBitPacking.integratedunpack(initoffset, in, tmpinpos, + out, s + 2 * BLOCK_SIZE, mbits3); + tmpinpos += mbits3; + initoffset = out[s + 2 * BLOCK_SIZE + 31]; + IntegratedBitPacking.integratedunpack(initoffset, in, tmpinpos, + out, s + 3 * BLOCK_SIZE, mbits4); + tmpinpos += mbits4; + initoffset = out[s + 3 * BLOCK_SIZE + 31]; + } + for (; s < outpos.get() + outlength; s += BLOCK_SIZE) { + final int mbits = in[tmpinpos]; + ++tmpinpos; + IntegratedBitPacking.integratedunpack(initoffset, in, tmpinpos, + out, s, mbits); + initoffset = out[s + 31]; + + tmpinpos += mbits; + } + outpos.add(outlength); + initvalue.set(initoffset); + inpos.set(tmpinpos); + } + + @Override + public int maxHeadlessCompressedLength(IntWrapper compressedPositions, int inlength) { + int blockCount = inlength / BLOCK_SIZE; + int headersSizeInInts = blockCount / Integer.BYTES + (blockCount % Integer.BYTES); + int blocksSizeInInts = blockCount * MAX_BIT_WIDTH; + compressedPositions.add(blockCount * BLOCK_SIZE); + return headersSizeInInts + blocksSizeInInts; + } +} diff --git a/src/main/java/me/lemire/integercompression/differential/IntegratedBitPacking.java b/src/main/java/me/lemire/integercompression/differential/IntegratedBitPacking.java new file mode 100644 index 0000000..8b26f6b --- /dev/null +++ b/src/main/java/me/lemire/integercompression/differential/IntegratedBitPacking.java @@ -0,0 +1,3914 @@ +/** + * This code is released under the + * Apache License Version 2.0 http://www.apache.org/licenses/. + * + * (c) Daniel Lemire, http://lemire.me/en/ + */ + +package me.lemire.integercompression.differential; + +import java.util.Arrays; + +/** + * "Integrated" bit packing routines: they include both the bit packing and the + * differential coding. + * + * For details, please see + *

+ * Daniel Lemire and Leonid Boytsov, Decoding billions of integers per second + * through vectorization Software: Practice & Experience + * http://onlinelibrary.wiley.com/doi/10.1002/spe.2203/abstract + * http://arxiv.org/abs/1209.2137 + *

+ * + * @author Daniel Lemire + * + */ +public final class IntegratedBitPacking { + + /** + * Pack 32 integers as deltas with an initial value + * + * @param initoffset initial value (used to compute first delta) + * @param in input array + * @param inpos initial position in input array + * @param out output array + * @param outpos initial position in output array + * @param bit number of bits to use per integer + */ + public static void integratedpack(final int initoffset, final int[] in, + final int inpos, final int[] out, final int outpos, final int bit) { + switch (bit) { + case 0: + integratedpack0(initoffset, in, inpos, out, outpos); + break; + case 1: + integratedpack1(initoffset, in, inpos, out, outpos); + break; + case 2: + integratedpack2(initoffset, in, inpos, out, outpos); + break; + case 3: + integratedpack3(initoffset, in, inpos, out, outpos); + break; + case 4: + integratedpack4(initoffset, in, inpos, out, outpos); + break; + case 5: + integratedpack5(initoffset, in, inpos, out, outpos); + break; + case 6: + integratedpack6(initoffset, in, inpos, out, outpos); + break; + case 7: + integratedpack7(initoffset, in, inpos, out, outpos); + break; + case 8: + integratedpack8(initoffset, in, inpos, out, outpos); + break; + case 9: + integratedpack9(initoffset, in, inpos, out, outpos); + break; + case 10: + integratedpack10(initoffset, in, inpos, out, outpos); + break; + case 11: + integratedpack11(initoffset, in, inpos, out, outpos); + break; + case 12: + integratedpack12(initoffset, in, inpos, out, outpos); + break; + case 13: + integratedpack13(initoffset, in, inpos, out, outpos); + break; + case 14: + integratedpack14(initoffset, in, inpos, out, outpos); + break; + case 15: + integratedpack15(initoffset, in, inpos, out, outpos); + break; + case 16: + integratedpack16(initoffset, in, inpos, out, outpos); + break; + case 17: + integratedpack17(initoffset, in, inpos, out, outpos); + break; + case 18: + integratedpack18(initoffset, in, inpos, out, outpos); + break; + case 19: + integratedpack19(initoffset, in, inpos, out, outpos); + break; + case 20: + integratedpack20(initoffset, in, inpos, out, outpos); + break; + case 21: + integratedpack21(initoffset, in, inpos, out, outpos); + break; + case 22: + integratedpack22(initoffset, in, inpos, out, outpos); + break; + case 23: + integratedpack23(initoffset, in, inpos, out, outpos); + break; + case 24: + integratedpack24(initoffset, in, inpos, out, outpos); + break; + case 25: + integratedpack25(initoffset, in, inpos, out, outpos); + break; + case 26: + integratedpack26(initoffset, in, inpos, out, outpos); + break; + case 27: + integratedpack27(initoffset, in, inpos, out, outpos); + break; + case 28: + integratedpack28(initoffset, in, inpos, out, outpos); + break; + case 29: + integratedpack29(initoffset, in, inpos, out, outpos); + break; + case 30: + integratedpack30(initoffset, in, inpos, out, outpos); + break; + case 31: + integratedpack31(initoffset, in, inpos, out, outpos); + break; + case 32: + integratedpack32(initoffset, in, inpos, out, outpos); + break; + default: + throw new IllegalArgumentException( + "Unsupported bit width."); + } + } + + protected static void integratedpack0(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + // nothing + } + + protected static void integratedpack1(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + out[0 + outpos] = (in[0 + inpos] - initoffset) + | ((in[1 + inpos] - in[1 + inpos - 1]) << 1) + | ((in[2 + inpos] - in[2 + inpos - 1]) << 2) + | ((in[3 + inpos] - in[3 + inpos - 1]) << 3) + | ((in[4 + inpos] - in[4 + inpos - 1]) << 4) + | ((in[5 + inpos] - in[5 + inpos - 1]) << 5) + | ((in[6 + inpos] - in[6 + inpos - 1]) << 6) + | ((in[7 + inpos] - in[7 + inpos - 1]) << 7) + | ((in[8 + inpos] - in[8 + inpos - 1]) << 8) + | ((in[9 + inpos] - in[9 + inpos - 1]) << 9) + | ((in[10 + inpos] - in[10 + inpos - 1]) << 10) + | ((in[11 + inpos] - in[11 + inpos - 1]) << 11) + | ((in[12 + inpos] - in[12 + inpos - 1]) << 12) + | ((in[13 + inpos] - in[13 + inpos - 1]) << 13) + | ((in[14 + inpos] - in[14 + inpos - 1]) << 14) + | ((in[15 + inpos] - in[15 + inpos - 1]) << 15) + | ((in[16 + inpos] - in[16 + inpos - 1]) << 16) + | ((in[17 + inpos] - in[17 + inpos - 1]) << 17) + | ((in[18 + inpos] - in[18 + inpos - 1]) << 18) + | ((in[19 + inpos] - in[19 + inpos - 1]) << 19) + | ((in[20 + inpos] - in[20 + inpos - 1]) << 20) + | ((in[21 + inpos] - in[21 + inpos - 1]) << 21) + | ((in[22 + inpos] - in[22 + inpos - 1]) << 22) + | ((in[23 + inpos] - in[23 + inpos - 1]) << 23) + | ((in[24 + inpos] - in[24 + inpos - 1]) << 24) + | ((in[25 + inpos] - in[25 + inpos - 1]) << 25) + | ((in[26 + inpos] - in[26 + inpos - 1]) << 26) + | ((in[27 + inpos] - in[27 + inpos - 1]) << 27) + | ((in[28 + inpos] - in[28 + inpos - 1]) << 28) + | ((in[29 + inpos] - in[29 + inpos - 1]) << 29) + | ((in[30 + inpos] - in[30 + inpos - 1]) << 30) + | ((in[31 + inpos] - in[31 + inpos - 1]) << 31); + } + + protected static void integratedpack10(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + out[0 + outpos] = (in[0 + inpos] - initoffset) + | ((in[1 + inpos] - in[1 + inpos - 1]) << 10) + | ((in[2 + inpos] - in[2 + inpos - 1]) << 20) + | ((in[3 + inpos] - in[3 + inpos - 1]) << 30); + out[1 + outpos] = (in[3 + inpos] - in[3 + inpos - 1]) >>> (10 - 8) + | ((in[4 + inpos] - in[4 + inpos - 1]) << 8) + | ((in[5 + inpos] - in[5 + inpos - 1]) << 18) + | ((in[6 + inpos] - in[6 + inpos - 1]) << 28); + out[2 + outpos] = (in[6 + inpos] - in[6 + inpos - 1]) >>> (10 - 6) + | ((in[7 + inpos] - in[7 + inpos - 1]) << 6) + | ((in[8 + inpos] - in[8 + inpos - 1]) << 16) + | ((in[9 + inpos] - in[9 + inpos - 1]) << 26); + out[3 + outpos] = (in[9 + inpos] - in[9 + inpos - 1]) >>> (10 - 4) + | ((in[10 + inpos] - in[10 + inpos - 1]) << 4) + | ((in[11 + inpos] - in[11 + inpos - 1]) << 14) + | ((in[12 + inpos] - in[12 + inpos - 1]) << 24); + out[4 + outpos] = (in[12 + inpos] - in[12 + inpos - 1]) >>> (10 - 2) + | ((in[13 + inpos] - in[13 + inpos - 1]) << 2) + | ((in[14 + inpos] - in[14 + inpos - 1]) << 12) + | ((in[15 + inpos] - in[15 + inpos - 1]) << 22); + out[5 + outpos] = (in[16 + inpos] - in[16 + inpos - 1]) + | ((in[17 + inpos] - in[17 + inpos - 1]) << 10) + | ((in[18 + inpos] - in[18 + inpos - 1]) << 20) + | ((in[19 + inpos] - in[19 + inpos - 1]) << 30); + out[6 + outpos] = (in[19 + inpos] - in[19 + inpos - 1]) >>> (10 - 8) + | ((in[20 + inpos] - in[20 + inpos - 1]) << 8) + | ((in[21 + inpos] - in[21 + inpos - 1]) << 18) + | ((in[22 + inpos] - in[22 + inpos - 1]) << 28); + out[7 + outpos] = (in[22 + inpos] - in[22 + inpos - 1]) >>> (10 - 6) + | ((in[23 + inpos] - in[23 + inpos - 1]) << 6) + | ((in[24 + inpos] - in[24 + inpos - 1]) << 16) + | ((in[25 + inpos] - in[25 + inpos - 1]) << 26); + out[8 + outpos] = (in[25 + inpos] - in[25 + inpos - 1]) >>> (10 - 4) + | ((in[26 + inpos] - in[26 + inpos - 1]) << 4) + | ((in[27 + inpos] - in[27 + inpos - 1]) << 14) + | ((in[28 + inpos] - in[28 + inpos - 1]) << 24); + out[9 + outpos] = (in[28 + inpos] - in[28 + inpos - 1]) >>> (10 - 2) + | ((in[29 + inpos] - in[29 + inpos - 1]) << 2) + | ((in[30 + inpos] - in[30 + inpos - 1]) << 12) + | ((in[31 + inpos] - in[31 + inpos - 1]) << 22); + } + + protected static void integratedpack11(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + out[0 + outpos] = (in[0 + inpos] - initoffset) + | ((in[1 + inpos] - in[1 + inpos - 1]) << 11) + | ((in[2 + inpos] - in[2 + inpos - 1]) << 22); + out[1 + outpos] = (in[2 + inpos] - in[2 + inpos - 1]) >>> (11 - 1) + | ((in[3 + inpos] - in[3 + inpos - 1]) << 1) + | ((in[4 + inpos] - in[4 + inpos - 1]) << 12) + | ((in[5 + inpos] - in[5 + inpos - 1]) << 23); + out[2 + outpos] = (in[5 + inpos] - in[5 + inpos - 1]) >>> (11 - 2) + | ((in[6 + inpos] - in[6 + inpos - 1]) << 2) + | ((in[7 + inpos] - in[7 + inpos - 1]) << 13) + | ((in[8 + inpos] - in[8 + inpos - 1]) << 24); + out[3 + outpos] = (in[8 + inpos] - in[8 + inpos - 1]) >>> (11 - 3) + | ((in[9 + inpos] - in[9 + inpos - 1]) << 3) + | ((in[10 + inpos] - in[10 + inpos - 1]) << 14) + | ((in[11 + inpos] - in[11 + inpos - 1]) << 25); + out[4 + outpos] = (in[11 + inpos] - in[11 + inpos - 1]) >>> (11 - 4) + | ((in[12 + inpos] - in[12 + inpos - 1]) << 4) + | ((in[13 + inpos] - in[13 + inpos - 1]) << 15) + | ((in[14 + inpos] - in[14 + inpos - 1]) << 26); + out[5 + outpos] = (in[14 + inpos] - in[14 + inpos - 1]) >>> (11 - 5) + | ((in[15 + inpos] - in[15 + inpos - 1]) << 5) + | ((in[16 + inpos] - in[16 + inpos - 1]) << 16) + | ((in[17 + inpos] - in[17 + inpos - 1]) << 27); + out[6 + outpos] = (in[17 + inpos] - in[17 + inpos - 1]) >>> (11 - 6) + | ((in[18 + inpos] - in[18 + inpos - 1]) << 6) + | ((in[19 + inpos] - in[19 + inpos - 1]) << 17) + | ((in[20 + inpos] - in[20 + inpos - 1]) << 28); + out[7 + outpos] = (in[20 + inpos] - in[20 + inpos - 1]) >>> (11 - 7) + | ((in[21 + inpos] - in[21 + inpos - 1]) << 7) + | ((in[22 + inpos] - in[22 + inpos - 1]) << 18) + | ((in[23 + inpos] - in[23 + inpos - 1]) << 29); + out[8 + outpos] = (in[23 + inpos] - in[23 + inpos - 1]) >>> (11 - 8) + | ((in[24 + inpos] - in[24 + inpos - 1]) << 8) + | ((in[25 + inpos] - in[25 + inpos - 1]) << 19) + | ((in[26 + inpos] - in[26 + inpos - 1]) << 30); + out[9 + outpos] = (in[26 + inpos] - in[26 + inpos - 1]) >>> (11 - 9) + | ((in[27 + inpos] - in[27 + inpos - 1]) << 9) + | ((in[28 + inpos] - in[28 + inpos - 1]) << 20) + | ((in[29 + inpos] - in[29 + inpos - 1]) << 31); + out[10 + outpos] = (in[29 + inpos] - in[29 + inpos - 1]) >>> (11 - 10) + | ((in[30 + inpos] - in[30 + inpos - 1]) << 10) + | ((in[31 + inpos] - in[31 + inpos - 1]) << 21); + } + + protected static void integratedpack12(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + out[0 + outpos] = (in[0 + inpos] - initoffset) + | ((in[1 + inpos] - in[1 + inpos - 1]) << 12) + | ((in[2 + inpos] - in[2 + inpos - 1]) << 24); + out[1 + outpos] = (in[2 + inpos] - in[2 + inpos - 1]) >>> (12 - 4) + | ((in[3 + inpos] - in[3 + inpos - 1]) << 4) + | ((in[4 + inpos] - in[4 + inpos - 1]) << 16) + | ((in[5 + inpos] - in[5 + inpos - 1]) << 28); + out[2 + outpos] = (in[5 + inpos] - in[5 + inpos - 1]) >>> (12 - 8) + | ((in[6 + inpos] - in[6 + inpos - 1]) << 8) + | ((in[7 + inpos] - in[7 + inpos - 1]) << 20); + out[3 + outpos] = (in[8 + inpos] - in[8 + inpos - 1]) + | ((in[9 + inpos] - in[9 + inpos - 1]) << 12) + | ((in[10 + inpos] - in[10 + inpos - 1]) << 24); + out[4 + outpos] = (in[10 + inpos] - in[10 + inpos - 1]) >>> (12 - 4) + | ((in[11 + inpos] - in[11 + inpos - 1]) << 4) + | ((in[12 + inpos] - in[12 + inpos - 1]) << 16) + | ((in[13 + inpos] - in[13 + inpos - 1]) << 28); + out[5 + outpos] = (in[13 + inpos] - in[13 + inpos - 1]) >>> (12 - 8) + | ((in[14 + inpos] - in[14 + inpos - 1]) << 8) + | ((in[15 + inpos] - in[15 + inpos - 1]) << 20); + out[6 + outpos] = (in[16 + inpos] - in[16 + inpos - 1]) + | ((in[17 + inpos] - in[17 + inpos - 1]) << 12) + | ((in[18 + inpos] - in[18 + inpos - 1]) << 24); + out[7 + outpos] = (in[18 + inpos] - in[18 + inpos - 1]) >>> (12 - 4) + | ((in[19 + inpos] - in[19 + inpos - 1]) << 4) + | ((in[20 + inpos] - in[20 + inpos - 1]) << 16) + | ((in[21 + inpos] - in[21 + inpos - 1]) << 28); + out[8 + outpos] = (in[21 + inpos] - in[21 + inpos - 1]) >>> (12 - 8) + | ((in[22 + inpos] - in[22 + inpos - 1]) << 8) + | ((in[23 + inpos] - in[23 + inpos - 1]) << 20); + out[9 + outpos] = (in[24 + inpos] - in[24 + inpos - 1]) + | ((in[25 + inpos] - in[25 + inpos - 1]) << 12) + | ((in[26 + inpos] - in[26 + inpos - 1]) << 24); + out[10 + outpos] = (in[26 + inpos] - in[26 + inpos - 1]) >>> (12 - 4) + | ((in[27 + inpos] - in[27 + inpos - 1]) << 4) + | ((in[28 + inpos] - in[28 + inpos - 1]) << 16) + | ((in[29 + inpos] - in[29 + inpos - 1]) << 28); + out[11 + outpos] = (in[29 + inpos] - in[29 + inpos - 1]) >>> (12 - 8) + | ((in[30 + inpos] - in[30 + inpos - 1]) << 8) + | ((in[31 + inpos] - in[31 + inpos - 1]) << 20); + } + + protected static void integratedpack13(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + out[0 + outpos] = (in[0 + inpos] - initoffset) + | ((in[1 + inpos] - in[1 + inpos - 1]) << 13) + | ((in[2 + inpos] - in[2 + inpos - 1]) << 26); + out[1 + outpos] = (in[2 + inpos] - in[2 + inpos - 1]) >>> (13 - 7) + | ((in[3 + inpos] - in[3 + inpos - 1]) << 7) + | ((in[4 + inpos] - in[4 + inpos - 1]) << 20); + out[2 + outpos] = (in[4 + inpos] - in[4 + inpos - 1]) >>> (13 - 1) + | ((in[5 + inpos] - in[5 + inpos - 1]) << 1) + | ((in[6 + inpos] - in[6 + inpos - 1]) << 14) + | ((in[7 + inpos] - in[7 + inpos - 1]) << 27); + out[3 + outpos] = (in[7 + inpos] - in[7 + inpos - 1]) >>> (13 - 8) + | ((in[8 + inpos] - in[8 + inpos - 1]) << 8) + | ((in[9 + inpos] - in[9 + inpos - 1]) << 21); + out[4 + outpos] = (in[9 + inpos] - in[9 + inpos - 1]) >>> (13 - 2) + | ((in[10 + inpos] - in[10 + inpos - 1]) << 2) + | ((in[11 + inpos] - in[11 + inpos - 1]) << 15) + | ((in[12 + inpos] - in[12 + inpos - 1]) << 28); + out[5 + outpos] = (in[12 + inpos] - in[12 + inpos - 1]) >>> (13 - 9) + | ((in[13 + inpos] - in[13 + inpos - 1]) << 9) + | ((in[14 + inpos] - in[14 + inpos - 1]) << 22); + out[6 + outpos] = (in[14 + inpos] - in[14 + inpos - 1]) >>> (13 - 3) + | ((in[15 + inpos] - in[15 + inpos - 1]) << 3) + | ((in[16 + inpos] - in[16 + inpos - 1]) << 16) + | ((in[17 + inpos] - in[17 + inpos - 1]) << 29); + out[7 + outpos] = (in[17 + inpos] - in[17 + inpos - 1]) >>> (13 - 10) + | ((in[18 + inpos] - in[18 + inpos - 1]) << 10) + | ((in[19 + inpos] - in[19 + inpos - 1]) << 23); + out[8 + outpos] = (in[19 + inpos] - in[19 + inpos - 1]) >>> (13 - 4) + | ((in[20 + inpos] - in[20 + inpos - 1]) << 4) + | ((in[21 + inpos] - in[21 + inpos - 1]) << 17) + | ((in[22 + inpos] - in[22 + inpos - 1]) << 30); + out[9 + outpos] = (in[22 + inpos] - in[22 + inpos - 1]) >>> (13 - 11) + | ((in[23 + inpos] - in[23 + inpos - 1]) << 11) + | ((in[24 + inpos] - in[24 + inpos - 1]) << 24); + out[10 + outpos] = (in[24 + inpos] - in[24 + inpos - 1]) >>> (13 - 5) + | ((in[25 + inpos] - in[25 + inpos - 1]) << 5) + | ((in[26 + inpos] - in[26 + inpos - 1]) << 18) + | ((in[27 + inpos] - in[27 + inpos - 1]) << 31); + out[11 + outpos] = (in[27 + inpos] - in[27 + inpos - 1]) >>> (13 - 12) + | ((in[28 + inpos] - in[28 + inpos - 1]) << 12) + | ((in[29 + inpos] - in[29 + inpos - 1]) << 25); + out[12 + outpos] = (in[29 + inpos] - in[29 + inpos - 1]) >>> (13 - 6) + | ((in[30 + inpos] - in[30 + inpos - 1]) << 6) + | ((in[31 + inpos] - in[31 + inpos - 1]) << 19); + } + + protected static void integratedpack14(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + out[0 + outpos] = (in[0 + inpos] - initoffset) + | ((in[1 + inpos] - in[1 + inpos - 1]) << 14) + | ((in[2 + inpos] - in[2 + inpos - 1]) << 28); + out[1 + outpos] = (in[2 + inpos] - in[2 + inpos - 1]) >>> (14 - 10) + | ((in[3 + inpos] - in[3 + inpos - 1]) << 10) + | ((in[4 + inpos] - in[4 + inpos - 1]) << 24); + out[2 + outpos] = (in[4 + inpos] - in[4 + inpos - 1]) >>> (14 - 6) + | ((in[5 + inpos] - in[5 + inpos - 1]) << 6) + | ((in[6 + inpos] - in[6 + inpos - 1]) << 20); + out[3 + outpos] = (in[6 + inpos] - in[6 + inpos - 1]) >>> (14 - 2) + | ((in[7 + inpos] - in[7 + inpos - 1]) << 2) + | ((in[8 + inpos] - in[8 + inpos - 1]) << 16) + | ((in[9 + inpos] - in[9 + inpos - 1]) << 30); + out[4 + outpos] = (in[9 + inpos] - in[9 + inpos - 1]) >>> (14 - 12) + | ((in[10 + inpos] - in[10 + inpos - 1]) << 12) + | ((in[11 + inpos] - in[11 + inpos - 1]) << 26); + out[5 + outpos] = (in[11 + inpos] - in[11 + inpos - 1]) >>> (14 - 8) + | ((in[12 + inpos] - in[12 + inpos - 1]) << 8) + | ((in[13 + inpos] - in[13 + inpos - 1]) << 22); + out[6 + outpos] = (in[13 + inpos] - in[13 + inpos - 1]) >>> (14 - 4) + | ((in[14 + inpos] - in[14 + inpos - 1]) << 4) + | ((in[15 + inpos] - in[15 + inpos - 1]) << 18); + out[7 + outpos] = (in[16 + inpos] - in[16 + inpos - 1]) + | ((in[17 + inpos] - in[17 + inpos - 1]) << 14) + | ((in[18 + inpos] - in[18 + inpos - 1]) << 28); + out[8 + outpos] = (in[18 + inpos] - in[18 + inpos - 1]) >>> (14 - 10) + | ((in[19 + inpos] - in[19 + inpos - 1]) << 10) + | ((in[20 + inpos] - in[20 + inpos - 1]) << 24); + out[9 + outpos] = (in[20 + inpos] - in[20 + inpos - 1]) >>> (14 - 6) + | ((in[21 + inpos] - in[21 + inpos - 1]) << 6) + | ((in[22 + inpos] - in[22 + inpos - 1]) << 20); + out[10 + outpos] = (in[22 + inpos] - in[22 + inpos - 1]) >>> (14 - 2) + | ((in[23 + inpos] - in[23 + inpos - 1]) << 2) + | ((in[24 + inpos] - in[24 + inpos - 1]) << 16) + | ((in[25 + inpos] - in[25 + inpos - 1]) << 30); + out[11 + outpos] = (in[25 + inpos] - in[25 + inpos - 1]) >>> (14 - 12) + | ((in[26 + inpos] - in[26 + inpos - 1]) << 12) + | ((in[27 + inpos] - in[27 + inpos - 1]) << 26); + out[12 + outpos] = (in[27 + inpos] - in[27 + inpos - 1]) >>> (14 - 8) + | ((in[28 + inpos] - in[28 + inpos - 1]) << 8) + | ((in[29 + inpos] - in[29 + inpos - 1]) << 22); + out[13 + outpos] = (in[29 + inpos] - in[29 + inpos - 1]) >>> (14 - 4) + | ((in[30 + inpos] - in[30 + inpos - 1]) << 4) + | ((in[31 + inpos] - in[31 + inpos - 1]) << 18); + } + + protected static void integratedpack15(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + out[0 + outpos] = (in[0 + inpos] - initoffset) + | ((in[1 + inpos] - in[1 + inpos - 1]) << 15) + | ((in[2 + inpos] - in[2 + inpos - 1]) << 30); + out[1 + outpos] = (in[2 + inpos] - in[2 + inpos - 1]) >>> (15 - 13) + | ((in[3 + inpos] - in[3 + inpos - 1]) << 13) + | ((in[4 + inpos] - in[4 + inpos - 1]) << 28); + out[2 + outpos] = (in[4 + inpos] - in[4 + inpos - 1]) >>> (15 - 11) + | ((in[5 + inpos] - in[5 + inpos - 1]) << 11) + | ((in[6 + inpos] - in[6 + inpos - 1]) << 26); + out[3 + outpos] = (in[6 + inpos] - in[6 + inpos - 1]) >>> (15 - 9) + | ((in[7 + inpos] - in[7 + inpos - 1]) << 9) + | ((in[8 + inpos] - in[8 + inpos - 1]) << 24); + out[4 + outpos] = (in[8 + inpos] - in[8 + inpos - 1]) >>> (15 - 7) + | ((in[9 + inpos] - in[9 + inpos - 1]) << 7) + | ((in[10 + inpos] - in[10 + inpos - 1]) << 22); + out[5 + outpos] = (in[10 + inpos] - in[10 + inpos - 1]) >>> (15 - 5) + | ((in[11 + inpos] - in[11 + inpos - 1]) << 5) + | ((in[12 + inpos] - in[12 + inpos - 1]) << 20); + out[6 + outpos] = (in[12 + inpos] - in[12 + inpos - 1]) >>> (15 - 3) + | ((in[13 + inpos] - in[13 + inpos - 1]) << 3) + | ((in[14 + inpos] - in[14 + inpos - 1]) << 18); + out[7 + outpos] = (in[14 + inpos] - in[14 + inpos - 1]) >>> (15 - 1) + | ((in[15 + inpos] - in[15 + inpos - 1]) << 1) + | ((in[16 + inpos] - in[16 + inpos - 1]) << 16) + | ((in[17 + inpos] - in[17 + inpos - 1]) << 31); + out[8 + outpos] = (in[17 + inpos] - in[17 + inpos - 1]) >>> (15 - 14) + | ((in[18 + inpos] - in[18 + inpos - 1]) << 14) + | ((in[19 + inpos] - in[19 + inpos - 1]) << 29); + out[9 + outpos] = (in[19 + inpos] - in[19 + inpos - 1]) >>> (15 - 12) + | ((in[20 + inpos] - in[20 + inpos - 1]) << 12) + | ((in[21 + inpos] - in[21 + inpos - 1]) << 27); + out[10 + outpos] = (in[21 + inpos] - in[21 + inpos - 1]) >>> (15 - 10) + | ((in[22 + inpos] - in[22 + inpos - 1]) << 10) + | ((in[23 + inpos] - in[23 + inpos - 1]) << 25); + out[11 + outpos] = (in[23 + inpos] - in[23 + inpos - 1]) >>> (15 - 8) + | ((in[24 + inpos] - in[24 + inpos - 1]) << 8) + | ((in[25 + inpos] - in[25 + inpos - 1]) << 23); + out[12 + outpos] = (in[25 + inpos] - in[25 + inpos - 1]) >>> (15 - 6) + | ((in[26 + inpos] - in[26 + inpos - 1]) << 6) + | ((in[27 + inpos] - in[27 + inpos - 1]) << 21); + out[13 + outpos] = (in[27 + inpos] - in[27 + inpos - 1]) >>> (15 - 4) + | ((in[28 + inpos] - in[28 + inpos - 1]) << 4) + | ((in[29 + inpos] - in[29 + inpos - 1]) << 19); + out[14 + outpos] = (in[29 + inpos] - in[29 + inpos - 1]) >>> (15 - 2) + | ((in[30 + inpos] - in[30 + inpos - 1]) << 2) + | ((in[31 + inpos] - in[31 + inpos - 1]) << 17); + } + + protected static void integratedpack16(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + out[0 + outpos] = (in[0 + inpos] - initoffset) + | ((in[1 + inpos] - in[1 + inpos - 1]) << 16); + out[1 + outpos] = (in[2 + inpos] - in[2 + inpos - 1]) + | ((in[3 + inpos] - in[3 + inpos - 1]) << 16); + out[2 + outpos] = (in[4 + inpos] - in[4 + inpos - 1]) + | ((in[5 + inpos] - in[5 + inpos - 1]) << 16); + out[3 + outpos] = (in[6 + inpos] - in[6 + inpos - 1]) + | ((in[7 + inpos] - in[7 + inpos - 1]) << 16); + out[4 + outpos] = (in[8 + inpos] - in[8 + inpos - 1]) + | ((in[9 + inpos] - in[9 + inpos - 1]) << 16); + out[5 + outpos] = (in[10 + inpos] - in[10 + inpos - 1]) + | ((in[11 + inpos] - in[11 + inpos - 1]) << 16); + out[6 + outpos] = (in[12 + inpos] - in[12 + inpos - 1]) + | ((in[13 + inpos] - in[13 + inpos - 1]) << 16); + out[7 + outpos] = (in[14 + inpos] - in[14 + inpos - 1]) + | ((in[15 + inpos] - in[15 + inpos - 1]) << 16); + out[8 + outpos] = (in[16 + inpos] - in[16 + inpos - 1]) + | ((in[17 + inpos] - in[17 + inpos - 1]) << 16); + out[9 + outpos] = (in[18 + inpos] - in[18 + inpos - 1]) + | ((in[19 + inpos] - in[19 + inpos - 1]) << 16); + out[10 + outpos] = (in[20 + inpos] - in[20 + inpos - 1]) + | ((in[21 + inpos] - in[21 + inpos - 1]) << 16); + out[11 + outpos] = (in[22 + inpos] - in[22 + inpos - 1]) + | ((in[23 + inpos] - in[23 + inpos - 1]) << 16); + out[12 + outpos] = (in[24 + inpos] - in[24 + inpos - 1]) + | ((in[25 + inpos] - in[25 + inpos - 1]) << 16); + out[13 + outpos] = (in[26 + inpos] - in[26 + inpos - 1]) + | ((in[27 + inpos] - in[27 + inpos - 1]) << 16); + out[14 + outpos] = (in[28 + inpos] - in[28 + inpos - 1]) + | ((in[29 + inpos] - in[29 + inpos - 1]) << 16); + out[15 + outpos] = (in[30 + inpos] - in[30 + inpos - 1]) + | ((in[31 + inpos] - in[31 + inpos - 1]) << 16); + } + + protected static void integratedpack17(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + out[0 + outpos] = (in[0 + inpos] - initoffset) + | ((in[1 + inpos] - in[1 + inpos - 1]) << 17); + out[1 + outpos] = (in[1 + inpos] - in[1 + inpos - 1]) >>> (17 - 2) + | ((in[2 + inpos] - in[2 + inpos - 1]) << 2) + | ((in[3 + inpos] - in[3 + inpos - 1]) << 19); + out[2 + outpos] = (in[3 + inpos] - in[3 + inpos - 1]) >>> (17 - 4) + | ((in[4 + inpos] - in[4 + inpos - 1]) << 4) + | ((in[5 + inpos] - in[5 + inpos - 1]) << 21); + out[3 + outpos] = (in[5 + inpos] - in[5 + inpos - 1]) >>> (17 - 6) + | ((in[6 + inpos] - in[6 + inpos - 1]) << 6) + | ((in[7 + inpos] - in[7 + inpos - 1]) << 23); + out[4 + outpos] = (in[7 + inpos] - in[7 + inpos - 1]) >>> (17 - 8) + | ((in[8 + inpos] - in[8 + inpos - 1]) << 8) + | ((in[9 + inpos] - in[9 + inpos - 1]) << 25); + out[5 + outpos] = (in[9 + inpos] - in[9 + inpos - 1]) >>> (17 - 10) + | ((in[10 + inpos] - in[10 + inpos - 1]) << 10) + | ((in[11 + inpos] - in[11 + inpos - 1]) << 27); + out[6 + outpos] = (in[11 + inpos] - in[11 + inpos - 1]) >>> (17 - 12) + | ((in[12 + inpos] - in[12 + inpos - 1]) << 12) + | ((in[13 + inpos] - in[13 + inpos - 1]) << 29); + out[7 + outpos] = (in[13 + inpos] - in[13 + inpos - 1]) >>> (17 - 14) + | ((in[14 + inpos] - in[14 + inpos - 1]) << 14) + | ((in[15 + inpos] - in[15 + inpos - 1]) << 31); + out[8 + outpos] = (in[15 + inpos] - in[15 + inpos - 1]) >>> (17 - 16) + | ((in[16 + inpos] - in[16 + inpos - 1]) << 16); + out[9 + outpos] = (in[16 + inpos] - in[16 + inpos - 1]) >>> (17 - 1) + | ((in[17 + inpos] - in[17 + inpos - 1]) << 1) + | ((in[18 + inpos] - in[18 + inpos - 1]) << 18); + out[10 + outpos] = (in[18 + inpos] - in[18 + inpos - 1]) >>> (17 - 3) + | ((in[19 + inpos] - in[19 + inpos - 1]) << 3) + | ((in[20 + inpos] - in[20 + inpos - 1]) << 20); + out[11 + outpos] = (in[20 + inpos] - in[20 + inpos - 1]) >>> (17 - 5) + | ((in[21 + inpos] - in[21 + inpos - 1]) << 5) + | ((in[22 + inpos] - in[22 + inpos - 1]) << 22); + out[12 + outpos] = (in[22 + inpos] - in[22 + inpos - 1]) >>> (17 - 7) + | ((in[23 + inpos] - in[23 + inpos - 1]) << 7) + | ((in[24 + inpos] - in[24 + inpos - 1]) << 24); + out[13 + outpos] = (in[24 + inpos] - in[24 + inpos - 1]) >>> (17 - 9) + | ((in[25 + inpos] - in[25 + inpos - 1]) << 9) + | ((in[26 + inpos] - in[26 + inpos - 1]) << 26); + out[14 + outpos] = (in[26 + inpos] - in[26 + inpos - 1]) >>> (17 - 11) + | ((in[27 + inpos] - in[27 + inpos - 1]) << 11) + | ((in[28 + inpos] - in[28 + inpos - 1]) << 28); + out[15 + outpos] = (in[28 + inpos] - in[28 + inpos - 1]) >>> (17 - 13) + | ((in[29 + inpos] - in[29 + inpos - 1]) << 13) + | ((in[30 + inpos] - in[30 + inpos - 1]) << 30); + out[16 + outpos] = (in[30 + inpos] - in[30 + inpos - 1]) >>> (17 - 15) + | ((in[31 + inpos] - in[31 + inpos - 1]) << 15); + } + + protected static void integratedpack18(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + out[0 + outpos] = (in[0 + inpos] - initoffset) + | ((in[1 + inpos] - in[1 + inpos - 1]) << 18); + out[1 + outpos] = (in[1 + inpos] - in[1 + inpos - 1]) >>> (18 - 4) + | ((in[2 + inpos] - in[2 + inpos - 1]) << 4) + | ((in[3 + inpos] - in[3 + inpos - 1]) << 22); + out[2 + outpos] = (in[3 + inpos] - in[3 + inpos - 1]) >>> (18 - 8) + | ((in[4 + inpos] - in[4 + inpos - 1]) << 8) + | ((in[5 + inpos] - in[5 + inpos - 1]) << 26); + out[3 + outpos] = (in[5 + inpos] - in[5 + inpos - 1]) >>> (18 - 12) + | ((in[6 + inpos] - in[6 + inpos - 1]) << 12) + | ((in[7 + inpos] - in[7 + inpos - 1]) << 30); + out[4 + outpos] = (in[7 + inpos] - in[7 + inpos - 1]) >>> (18 - 16) + | ((in[8 + inpos] - in[8 + inpos - 1]) << 16); + out[5 + outpos] = (in[8 + inpos] - in[8 + inpos - 1]) >>> (18 - 2) + | ((in[9 + inpos] - in[9 + inpos - 1]) << 2) + | ((in[10 + inpos] - in[10 + inpos - 1]) << 20); + out[6 + outpos] = (in[10 + inpos] - in[10 + inpos - 1]) >>> (18 - 6) + | ((in[11 + inpos] - in[11 + inpos - 1]) << 6) + | ((in[12 + inpos] - in[12 + inpos - 1]) << 24); + out[7 + outpos] = (in[12 + inpos] - in[12 + inpos - 1]) >>> (18 - 10) + | ((in[13 + inpos] - in[13 + inpos - 1]) << 10) + | ((in[14 + inpos] - in[14 + inpos - 1]) << 28); + out[8 + outpos] = (in[14 + inpos] - in[14 + inpos - 1]) >>> (18 - 14) + | ((in[15 + inpos] - in[15 + inpos - 1]) << 14); + out[9 + outpos] = (in[16 + inpos] - in[16 + inpos - 1]) + | ((in[17 + inpos] - in[17 + inpos - 1]) << 18); + out[10 + outpos] = (in[17 + inpos] - in[17 + inpos - 1]) >>> (18 - 4) + | ((in[18 + inpos] - in[18 + inpos - 1]) << 4) + | ((in[19 + inpos] - in[19 + inpos - 1]) << 22); + out[11 + outpos] = (in[19 + inpos] - in[19 + inpos - 1]) >>> (18 - 8) + | ((in[20 + inpos] - in[20 + inpos - 1]) << 8) + | ((in[21 + inpos] - in[21 + inpos - 1]) << 26); + out[12 + outpos] = (in[21 + inpos] - in[21 + inpos - 1]) >>> (18 - 12) + | ((in[22 + inpos] - in[22 + inpos - 1]) << 12) + | ((in[23 + inpos] - in[23 + inpos - 1]) << 30); + out[13 + outpos] = (in[23 + inpos] - in[23 + inpos - 1]) >>> (18 - 16) + | ((in[24 + inpos] - in[24 + inpos - 1]) << 16); + out[14 + outpos] = (in[24 + inpos] - in[24 + inpos - 1]) >>> (18 - 2) + | ((in[25 + inpos] - in[25 + inpos - 1]) << 2) + | ((in[26 + inpos] - in[26 + inpos - 1]) << 20); + out[15 + outpos] = (in[26 + inpos] - in[26 + inpos - 1]) >>> (18 - 6) + | ((in[27 + inpos] - in[27 + inpos - 1]) << 6) + | ((in[28 + inpos] - in[28 + inpos - 1]) << 24); + out[16 + outpos] = (in[28 + inpos] - in[28 + inpos - 1]) >>> (18 - 10) + | ((in[29 + inpos] - in[29 + inpos - 1]) << 10) + | ((in[30 + inpos] - in[30 + inpos - 1]) << 28); + out[17 + outpos] = (in[30 + inpos] - in[30 + inpos - 1]) >>> (18 - 14) + | ((in[31 + inpos] - in[31 + inpos - 1]) << 14); + } + + protected static void integratedpack19(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + out[0 + outpos] = (in[0 + inpos] - initoffset) + | ((in[1 + inpos] - in[1 + inpos - 1]) << 19); + out[1 + outpos] = (in[1 + inpos] - in[1 + inpos - 1]) >>> (19 - 6) + | ((in[2 + inpos] - in[2 + inpos - 1]) << 6) + | ((in[3 + inpos] - in[3 + inpos - 1]) << 25); + out[2 + outpos] = (in[3 + inpos] - in[3 + inpos - 1]) >>> (19 - 12) + | ((in[4 + inpos] - in[4 + inpos - 1]) << 12) + | ((in[5 + inpos] - in[5 + inpos - 1]) << 31); + out[3 + outpos] = (in[5 + inpos] - in[5 + inpos - 1]) >>> (19 - 18) + | ((in[6 + inpos] - in[6 + inpos - 1]) << 18); + out[4 + outpos] = (in[6 + inpos] - in[6 + inpos - 1]) >>> (19 - 5) + | ((in[7 + inpos] - in[7 + inpos - 1]) << 5) + | ((in[8 + inpos] - in[8 + inpos - 1]) << 24); + out[5 + outpos] = (in[8 + inpos] - in[8 + inpos - 1]) >>> (19 - 11) + | ((in[9 + inpos] - in[9 + inpos - 1]) << 11) + | ((in[10 + inpos] - in[10 + inpos - 1]) << 30); + out[6 + outpos] = (in[10 + inpos] - in[10 + inpos - 1]) >>> (19 - 17) + | ((in[11 + inpos] - in[11 + inpos - 1]) << 17); + out[7 + outpos] = (in[11 + inpos] - in[11 + inpos - 1]) >>> (19 - 4) + | ((in[12 + inpos] - in[12 + inpos - 1]) << 4) + | ((in[13 + inpos] - in[13 + inpos - 1]) << 23); + out[8 + outpos] = (in[13 + inpos] - in[13 + inpos - 1]) >>> (19 - 10) + | ((in[14 + inpos] - in[14 + inpos - 1]) << 10) + | ((in[15 + inpos] - in[15 + inpos - 1]) << 29); + out[9 + outpos] = (in[15 + inpos] - in[15 + inpos - 1]) >>> (19 - 16) + | ((in[16 + inpos] - in[16 + inpos - 1]) << 16); + out[10 + outpos] = (in[16 + inpos] - in[16 + inpos - 1]) >>> (19 - 3) + | ((in[17 + inpos] - in[17 + inpos - 1]) << 3) + | ((in[18 + inpos] - in[18 + inpos - 1]) << 22); + out[11 + outpos] = (in[18 + inpos] - in[18 + inpos - 1]) >>> (19 - 9) + | ((in[19 + inpos] - in[19 + inpos - 1]) << 9) + | ((in[20 + inpos] - in[20 + inpos - 1]) << 28); + out[12 + outpos] = (in[20 + inpos] - in[20 + inpos - 1]) >>> (19 - 15) + | ((in[21 + inpos] - in[21 + inpos - 1]) << 15); + out[13 + outpos] = (in[21 + inpos] - in[21 + inpos - 1]) >>> (19 - 2) + | ((in[22 + inpos] - in[22 + inpos - 1]) << 2) + | ((in[23 + inpos] - in[23 + inpos - 1]) << 21); + out[14 + outpos] = (in[23 + inpos] - in[23 + inpos - 1]) >>> (19 - 8) + | ((in[24 + inpos] - in[24 + inpos - 1]) << 8) + | ((in[25 + inpos] - in[25 + inpos - 1]) << 27); + out[15 + outpos] = (in[25 + inpos] - in[25 + inpos - 1]) >>> (19 - 14) + | ((in[26 + inpos] - in[26 + inpos - 1]) << 14); + out[16 + outpos] = (in[26 + inpos] - in[26 + inpos - 1]) >>> (19 - 1) + | ((in[27 + inpos] - in[27 + inpos - 1]) << 1) + | ((in[28 + inpos] - in[28 + inpos - 1]) << 20); + out[17 + outpos] = (in[28 + inpos] - in[28 + inpos - 1]) >>> (19 - 7) + | ((in[29 + inpos] - in[29 + inpos - 1]) << 7) + | ((in[30 + inpos] - in[30 + inpos - 1]) << 26); + out[18 + outpos] = (in[30 + inpos] - in[30 + inpos - 1]) >>> (19 - 13) + | ((in[31 + inpos] - in[31 + inpos - 1]) << 13); + } + + protected static void integratedpack2(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + out[0 + outpos] = (in[0 + inpos] - initoffset) + | ((in[1 + inpos] - in[1 + inpos - 1]) << 2) + | ((in[2 + inpos] - in[2 + inpos - 1]) << 4) + | ((in[3 + inpos] - in[3 + inpos - 1]) << 6) + | ((in[4 + inpos] - in[4 + inpos - 1]) << 8) + | ((in[5 + inpos] - in[5 + inpos - 1]) << 10) + | ((in[6 + inpos] - in[6 + inpos - 1]) << 12) + | ((in[7 + inpos] - in[7 + inpos - 1]) << 14) + | ((in[8 + inpos] - in[8 + inpos - 1]) << 16) + | ((in[9 + inpos] - in[9 + inpos - 1]) << 18) + | ((in[10 + inpos] - in[10 + inpos - 1]) << 20) + | ((in[11 + inpos] - in[11 + inpos - 1]) << 22) + | ((in[12 + inpos] - in[12 + inpos - 1]) << 24) + | ((in[13 + inpos] - in[13 + inpos - 1]) << 26) + | ((in[14 + inpos] - in[14 + inpos - 1]) << 28) + | ((in[15 + inpos] - in[15 + inpos - 1]) << 30); + out[1 + outpos] = (in[16 + inpos] - in[16 + inpos - 1]) + | ((in[17 + inpos] - in[17 + inpos - 1]) << 2) + | ((in[18 + inpos] - in[18 + inpos - 1]) << 4) + | ((in[19 + inpos] - in[19 + inpos - 1]) << 6) + | ((in[20 + inpos] - in[20 + inpos - 1]) << 8) + | ((in[21 + inpos] - in[21 + inpos - 1]) << 10) + | ((in[22 + inpos] - in[22 + inpos - 1]) << 12) + | ((in[23 + inpos] - in[23 + inpos - 1]) << 14) + | ((in[24 + inpos] - in[24 + inpos - 1]) << 16) + | ((in[25 + inpos] - in[25 + inpos - 1]) << 18) + | ((in[26 + inpos] - in[26 + inpos - 1]) << 20) + | ((in[27 + inpos] - in[27 + inpos - 1]) << 22) + | ((in[28 + inpos] - in[28 + inpos - 1]) << 24) + | ((in[29 + inpos] - in[29 + inpos - 1]) << 26) + | ((in[30 + inpos] - in[30 + inpos - 1]) << 28) + | ((in[31 + inpos] - in[31 + inpos - 1]) << 30); + } + + protected static void integratedpack20(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + out[0 + outpos] = (in[0 + inpos] - initoffset) + | ((in[1 + inpos] - in[1 + inpos - 1]) << 20); + out[1 + outpos] = (in[1 + inpos] - in[1 + inpos - 1]) >>> (20 - 8) + | ((in[2 + inpos] - in[2 + inpos - 1]) << 8) + | ((in[3 + inpos] - in[3 + inpos - 1]) << 28); + out[2 + outpos] = (in[3 + inpos] - in[3 + inpos - 1]) >>> (20 - 16) + | ((in[4 + inpos] - in[4 + inpos - 1]) << 16); + out[3 + outpos] = (in[4 + inpos] - in[4 + inpos - 1]) >>> (20 - 4) + | ((in[5 + inpos] - in[5 + inpos - 1]) << 4) + | ((in[6 + inpos] - in[6 + inpos - 1]) << 24); + out[4 + outpos] = (in[6 + inpos] - in[6 + inpos - 1]) >>> (20 - 12) + | ((in[7 + inpos] - in[7 + inpos - 1]) << 12); + out[5 + outpos] = (in[8 + inpos] - in[8 + inpos - 1]) + | ((in[9 + inpos] - in[9 + inpos - 1]) << 20); + out[6 + outpos] = (in[9 + inpos] - in[9 + inpos - 1]) >>> (20 - 8) + | ((in[10 + inpos] - in[10 + inpos - 1]) << 8) + | ((in[11 + inpos] - in[11 + inpos - 1]) << 28); + out[7 + outpos] = (in[11 + inpos] - in[11 + inpos - 1]) >>> (20 - 16) + | ((in[12 + inpos] - in[12 + inpos - 1]) << 16); + out[8 + outpos] = (in[12 + inpos] - in[12 + inpos - 1]) >>> (20 - 4) + | ((in[13 + inpos] - in[13 + inpos - 1]) << 4) + | ((in[14 + inpos] - in[14 + inpos - 1]) << 24); + out[9 + outpos] = (in[14 + inpos] - in[14 + inpos - 1]) >>> (20 - 12) + | ((in[15 + inpos] - in[15 + inpos - 1]) << 12); + out[10 + outpos] = (in[16 + inpos] - in[16 + inpos - 1]) + | ((in[17 + inpos] - in[17 + inpos - 1]) << 20); + out[11 + outpos] = (in[17 + inpos] - in[17 + inpos - 1]) >>> (20 - 8) + | ((in[18 + inpos] - in[18 + inpos - 1]) << 8) + | ((in[19 + inpos] - in[19 + inpos - 1]) << 28); + out[12 + outpos] = (in[19 + inpos] - in[19 + inpos - 1]) >>> (20 - 16) + | ((in[20 + inpos] - in[20 + inpos - 1]) << 16); + out[13 + outpos] = (in[20 + inpos] - in[20 + inpos - 1]) >>> (20 - 4) + | ((in[21 + inpos] - in[21 + inpos - 1]) << 4) + | ((in[22 + inpos] - in[22 + inpos - 1]) << 24); + out[14 + outpos] = (in[22 + inpos] - in[22 + inpos - 1]) >>> (20 - 12) + | ((in[23 + inpos] - in[23 + inpos - 1]) << 12); + out[15 + outpos] = (in[24 + inpos] - in[24 + inpos - 1]) + | ((in[25 + inpos] - in[25 + inpos - 1]) << 20); + out[16 + outpos] = (in[25 + inpos] - in[25 + inpos - 1]) >>> (20 - 8) + | ((in[26 + inpos] - in[26 + inpos - 1]) << 8) + | ((in[27 + inpos] - in[27 + inpos - 1]) << 28); + out[17 + outpos] = (in[27 + inpos] - in[27 + inpos - 1]) >>> (20 - 16) + | ((in[28 + inpos] - in[28 + inpos - 1]) << 16); + out[18 + outpos] = (in[28 + inpos] - in[28 + inpos - 1]) >>> (20 - 4) + | ((in[29 + inpos] - in[29 + inpos - 1]) << 4) + | ((in[30 + inpos] - in[30 + inpos - 1]) << 24); + out[19 + outpos] = (in[30 + inpos] - in[30 + inpos - 1]) >>> (20 - 12) + | ((in[31 + inpos] - in[31 + inpos - 1]) << 12); + } + + protected static void integratedpack21(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + out[0 + outpos] = (in[0 + inpos] - initoffset) + | ((in[1 + inpos] - in[1 + inpos - 1]) << 21); + out[1 + outpos] = (in[1 + inpos] - in[1 + inpos - 1]) >>> (21 - 10) + | ((in[2 + inpos] - in[2 + inpos - 1]) << 10) + | ((in[3 + inpos] - in[3 + inpos - 1]) << 31); + out[2 + outpos] = (in[3 + inpos] - in[3 + inpos - 1]) >>> (21 - 20) + | ((in[4 + inpos] - in[4 + inpos - 1]) << 20); + out[3 + outpos] = (in[4 + inpos] - in[4 + inpos - 1]) >>> (21 - 9) + | ((in[5 + inpos] - in[5 + inpos - 1]) << 9) + | ((in[6 + inpos] - in[6 + inpos - 1]) << 30); + out[4 + outpos] = (in[6 + inpos] - in[6 + inpos - 1]) >>> (21 - 19) + | ((in[7 + inpos] - in[7 + inpos - 1]) << 19); + out[5 + outpos] = (in[7 + inpos] - in[7 + inpos - 1]) >>> (21 - 8) + | ((in[8 + inpos] - in[8 + inpos - 1]) << 8) + | ((in[9 + inpos] - in[9 + inpos - 1]) << 29); + out[6 + outpos] = (in[9 + inpos] - in[9 + inpos - 1]) >>> (21 - 18) + | ((in[10 + inpos] - in[10 + inpos - 1]) << 18); + out[7 + outpos] = (in[10 + inpos] - in[10 + inpos - 1]) >>> (21 - 7) + | ((in[11 + inpos] - in[11 + inpos - 1]) << 7) + | ((in[12 + inpos] - in[12 + inpos - 1]) << 28); + out[8 + outpos] = (in[12 + inpos] - in[12 + inpos - 1]) >>> (21 - 17) + | ((in[13 + inpos] - in[13 + inpos - 1]) << 17); + out[9 + outpos] = (in[13 + inpos] - in[13 + inpos - 1]) >>> (21 - 6) + | ((in[14 + inpos] - in[14 + inpos - 1]) << 6) + | ((in[15 + inpos] - in[15 + inpos - 1]) << 27); + out[10 + outpos] = (in[15 + inpos] - in[15 + inpos - 1]) >>> (21 - 16) + | ((in[16 + inpos] - in[16 + inpos - 1]) << 16); + out[11 + outpos] = (in[16 + inpos] - in[16 + inpos - 1]) >>> (21 - 5) + | ((in[17 + inpos] - in[17 + inpos - 1]) << 5) + | ((in[18 + inpos] - in[18 + inpos - 1]) << 26); + out[12 + outpos] = (in[18 + inpos] - in[18 + inpos - 1]) >>> (21 - 15) + | ((in[19 + inpos] - in[19 + inpos - 1]) << 15); + out[13 + outpos] = (in[19 + inpos] - in[19 + inpos - 1]) >>> (21 - 4) + | ((in[20 + inpos] - in[20 + inpos - 1]) << 4) + | ((in[21 + inpos] - in[21 + inpos - 1]) << 25); + out[14 + outpos] = (in[21 + inpos] - in[21 + inpos - 1]) >>> (21 - 14) + | ((in[22 + inpos] - in[22 + inpos - 1]) << 14); + out[15 + outpos] = (in[22 + inpos] - in[22 + inpos - 1]) >>> (21 - 3) + | ((in[23 + inpos] - in[23 + inpos - 1]) << 3) + | ((in[24 + inpos] - in[24 + inpos - 1]) << 24); + out[16 + outpos] = (in[24 + inpos] - in[24 + inpos - 1]) >>> (21 - 13) + | ((in[25 + inpos] - in[25 + inpos - 1]) << 13); + out[17 + outpos] = (in[25 + inpos] - in[25 + inpos - 1]) >>> (21 - 2) + | ((in[26 + inpos] - in[26 + inpos - 1]) << 2) + | ((in[27 + inpos] - in[27 + inpos - 1]) << 23); + out[18 + outpos] = (in[27 + inpos] - in[27 + inpos - 1]) >>> (21 - 12) + | ((in[28 + inpos] - in[28 + inpos - 1]) << 12); + out[19 + outpos] = (in[28 + inpos] - in[28 + inpos - 1]) >>> (21 - 1) + | ((in[29 + inpos] - in[29 + inpos - 1]) << 1) + | ((in[30 + inpos] - in[30 + inpos - 1]) << 22); + out[20 + outpos] = (in[30 + inpos] - in[30 + inpos - 1]) >>> (21 - 11) + | ((in[31 + inpos] - in[31 + inpos - 1]) << 11); + } + + protected static void integratedpack22(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + out[0 + outpos] = (in[0 + inpos] - initoffset) + | ((in[1 + inpos] - in[1 + inpos - 1]) << 22); + out[1 + outpos] = (in[1 + inpos] - in[1 + inpos - 1]) >>> (22 - 12) + | ((in[2 + inpos] - in[2 + inpos - 1]) << 12); + out[2 + outpos] = (in[2 + inpos] - in[2 + inpos - 1]) >>> (22 - 2) + | ((in[3 + inpos] - in[3 + inpos - 1]) << 2) + | ((in[4 + inpos] - in[4 + inpos - 1]) << 24); + out[3 + outpos] = (in[4 + inpos] - in[4 + inpos - 1]) >>> (22 - 14) + | ((in[5 + inpos] - in[5 + inpos - 1]) << 14); + out[4 + outpos] = (in[5 + inpos] - in[5 + inpos - 1]) >>> (22 - 4) + | ((in[6 + inpos] - in[6 + inpos - 1]) << 4) + | ((in[7 + inpos] - in[7 + inpos - 1]) << 26); + out[5 + outpos] = (in[7 + inpos] - in[7 + inpos - 1]) >>> (22 - 16) + | ((in[8 + inpos] - in[8 + inpos - 1]) << 16); + out[6 + outpos] = (in[8 + inpos] - in[8 + inpos - 1]) >>> (22 - 6) + | ((in[9 + inpos] - in[9 + inpos - 1]) << 6) + | ((in[10 + inpos] - in[10 + inpos - 1]) << 28); + out[7 + outpos] = (in[10 + inpos] - in[10 + inpos - 1]) >>> (22 - 18) + | ((in[11 + inpos] - in[11 + inpos - 1]) << 18); + out[8 + outpos] = (in[11 + inpos] - in[11 + inpos - 1]) >>> (22 - 8) + | ((in[12 + inpos] - in[12 + inpos - 1]) << 8) + | ((in[13 + inpos] - in[13 + inpos - 1]) << 30); + out[9 + outpos] = (in[13 + inpos] - in[13 + inpos - 1]) >>> (22 - 20) + | ((in[14 + inpos] - in[14 + inpos - 1]) << 20); + out[10 + outpos] = (in[14 + inpos] - in[14 + inpos - 1]) >>> (22 - 10) + | ((in[15 + inpos] - in[15 + inpos - 1]) << 10); + out[11 + outpos] = (in[16 + inpos] - in[16 + inpos - 1]) + | ((in[17 + inpos] - in[17 + inpos - 1]) << 22); + out[12 + outpos] = (in[17 + inpos] - in[17 + inpos - 1]) >>> (22 - 12) + | ((in[18 + inpos] - in[18 + inpos - 1]) << 12); + out[13 + outpos] = (in[18 + inpos] - in[18 + inpos - 1]) >>> (22 - 2) + | ((in[19 + inpos] - in[19 + inpos - 1]) << 2) + | ((in[20 + inpos] - in[20 + inpos - 1]) << 24); + out[14 + outpos] = (in[20 + inpos] - in[20 + inpos - 1]) >>> (22 - 14) + | ((in[21 + inpos] - in[21 + inpos - 1]) << 14); + out[15 + outpos] = (in[21 + inpos] - in[21 + inpos - 1]) >>> (22 - 4) + | ((in[22 + inpos] - in[22 + inpos - 1]) << 4) + | ((in[23 + inpos] - in[23 + inpos - 1]) << 26); + out[16 + outpos] = (in[23 + inpos] - in[23 + inpos - 1]) >>> (22 - 16) + | ((in[24 + inpos] - in[24 + inpos - 1]) << 16); + out[17 + outpos] = (in[24 + inpos] - in[24 + inpos - 1]) >>> (22 - 6) + | ((in[25 + inpos] - in[25 + inpos - 1]) << 6) + | ((in[26 + inpos] - in[26 + inpos - 1]) << 28); + out[18 + outpos] = (in[26 + inpos] - in[26 + inpos - 1]) >>> (22 - 18) + | ((in[27 + inpos] - in[27 + inpos - 1]) << 18); + out[19 + outpos] = (in[27 + inpos] - in[27 + inpos - 1]) >>> (22 - 8) + | ((in[28 + inpos] - in[28 + inpos - 1]) << 8) + | ((in[29 + inpos] - in[29 + inpos - 1]) << 30); + out[20 + outpos] = (in[29 + inpos] - in[29 + inpos - 1]) >>> (22 - 20) + | ((in[30 + inpos] - in[30 + inpos - 1]) << 20); + out[21 + outpos] = (in[30 + inpos] - in[30 + inpos - 1]) >>> (22 - 10) + | ((in[31 + inpos] - in[31 + inpos - 1]) << 10); + } + + protected static void integratedpack23(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + out[0 + outpos] = (in[0 + inpos] - initoffset) + | ((in[1 + inpos] - in[1 + inpos - 1]) << 23); + out[1 + outpos] = (in[1 + inpos] - in[1 + inpos - 1]) >>> (23 - 14) + | ((in[2 + inpos] - in[2 + inpos - 1]) << 14); + out[2 + outpos] = (in[2 + inpos] - in[2 + inpos - 1]) >>> (23 - 5) + | ((in[3 + inpos] - in[3 + inpos - 1]) << 5) + | ((in[4 + inpos] - in[4 + inpos - 1]) << 28); + out[3 + outpos] = (in[4 + inpos] - in[4 + inpos - 1]) >>> (23 - 19) + | ((in[5 + inpos] - in[5 + inpos - 1]) << 19); + out[4 + outpos] = (in[5 + inpos] - in[5 + inpos - 1]) >>> (23 - 10) + | ((in[6 + inpos] - in[6 + inpos - 1]) << 10); + out[5 + outpos] = (in[6 + inpos] - in[6 + inpos - 1]) >>> (23 - 1) + | ((in[7 + inpos] - in[7 + inpos - 1]) << 1) + | ((in[8 + inpos] - in[8 + inpos - 1]) << 24); + out[6 + outpos] = (in[8 + inpos] - in[8 + inpos - 1]) >>> (23 - 15) + | ((in[9 + inpos] - in[9 + inpos - 1]) << 15); + out[7 + outpos] = (in[9 + inpos] - in[9 + inpos - 1]) >>> (23 - 6) + | ((in[10 + inpos] - in[10 + inpos - 1]) << 6) + | ((in[11 + inpos] - in[11 + inpos - 1]) << 29); + out[8 + outpos] = (in[11 + inpos] - in[11 + inpos - 1]) >>> (23 - 20) + | ((in[12 + inpos] - in[12 + inpos - 1]) << 20); + out[9 + outpos] = (in[12 + inpos] - in[12 + inpos - 1]) >>> (23 - 11) + | ((in[13 + inpos] - in[13 + inpos - 1]) << 11); + out[10 + outpos] = (in[13 + inpos] - in[13 + inpos - 1]) >>> (23 - 2) + | ((in[14 + inpos] - in[14 + inpos - 1]) << 2) + | ((in[15 + inpos] - in[15 + inpos - 1]) << 25); + out[11 + outpos] = (in[15 + inpos] - in[15 + inpos - 1]) >>> (23 - 16) + | ((in[16 + inpos] - in[16 + inpos - 1]) << 16); + out[12 + outpos] = (in[16 + inpos] - in[16 + inpos - 1]) >>> (23 - 7) + | ((in[17 + inpos] - in[17 + inpos - 1]) << 7) + | ((in[18 + inpos] - in[18 + inpos - 1]) << 30); + out[13 + outpos] = (in[18 + inpos] - in[18 + inpos - 1]) >>> (23 - 21) + | ((in[19 + inpos] - in[19 + inpos - 1]) << 21); + out[14 + outpos] = (in[19 + inpos] - in[19 + inpos - 1]) >>> (23 - 12) + | ((in[20 + inpos] - in[20 + inpos - 1]) << 12); + out[15 + outpos] = (in[20 + inpos] - in[20 + inpos - 1]) >>> (23 - 3) + | ((in[21 + inpos] - in[21 + inpos - 1]) << 3) + | ((in[22 + inpos] - in[22 + inpos - 1]) << 26); + out[16 + outpos] = (in[22 + inpos] - in[22 + inpos - 1]) >>> (23 - 17) + | ((in[23 + inpos] - in[23 + inpos - 1]) << 17); + out[17 + outpos] = (in[23 + inpos] - in[23 + inpos - 1]) >>> (23 - 8) + | ((in[24 + inpos] - in[24 + inpos - 1]) << 8) + | ((in[25 + inpos] - in[25 + inpos - 1]) << 31); + out[18 + outpos] = (in[25 + inpos] - in[25 + inpos - 1]) >>> (23 - 22) + | ((in[26 + inpos] - in[26 + inpos - 1]) << 22); + out[19 + outpos] = (in[26 + inpos] - in[26 + inpos - 1]) >>> (23 - 13) + | ((in[27 + inpos] - in[27 + inpos - 1]) << 13); + out[20 + outpos] = (in[27 + inpos] - in[27 + inpos - 1]) >>> (23 - 4) + | ((in[28 + inpos] - in[28 + inpos - 1]) << 4) + | ((in[29 + inpos] - in[29 + inpos - 1]) << 27); + out[21 + outpos] = (in[29 + inpos] - in[29 + inpos - 1]) >>> (23 - 18) + | ((in[30 + inpos] - in[30 + inpos - 1]) << 18); + out[22 + outpos] = (in[30 + inpos] - in[30 + inpos - 1]) >>> (23 - 9) + | ((in[31 + inpos] - in[31 + inpos - 1]) << 9); + } + + protected static void integratedpack24(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + out[0 + outpos] = (in[0 + inpos] - initoffset) + | ((in[1 + inpos] - in[1 + inpos - 1]) << 24); + out[1 + outpos] = (in[1 + inpos] - in[1 + inpos - 1]) >>> (24 - 16) + | ((in[2 + inpos] - in[2 + inpos - 1]) << 16); + out[2 + outpos] = (in[2 + inpos] - in[2 + inpos - 1]) >>> (24 - 8) + | ((in[3 + inpos] - in[3 + inpos - 1]) << 8); + out[3 + outpos] = (in[4 + inpos] - in[4 + inpos - 1]) + | ((in[5 + inpos] - in[5 + inpos - 1]) << 24); + out[4 + outpos] = (in[5 + inpos] - in[5 + inpos - 1]) >>> (24 - 16) + | ((in[6 + inpos] - in[6 + inpos - 1]) << 16); + out[5 + outpos] = (in[6 + inpos] - in[6 + inpos - 1]) >>> (24 - 8) + | ((in[7 + inpos] - in[7 + inpos - 1]) << 8); + out[6 + outpos] = (in[8 + inpos] - in[8 + inpos - 1]) + | ((in[9 + inpos] - in[9 + inpos - 1]) << 24); + out[7 + outpos] = (in[9 + inpos] - in[9 + inpos - 1]) >>> (24 - 16) + | ((in[10 + inpos] - in[10 + inpos - 1]) << 16); + out[8 + outpos] = (in[10 + inpos] - in[10 + inpos - 1]) >>> (24 - 8) + | ((in[11 + inpos] - in[11 + inpos - 1]) << 8); + out[9 + outpos] = (in[12 + inpos] - in[12 + inpos - 1]) + | ((in[13 + inpos] - in[13 + inpos - 1]) << 24); + out[10 + outpos] = (in[13 + inpos] - in[13 + inpos - 1]) >>> (24 - 16) + | ((in[14 + inpos] - in[14 + inpos - 1]) << 16); + out[11 + outpos] = (in[14 + inpos] - in[14 + inpos - 1]) >>> (24 - 8) + | ((in[15 + inpos] - in[15 + inpos - 1]) << 8); + out[12 + outpos] = (in[16 + inpos] - in[16 + inpos - 1]) + | ((in[17 + inpos] - in[17 + inpos - 1]) << 24); + out[13 + outpos] = (in[17 + inpos] - in[17 + inpos - 1]) >>> (24 - 16) + | ((in[18 + inpos] - in[18 + inpos - 1]) << 16); + out[14 + outpos] = (in[18 + inpos] - in[18 + inpos - 1]) >>> (24 - 8) + | ((in[19 + inpos] - in[19 + inpos - 1]) << 8); + out[15 + outpos] = (in[20 + inpos] - in[20 + inpos - 1]) + | ((in[21 + inpos] - in[21 + inpos - 1]) << 24); + out[16 + outpos] = (in[21 + inpos] - in[21 + inpos - 1]) >>> (24 - 16) + | ((in[22 + inpos] - in[22 + inpos - 1]) << 16); + out[17 + outpos] = (in[22 + inpos] - in[22 + inpos - 1]) >>> (24 - 8) + | ((in[23 + inpos] - in[23 + inpos - 1]) << 8); + out[18 + outpos] = (in[24 + inpos] - in[24 + inpos - 1]) + | ((in[25 + inpos] - in[25 + inpos - 1]) << 24); + out[19 + outpos] = (in[25 + inpos] - in[25 + inpos - 1]) >>> (24 - 16) + | ((in[26 + inpos] - in[26 + inpos - 1]) << 16); + out[20 + outpos] = (in[26 + inpos] - in[26 + inpos - 1]) >>> (24 - 8) + | ((in[27 + inpos] - in[27 + inpos - 1]) << 8); + out[21 + outpos] = (in[28 + inpos] - in[28 + inpos - 1]) + | ((in[29 + inpos] - in[29 + inpos - 1]) << 24); + out[22 + outpos] = (in[29 + inpos] - in[29 + inpos - 1]) >>> (24 - 16) + | ((in[30 + inpos] - in[30 + inpos - 1]) << 16); + out[23 + outpos] = (in[30 + inpos] - in[30 + inpos - 1]) >>> (24 - 8) + | ((in[31 + inpos] - in[31 + inpos - 1]) << 8); + } + + protected static void integratedpack25(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + out[0 + outpos] = (in[0 + inpos] - initoffset) + | ((in[1 + inpos] - in[1 + inpos - 1]) << 25); + out[1 + outpos] = (in[1 + inpos] - in[1 + inpos - 1]) >>> (25 - 18) + | ((in[2 + inpos] - in[2 + inpos - 1]) << 18); + out[2 + outpos] = (in[2 + inpos] - in[2 + inpos - 1]) >>> (25 - 11) + | ((in[3 + inpos] - in[3 + inpos - 1]) << 11); + out[3 + outpos] = (in[3 + inpos] - in[3 + inpos - 1]) >>> (25 - 4) + | ((in[4 + inpos] - in[4 + inpos - 1]) << 4) + | ((in[5 + inpos] - in[5 + inpos - 1]) << 29); + out[4 + outpos] = (in[5 + inpos] - in[5 + inpos - 1]) >>> (25 - 22) + | ((in[6 + inpos] - in[6 + inpos - 1]) << 22); + out[5 + outpos] = (in[6 + inpos] - in[6 + inpos - 1]) >>> (25 - 15) + | ((in[7 + inpos] - in[7 + inpos - 1]) << 15); + out[6 + outpos] = (in[7 + inpos] - in[7 + inpos - 1]) >>> (25 - 8) + | ((in[8 + inpos] - in[8 + inpos - 1]) << 8); + out[7 + outpos] = (in[8 + inpos] - in[8 + inpos - 1]) >>> (25 - 1) + | ((in[9 + inpos] - in[9 + inpos - 1]) << 1) + | ((in[10 + inpos] - in[10 + inpos - 1]) << 26); + out[8 + outpos] = (in[10 + inpos] - in[10 + inpos - 1]) >>> (25 - 19) + | ((in[11 + inpos] - in[11 + inpos - 1]) << 19); + out[9 + outpos] = (in[11 + inpos] - in[11 + inpos - 1]) >>> (25 - 12) + | ((in[12 + inpos] - in[12 + inpos - 1]) << 12); + out[10 + outpos] = (in[12 + inpos] - in[12 + inpos - 1]) >>> (25 - 5) + | ((in[13 + inpos] - in[13 + inpos - 1]) << 5) + | ((in[14 + inpos] - in[14 + inpos - 1]) << 30); + out[11 + outpos] = (in[14 + inpos] - in[14 + inpos - 1]) >>> (25 - 23) + | ((in[15 + inpos] - in[15 + inpos - 1]) << 23); + out[12 + outpos] = (in[15 + inpos] - in[15 + inpos - 1]) >>> (25 - 16) + | ((in[16 + inpos] - in[16 + inpos - 1]) << 16); + out[13 + outpos] = (in[16 + inpos] - in[16 + inpos - 1]) >>> (25 - 9) + | ((in[17 + inpos] - in[17 + inpos - 1]) << 9); + out[14 + outpos] = (in[17 + inpos] - in[17 + inpos - 1]) >>> (25 - 2) + | ((in[18 + inpos] - in[18 + inpos - 1]) << 2) + | ((in[19 + inpos] - in[19 + inpos - 1]) << 27); + out[15 + outpos] = (in[19 + inpos] - in[19 + inpos - 1]) >>> (25 - 20) + | ((in[20 + inpos] - in[20 + inpos - 1]) << 20); + out[16 + outpos] = (in[20 + inpos] - in[20 + inpos - 1]) >>> (25 - 13) + | ((in[21 + inpos] - in[21 + inpos - 1]) << 13); + out[17 + outpos] = (in[21 + inpos] - in[21 + inpos - 1]) >>> (25 - 6) + | ((in[22 + inpos] - in[22 + inpos - 1]) << 6) + | ((in[23 + inpos] - in[23 + inpos - 1]) << 31); + out[18 + outpos] = (in[23 + inpos] - in[23 + inpos - 1]) >>> (25 - 24) + | ((in[24 + inpos] - in[24 + inpos - 1]) << 24); + out[19 + outpos] = (in[24 + inpos] - in[24 + inpos - 1]) >>> (25 - 17) + | ((in[25 + inpos] - in[25 + inpos - 1]) << 17); + out[20 + outpos] = (in[25 + inpos] - in[25 + inpos - 1]) >>> (25 - 10) + | ((in[26 + inpos] - in[26 + inpos - 1]) << 10); + out[21 + outpos] = (in[26 + inpos] - in[26 + inpos - 1]) >>> (25 - 3) + | ((in[27 + inpos] - in[27 + inpos - 1]) << 3) + | ((in[28 + inpos] - in[28 + inpos - 1]) << 28); + out[22 + outpos] = (in[28 + inpos] - in[28 + inpos - 1]) >>> (25 - 21) + | ((in[29 + inpos] - in[29 + inpos - 1]) << 21); + out[23 + outpos] = (in[29 + inpos] - in[29 + inpos - 1]) >>> (25 - 14) + | ((in[30 + inpos] - in[30 + inpos - 1]) << 14); + out[24 + outpos] = (in[30 + inpos] - in[30 + inpos - 1]) >>> (25 - 7) + | ((in[31 + inpos] - in[31 + inpos - 1]) << 7); + } + + protected static void integratedpack26(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + out[0 + outpos] = (in[0 + inpos] - initoffset) + | ((in[1 + inpos] - in[1 + inpos - 1]) << 26); + out[1 + outpos] = (in[1 + inpos] - in[1 + inpos - 1]) >>> (26 - 20) + | ((in[2 + inpos] - in[2 + inpos - 1]) << 20); + out[2 + outpos] = (in[2 + inpos] - in[2 + inpos - 1]) >>> (26 - 14) + | ((in[3 + inpos] - in[3 + inpos - 1]) << 14); + out[3 + outpos] = (in[3 + inpos] - in[3 + inpos - 1]) >>> (26 - 8) + | ((in[4 + inpos] - in[4 + inpos - 1]) << 8); + out[4 + outpos] = (in[4 + inpos] - in[4 + inpos - 1]) >>> (26 - 2) + | ((in[5 + inpos] - in[5 + inpos - 1]) << 2) + | ((in[6 + inpos] - in[6 + inpos - 1]) << 28); + out[5 + outpos] = (in[6 + inpos] - in[6 + inpos - 1]) >>> (26 - 22) + | ((in[7 + inpos] - in[7 + inpos - 1]) << 22); + out[6 + outpos] = (in[7 + inpos] - in[7 + inpos - 1]) >>> (26 - 16) + | ((in[8 + inpos] - in[8 + inpos - 1]) << 16); + out[7 + outpos] = (in[8 + inpos] - in[8 + inpos - 1]) >>> (26 - 10) + | ((in[9 + inpos] - in[9 + inpos - 1]) << 10); + out[8 + outpos] = (in[9 + inpos] - in[9 + inpos - 1]) >>> (26 - 4) + | ((in[10 + inpos] - in[10 + inpos - 1]) << 4) + | ((in[11 + inpos] - in[11 + inpos - 1]) << 30); + out[9 + outpos] = (in[11 + inpos] - in[11 + inpos - 1]) >>> (26 - 24) + | ((in[12 + inpos] - in[12 + inpos - 1]) << 24); + out[10 + outpos] = (in[12 + inpos] - in[12 + inpos - 1]) >>> (26 - 18) + | ((in[13 + inpos] - in[13 + inpos - 1]) << 18); + out[11 + outpos] = (in[13 + inpos] - in[13 + inpos - 1]) >>> (26 - 12) + | ((in[14 + inpos] - in[14 + inpos - 1]) << 12); + out[12 + outpos] = (in[14 + inpos] - in[14 + inpos - 1]) >>> (26 - 6) + | ((in[15 + inpos] - in[15 + inpos - 1]) << 6); + out[13 + outpos] = (in[16 + inpos] - in[16 + inpos - 1]) + | ((in[17 + inpos] - in[17 + inpos - 1]) << 26); + out[14 + outpos] = (in[17 + inpos] - in[17 + inpos - 1]) >>> (26 - 20) + | ((in[18 + inpos] - in[18 + inpos - 1]) << 20); + out[15 + outpos] = (in[18 + inpos] - in[18 + inpos - 1]) >>> (26 - 14) + | ((in[19 + inpos] - in[19 + inpos - 1]) << 14); + out[16 + outpos] = (in[19 + inpos] - in[19 + inpos - 1]) >>> (26 - 8) + | ((in[20 + inpos] - in[20 + inpos - 1]) << 8); + out[17 + outpos] = (in[20 + inpos] - in[20 + inpos - 1]) >>> (26 - 2) + | ((in[21 + inpos] - in[21 + inpos - 1]) << 2) + | ((in[22 + inpos] - in[22 + inpos - 1]) << 28); + out[18 + outpos] = (in[22 + inpos] - in[22 + inpos - 1]) >>> (26 - 22) + | ((in[23 + inpos] - in[23 + inpos - 1]) << 22); + out[19 + outpos] = (in[23 + inpos] - in[23 + inpos - 1]) >>> (26 - 16) + | ((in[24 + inpos] - in[24 + inpos - 1]) << 16); + out[20 + outpos] = (in[24 + inpos] - in[24 + inpos - 1]) >>> (26 - 10) + | ((in[25 + inpos] - in[25 + inpos - 1]) << 10); + out[21 + outpos] = (in[25 + inpos] - in[25 + inpos - 1]) >>> (26 - 4) + | ((in[26 + inpos] - in[26 + inpos - 1]) << 4) + | ((in[27 + inpos] - in[27 + inpos - 1]) << 30); + out[22 + outpos] = (in[27 + inpos] - in[27 + inpos - 1]) >>> (26 - 24) + | ((in[28 + inpos] - in[28 + inpos - 1]) << 24); + out[23 + outpos] = (in[28 + inpos] - in[28 + inpos - 1]) >>> (26 - 18) + | ((in[29 + inpos] - in[29 + inpos - 1]) << 18); + out[24 + outpos] = (in[29 + inpos] - in[29 + inpos - 1]) >>> (26 - 12) + | ((in[30 + inpos] - in[30 + inpos - 1]) << 12); + out[25 + outpos] = (in[30 + inpos] - in[30 + inpos - 1]) >>> (26 - 6) + | ((in[31 + inpos] - in[31 + inpos - 1]) << 6); + } + + protected static void integratedpack27(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + out[0 + outpos] = (in[0 + inpos] - initoffset) + | ((in[1 + inpos] - in[1 + inpos - 1]) << 27); + out[1 + outpos] = (in[1 + inpos] - in[1 + inpos - 1]) >>> (27 - 22) + | ((in[2 + inpos] - in[2 + inpos - 1]) << 22); + out[2 + outpos] = (in[2 + inpos] - in[2 + inpos - 1]) >>> (27 - 17) + | ((in[3 + inpos] - in[3 + inpos - 1]) << 17); + out[3 + outpos] = (in[3 + inpos] - in[3 + inpos - 1]) >>> (27 - 12) + | ((in[4 + inpos] - in[4 + inpos - 1]) << 12); + out[4 + outpos] = (in[4 + inpos] - in[4 + inpos - 1]) >>> (27 - 7) + | ((in[5 + inpos] - in[5 + inpos - 1]) << 7); + out[5 + outpos] = (in[5 + inpos] - in[5 + inpos - 1]) >>> (27 - 2) + | ((in[6 + inpos] - in[6 + inpos - 1]) << 2) + | ((in[7 + inpos] - in[7 + inpos - 1]) << 29); + out[6 + outpos] = (in[7 + inpos] - in[7 + inpos - 1]) >>> (27 - 24) + | ((in[8 + inpos] - in[8 + inpos - 1]) << 24); + out[7 + outpos] = (in[8 + inpos] - in[8 + inpos - 1]) >>> (27 - 19) + | ((in[9 + inpos] - in[9 + inpos - 1]) << 19); + out[8 + outpos] = (in[9 + inpos] - in[9 + inpos - 1]) >>> (27 - 14) + | ((in[10 + inpos] - in[10 + inpos - 1]) << 14); + out[9 + outpos] = (in[10 + inpos] - in[10 + inpos - 1]) >>> (27 - 9) + | ((in[11 + inpos] - in[11 + inpos - 1]) << 9); + out[10 + outpos] = (in[11 + inpos] - in[11 + inpos - 1]) >>> (27 - 4) + | ((in[12 + inpos] - in[12 + inpos - 1]) << 4) + | ((in[13 + inpos] - in[13 + inpos - 1]) << 31); + out[11 + outpos] = (in[13 + inpos] - in[13 + inpos - 1]) >>> (27 - 26) + | ((in[14 + inpos] - in[14 + inpos - 1]) << 26); + out[12 + outpos] = (in[14 + inpos] - in[14 + inpos - 1]) >>> (27 - 21) + | ((in[15 + inpos] - in[15 + inpos - 1]) << 21); + out[13 + outpos] = (in[15 + inpos] - in[15 + inpos - 1]) >>> (27 - 16) + | ((in[16 + inpos] - in[16 + inpos - 1]) << 16); + out[14 + outpos] = (in[16 + inpos] - in[16 + inpos - 1]) >>> (27 - 11) + | ((in[17 + inpos] - in[17 + inpos - 1]) << 11); + out[15 + outpos] = (in[17 + inpos] - in[17 + inpos - 1]) >>> (27 - 6) + | ((in[18 + inpos] - in[18 + inpos - 1]) << 6); + out[16 + outpos] = (in[18 + inpos] - in[18 + inpos - 1]) >>> (27 - 1) + | ((in[19 + inpos] - in[19 + inpos - 1]) << 1) + | ((in[20 + inpos] - in[20 + inpos - 1]) << 28); + out[17 + outpos] = (in[20 + inpos] - in[20 + inpos - 1]) >>> (27 - 23) + | ((in[21 + inpos] - in[21 + inpos - 1]) << 23); + out[18 + outpos] = (in[21 + inpos] - in[21 + inpos - 1]) >>> (27 - 18) + | ((in[22 + inpos] - in[22 + inpos - 1]) << 18); + out[19 + outpos] = (in[22 + inpos] - in[22 + inpos - 1]) >>> (27 - 13) + | ((in[23 + inpos] - in[23 + inpos - 1]) << 13); + out[20 + outpos] = (in[23 + inpos] - in[23 + inpos - 1]) >>> (27 - 8) + | ((in[24 + inpos] - in[24 + inpos - 1]) << 8); + out[21 + outpos] = (in[24 + inpos] - in[24 + inpos - 1]) >>> (27 - 3) + | ((in[25 + inpos] - in[25 + inpos - 1]) << 3) + | ((in[26 + inpos] - in[26 + inpos - 1]) << 30); + out[22 + outpos] = (in[26 + inpos] - in[26 + inpos - 1]) >>> (27 - 25) + | ((in[27 + inpos] - in[27 + inpos - 1]) << 25); + out[23 + outpos] = (in[27 + inpos] - in[27 + inpos - 1]) >>> (27 - 20) + | ((in[28 + inpos] - in[28 + inpos - 1]) << 20); + out[24 + outpos] = (in[28 + inpos] - in[28 + inpos - 1]) >>> (27 - 15) + | ((in[29 + inpos] - in[29 + inpos - 1]) << 15); + out[25 + outpos] = (in[29 + inpos] - in[29 + inpos - 1]) >>> (27 - 10) + | ((in[30 + inpos] - in[30 + inpos - 1]) << 10); + out[26 + outpos] = (in[30 + inpos] - in[30 + inpos - 1]) >>> (27 - 5) + | ((in[31 + inpos] - in[31 + inpos - 1]) << 5); + } + + protected static void integratedpack28(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + out[0 + outpos] = (in[0 + inpos] - initoffset) + | ((in[1 + inpos] - in[1 + inpos - 1]) << 28); + out[1 + outpos] = (in[1 + inpos] - in[1 + inpos - 1]) >>> (28 - 24) + | ((in[2 + inpos] - in[2 + inpos - 1]) << 24); + out[2 + outpos] = (in[2 + inpos] - in[2 + inpos - 1]) >>> (28 - 20) + | ((in[3 + inpos] - in[3 + inpos - 1]) << 20); + out[3 + outpos] = (in[3 + inpos] - in[3 + inpos - 1]) >>> (28 - 16) + | ((in[4 + inpos] - in[4 + inpos - 1]) << 16); + out[4 + outpos] = (in[4 + inpos] - in[4 + inpos - 1]) >>> (28 - 12) + | ((in[5 + inpos] - in[5 + inpos - 1]) << 12); + out[5 + outpos] = (in[5 + inpos] - in[5 + inpos - 1]) >>> (28 - 8) + | ((in[6 + inpos] - in[6 + inpos - 1]) << 8); + out[6 + outpos] = (in[6 + inpos] - in[6 + inpos - 1]) >>> (28 - 4) + | ((in[7 + inpos] - in[7 + inpos - 1]) << 4); + out[7 + outpos] = (in[8 + inpos] - in[8 + inpos - 1]) + | ((in[9 + inpos] - in[9 + inpos - 1]) << 28); + out[8 + outpos] = (in[9 + inpos] - in[9 + inpos - 1]) >>> (28 - 24) + | ((in[10 + inpos] - in[10 + inpos - 1]) << 24); + out[9 + outpos] = (in[10 + inpos] - in[10 + inpos - 1]) >>> (28 - 20) + | ((in[11 + inpos] - in[11 + inpos - 1]) << 20); + out[10 + outpos] = (in[11 + inpos] - in[11 + inpos - 1]) >>> (28 - 16) + | ((in[12 + inpos] - in[12 + inpos - 1]) << 16); + out[11 + outpos] = (in[12 + inpos] - in[12 + inpos - 1]) >>> (28 - 12) + | ((in[13 + inpos] - in[13 + inpos - 1]) << 12); + out[12 + outpos] = (in[13 + inpos] - in[13 + inpos - 1]) >>> (28 - 8) + | ((in[14 + inpos] - in[14 + inpos - 1]) << 8); + out[13 + outpos] = (in[14 + inpos] - in[14 + inpos - 1]) >>> (28 - 4) + | ((in[15 + inpos] - in[15 + inpos - 1]) << 4); + out[14 + outpos] = (in[16 + inpos] - in[16 + inpos - 1]) + | ((in[17 + inpos] - in[17 + inpos - 1]) << 28); + out[15 + outpos] = (in[17 + inpos] - in[17 + inpos - 1]) >>> (28 - 24) + | ((in[18 + inpos] - in[18 + inpos - 1]) << 24); + out[16 + outpos] = (in[18 + inpos] - in[18 + inpos - 1]) >>> (28 - 20) + | ((in[19 + inpos] - in[19 + inpos - 1]) << 20); + out[17 + outpos] = (in[19 + inpos] - in[19 + inpos - 1]) >>> (28 - 16) + | ((in[20 + inpos] - in[20 + inpos - 1]) << 16); + out[18 + outpos] = (in[20 + inpos] - in[20 + inpos - 1]) >>> (28 - 12) + | ((in[21 + inpos] - in[21 + inpos - 1]) << 12); + out[19 + outpos] = (in[21 + inpos] - in[21 + inpos - 1]) >>> (28 - 8) + | ((in[22 + inpos] - in[22 + inpos - 1]) << 8); + out[20 + outpos] = (in[22 + inpos] - in[22 + inpos - 1]) >>> (28 - 4) + | ((in[23 + inpos] - in[23 + inpos - 1]) << 4); + out[21 + outpos] = (in[24 + inpos] - in[24 + inpos - 1]) + | ((in[25 + inpos] - in[25 + inpos - 1]) << 28); + out[22 + outpos] = (in[25 + inpos] - in[25 + inpos - 1]) >>> (28 - 24) + | ((in[26 + inpos] - in[26 + inpos - 1]) << 24); + out[23 + outpos] = (in[26 + inpos] - in[26 + inpos - 1]) >>> (28 - 20) + | ((in[27 + inpos] - in[27 + inpos - 1]) << 20); + out[24 + outpos] = (in[27 + inpos] - in[27 + inpos - 1]) >>> (28 - 16) + | ((in[28 + inpos] - in[28 + inpos - 1]) << 16); + out[25 + outpos] = (in[28 + inpos] - in[28 + inpos - 1]) >>> (28 - 12) + | ((in[29 + inpos] - in[29 + inpos - 1]) << 12); + out[26 + outpos] = (in[29 + inpos] - in[29 + inpos - 1]) >>> (28 - 8) + | ((in[30 + inpos] - in[30 + inpos - 1]) << 8); + out[27 + outpos] = (in[30 + inpos] - in[30 + inpos - 1]) >>> (28 - 4) + | ((in[31 + inpos] - in[31 + inpos - 1]) << 4); + } + + protected static void integratedpack29(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + out[0 + outpos] = (in[0 + inpos] - initoffset) + | ((in[1 + inpos] - in[1 + inpos - 1]) << 29); + out[1 + outpos] = (in[1 + inpos] - in[1 + inpos - 1]) >>> (29 - 26) + | ((in[2 + inpos] - in[2 + inpos - 1]) << 26); + out[2 + outpos] = (in[2 + inpos] - in[2 + inpos - 1]) >>> (29 - 23) + | ((in[3 + inpos] - in[3 + inpos - 1]) << 23); + out[3 + outpos] = (in[3 + inpos] - in[3 + inpos - 1]) >>> (29 - 20) + | ((in[4 + inpos] - in[4 + inpos - 1]) << 20); + out[4 + outpos] = (in[4 + inpos] - in[4 + inpos - 1]) >>> (29 - 17) + | ((in[5 + inpos] - in[5 + inpos - 1]) << 17); + out[5 + outpos] = (in[5 + inpos] - in[5 + inpos - 1]) >>> (29 - 14) + | ((in[6 + inpos] - in[6 + inpos - 1]) << 14); + out[6 + outpos] = (in[6 + inpos] - in[6 + inpos - 1]) >>> (29 - 11) + | ((in[7 + inpos] - in[7 + inpos - 1]) << 11); + out[7 + outpos] = (in[7 + inpos] - in[7 + inpos - 1]) >>> (29 - 8) + | ((in[8 + inpos] - in[8 + inpos - 1]) << 8); + out[8 + outpos] = (in[8 + inpos] - in[8 + inpos - 1]) >>> (29 - 5) + | ((in[9 + inpos] - in[9 + inpos - 1]) << 5); + out[9 + outpos] = (in[9 + inpos] - in[9 + inpos - 1]) >>> (29 - 2) + | ((in[10 + inpos] - in[10 + inpos - 1]) << 2) + | ((in[11 + inpos] - in[11 + inpos - 1]) << 31); + out[10 + outpos] = (in[11 + inpos] - in[11 + inpos - 1]) >>> (29 - 28) + | ((in[12 + inpos] - in[12 + inpos - 1]) << 28); + out[11 + outpos] = (in[12 + inpos] - in[12 + inpos - 1]) >>> (29 - 25) + | ((in[13 + inpos] - in[13 + inpos - 1]) << 25); + out[12 + outpos] = (in[13 + inpos] - in[13 + inpos - 1]) >>> (29 - 22) + | ((in[14 + inpos] - in[14 + inpos - 1]) << 22); + out[13 + outpos] = (in[14 + inpos] - in[14 + inpos - 1]) >>> (29 - 19) + | ((in[15 + inpos] - in[15 + inpos - 1]) << 19); + out[14 + outpos] = (in[15 + inpos] - in[15 + inpos - 1]) >>> (29 - 16) + | ((in[16 + inpos] - in[16 + inpos - 1]) << 16); + out[15 + outpos] = (in[16 + inpos] - in[16 + inpos - 1]) >>> (29 - 13) + | ((in[17 + inpos] - in[17 + inpos - 1]) << 13); + out[16 + outpos] = (in[17 + inpos] - in[17 + inpos - 1]) >>> (29 - 10) + | ((in[18 + inpos] - in[18 + inpos - 1]) << 10); + out[17 + outpos] = (in[18 + inpos] - in[18 + inpos - 1]) >>> (29 - 7) + | ((in[19 + inpos] - in[19 + inpos - 1]) << 7); + out[18 + outpos] = (in[19 + inpos] - in[19 + inpos - 1]) >>> (29 - 4) + | ((in[20 + inpos] - in[20 + inpos - 1]) << 4); + out[19 + outpos] = (in[20 + inpos] - in[20 + inpos - 1]) >>> (29 - 1) + | ((in[21 + inpos] - in[21 + inpos - 1]) << 1) + | ((in[22 + inpos] - in[22 + inpos - 1]) << 30); + out[20 + outpos] = (in[22 + inpos] - in[22 + inpos - 1]) >>> (29 - 27) + | ((in[23 + inpos] - in[23 + inpos - 1]) << 27); + out[21 + outpos] = (in[23 + inpos] - in[23 + inpos - 1]) >>> (29 - 24) + | ((in[24 + inpos] - in[24 + inpos - 1]) << 24); + out[22 + outpos] = (in[24 + inpos] - in[24 + inpos - 1]) >>> (29 - 21) + | ((in[25 + inpos] - in[25 + inpos - 1]) << 21); + out[23 + outpos] = (in[25 + inpos] - in[25 + inpos - 1]) >>> (29 - 18) + | ((in[26 + inpos] - in[26 + inpos - 1]) << 18); + out[24 + outpos] = (in[26 + inpos] - in[26 + inpos - 1]) >>> (29 - 15) + | ((in[27 + inpos] - in[27 + inpos - 1]) << 15); + out[25 + outpos] = (in[27 + inpos] - in[27 + inpos - 1]) >>> (29 - 12) + | ((in[28 + inpos] - in[28 + inpos - 1]) << 12); + out[26 + outpos] = (in[28 + inpos] - in[28 + inpos - 1]) >>> (29 - 9) + | ((in[29 + inpos] - in[29 + inpos - 1]) << 9); + out[27 + outpos] = (in[29 + inpos] - in[29 + inpos - 1]) >>> (29 - 6) + | ((in[30 + inpos] - in[30 + inpos - 1]) << 6); + out[28 + outpos] = (in[30 + inpos] - in[30 + inpos - 1]) >>> (29 - 3) + | ((in[31 + inpos] - in[31 + inpos - 1]) << 3); + } + + protected static void integratedpack3(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + out[0 + outpos] = (in[0 + inpos] - initoffset) + | ((in[1 + inpos] - in[1 + inpos - 1]) << 3) + | ((in[2 + inpos] - in[2 + inpos - 1]) << 6) + | ((in[3 + inpos] - in[3 + inpos - 1]) << 9) + | ((in[4 + inpos] - in[4 + inpos - 1]) << 12) + | ((in[5 + inpos] - in[5 + inpos - 1]) << 15) + | ((in[6 + inpos] - in[6 + inpos - 1]) << 18) + | ((in[7 + inpos] - in[7 + inpos - 1]) << 21) + | ((in[8 + inpos] - in[8 + inpos - 1]) << 24) + | ((in[9 + inpos] - in[9 + inpos - 1]) << 27) + | ((in[10 + inpos] - in[10 + inpos - 1]) << 30); + out[1 + outpos] = (in[10 + inpos] - in[10 + inpos - 1]) >>> (3 - 1) + | ((in[11 + inpos] - in[11 + inpos - 1]) << 1) + | ((in[12 + inpos] - in[12 + inpos - 1]) << 4) + | ((in[13 + inpos] - in[13 + inpos - 1]) << 7) + | ((in[14 + inpos] - in[14 + inpos - 1]) << 10) + | ((in[15 + inpos] - in[15 + inpos - 1]) << 13) + | ((in[16 + inpos] - in[16 + inpos - 1]) << 16) + | ((in[17 + inpos] - in[17 + inpos - 1]) << 19) + | ((in[18 + inpos] - in[18 + inpos - 1]) << 22) + | ((in[19 + inpos] - in[19 + inpos - 1]) << 25) + | ((in[20 + inpos] - in[20 + inpos - 1]) << 28) + | ((in[21 + inpos] - in[21 + inpos - 1]) << 31); + out[2 + outpos] = (in[21 + inpos] - in[21 + inpos - 1]) >>> (3 - 2) + | ((in[22 + inpos] - in[22 + inpos - 1]) << 2) + | ((in[23 + inpos] - in[23 + inpos - 1]) << 5) + | ((in[24 + inpos] - in[24 + inpos - 1]) << 8) + | ((in[25 + inpos] - in[25 + inpos - 1]) << 11) + | ((in[26 + inpos] - in[26 + inpos - 1]) << 14) + | ((in[27 + inpos] - in[27 + inpos - 1]) << 17) + | ((in[28 + inpos] - in[28 + inpos - 1]) << 20) + | ((in[29 + inpos] - in[29 + inpos - 1]) << 23) + | ((in[30 + inpos] - in[30 + inpos - 1]) << 26) + | ((in[31 + inpos] - in[31 + inpos - 1]) << 29); + } + + protected static void integratedpack30(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + out[0 + outpos] = (in[0 + inpos] - initoffset) + | ((in[1 + inpos] - in[1 + inpos - 1]) << 30); + out[1 + outpos] = (in[1 + inpos] - in[1 + inpos - 1]) >>> (30 - 28) + | ((in[2 + inpos] - in[2 + inpos - 1]) << 28); + out[2 + outpos] = (in[2 + inpos] - in[2 + inpos - 1]) >>> (30 - 26) + | ((in[3 + inpos] - in[3 + inpos - 1]) << 26); + out[3 + outpos] = (in[3 + inpos] - in[3 + inpos - 1]) >>> (30 - 24) + | ((in[4 + inpos] - in[4 + inpos - 1]) << 24); + out[4 + outpos] = (in[4 + inpos] - in[4 + inpos - 1]) >>> (30 - 22) + | ((in[5 + inpos] - in[5 + inpos - 1]) << 22); + out[5 + outpos] = (in[5 + inpos] - in[5 + inpos - 1]) >>> (30 - 20) + | ((in[6 + inpos] - in[6 + inpos - 1]) << 20); + out[6 + outpos] = (in[6 + inpos] - in[6 + inpos - 1]) >>> (30 - 18) + | ((in[7 + inpos] - in[7 + inpos - 1]) << 18); + out[7 + outpos] = (in[7 + inpos] - in[7 + inpos - 1]) >>> (30 - 16) + | ((in[8 + inpos] - in[8 + inpos - 1]) << 16); + out[8 + outpos] = (in[8 + inpos] - in[8 + inpos - 1]) >>> (30 - 14) + | ((in[9 + inpos] - in[9 + inpos - 1]) << 14); + out[9 + outpos] = (in[9 + inpos] - in[9 + inpos - 1]) >>> (30 - 12) + | ((in[10 + inpos] - in[10 + inpos - 1]) << 12); + out[10 + outpos] = (in[10 + inpos] - in[10 + inpos - 1]) >>> (30 - 10) + | ((in[11 + inpos] - in[11 + inpos - 1]) << 10); + out[11 + outpos] = (in[11 + inpos] - in[11 + inpos - 1]) >>> (30 - 8) + | ((in[12 + inpos] - in[12 + inpos - 1]) << 8); + out[12 + outpos] = (in[12 + inpos] - in[12 + inpos - 1]) >>> (30 - 6) + | ((in[13 + inpos] - in[13 + inpos - 1]) << 6); + out[13 + outpos] = (in[13 + inpos] - in[13 + inpos - 1]) >>> (30 - 4) + | ((in[14 + inpos] - in[14 + inpos - 1]) << 4); + out[14 + outpos] = (in[14 + inpos] - in[14 + inpos - 1]) >>> (30 - 2) + | ((in[15 + inpos] - in[15 + inpos - 1]) << 2); + out[15 + outpos] = (in[16 + inpos] - in[16 + inpos - 1]) + | ((in[17 + inpos] - in[17 + inpos - 1]) << 30); + out[16 + outpos] = (in[17 + inpos] - in[17 + inpos - 1]) >>> (30 - 28) + | ((in[18 + inpos] - in[18 + inpos - 1]) << 28); + out[17 + outpos] = (in[18 + inpos] - in[18 + inpos - 1]) >>> (30 - 26) + | ((in[19 + inpos] - in[19 + inpos - 1]) << 26); + out[18 + outpos] = (in[19 + inpos] - in[19 + inpos - 1]) >>> (30 - 24) + | ((in[20 + inpos] - in[20 + inpos - 1]) << 24); + out[19 + outpos] = (in[20 + inpos] - in[20 + inpos - 1]) >>> (30 - 22) + | ((in[21 + inpos] - in[21 + inpos - 1]) << 22); + out[20 + outpos] = (in[21 + inpos] - in[21 + inpos - 1]) >>> (30 - 20) + | ((in[22 + inpos] - in[22 + inpos - 1]) << 20); + out[21 + outpos] = (in[22 + inpos] - in[22 + inpos - 1]) >>> (30 - 18) + | ((in[23 + inpos] - in[23 + inpos - 1]) << 18); + out[22 + outpos] = (in[23 + inpos] - in[23 + inpos - 1]) >>> (30 - 16) + | ((in[24 + inpos] - in[24 + inpos - 1]) << 16); + out[23 + outpos] = (in[24 + inpos] - in[24 + inpos - 1]) >>> (30 - 14) + | ((in[25 + inpos] - in[25 + inpos - 1]) << 14); + out[24 + outpos] = (in[25 + inpos] - in[25 + inpos - 1]) >>> (30 - 12) + | ((in[26 + inpos] - in[26 + inpos - 1]) << 12); + out[25 + outpos] = (in[26 + inpos] - in[26 + inpos - 1]) >>> (30 - 10) + | ((in[27 + inpos] - in[27 + inpos - 1]) << 10); + out[26 + outpos] = (in[27 + inpos] - in[27 + inpos - 1]) >>> (30 - 8) + | ((in[28 + inpos] - in[28 + inpos - 1]) << 8); + out[27 + outpos] = (in[28 + inpos] - in[28 + inpos - 1]) >>> (30 - 6) + | ((in[29 + inpos] - in[29 + inpos - 1]) << 6); + out[28 + outpos] = (in[29 + inpos] - in[29 + inpos - 1]) >>> (30 - 4) + | ((in[30 + inpos] - in[30 + inpos - 1]) << 4); + out[29 + outpos] = (in[30 + inpos] - in[30 + inpos - 1]) >>> (30 - 2) + | ((in[31 + inpos] - in[31 + inpos - 1]) << 2); + } + + protected static void integratedpack31(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + out[0 + outpos] = (in[0 + inpos] - initoffset) + | ((in[1 + inpos] - in[1 + inpos - 1]) << 31); + out[1 + outpos] = (in[1 + inpos] - in[1 + inpos - 1]) >>> (31 - 30) + | ((in[2 + inpos] - in[2 + inpos - 1]) << 30); + out[2 + outpos] = (in[2 + inpos] - in[2 + inpos - 1]) >>> (31 - 29) + | ((in[3 + inpos] - in[3 + inpos - 1]) << 29); + out[3 + outpos] = (in[3 + inpos] - in[3 + inpos - 1]) >>> (31 - 28) + | ((in[4 + inpos] - in[4 + inpos - 1]) << 28); + out[4 + outpos] = (in[4 + inpos] - in[4 + inpos - 1]) >>> (31 - 27) + | ((in[5 + inpos] - in[5 + inpos - 1]) << 27); + out[5 + outpos] = (in[5 + inpos] - in[5 + inpos - 1]) >>> (31 - 26) + | ((in[6 + inpos] - in[6 + inpos - 1]) << 26); + out[6 + outpos] = (in[6 + inpos] - in[6 + inpos - 1]) >>> (31 - 25) + | ((in[7 + inpos] - in[7 + inpos - 1]) << 25); + out[7 + outpos] = (in[7 + inpos] - in[7 + inpos - 1]) >>> (31 - 24) + | ((in[8 + inpos] - in[8 + inpos - 1]) << 24); + out[8 + outpos] = (in[8 + inpos] - in[8 + inpos - 1]) >>> (31 - 23) + | ((in[9 + inpos] - in[9 + inpos - 1]) << 23); + out[9 + outpos] = (in[9 + inpos] - in[9 + inpos - 1]) >>> (31 - 22) + | ((in[10 + inpos] - in[10 + inpos - 1]) << 22); + out[10 + outpos] = (in[10 + inpos] - in[10 + inpos - 1]) >>> (31 - 21) + | ((in[11 + inpos] - in[11 + inpos - 1]) << 21); + out[11 + outpos] = (in[11 + inpos] - in[11 + inpos - 1]) >>> (31 - 20) + | ((in[12 + inpos] - in[12 + inpos - 1]) << 20); + out[12 + outpos] = (in[12 + inpos] - in[12 + inpos - 1]) >>> (31 - 19) + | ((in[13 + inpos] - in[13 + inpos - 1]) << 19); + out[13 + outpos] = (in[13 + inpos] - in[13 + inpos - 1]) >>> (31 - 18) + | ((in[14 + inpos] - in[14 + inpos - 1]) << 18); + out[14 + outpos] = (in[14 + inpos] - in[14 + inpos - 1]) >>> (31 - 17) + | ((in[15 + inpos] - in[15 + inpos - 1]) << 17); + out[15 + outpos] = (in[15 + inpos] - in[15 + inpos - 1]) >>> (31 - 16) + | ((in[16 + inpos] - in[16 + inpos - 1]) << 16); + out[16 + outpos] = (in[16 + inpos] - in[16 + inpos - 1]) >>> (31 - 15) + | ((in[17 + inpos] - in[17 + inpos - 1]) << 15); + out[17 + outpos] = (in[17 + inpos] - in[17 + inpos - 1]) >>> (31 - 14) + | ((in[18 + inpos] - in[18 + inpos - 1]) << 14); + out[18 + outpos] = (in[18 + inpos] - in[18 + inpos - 1]) >>> (31 - 13) + | ((in[19 + inpos] - in[19 + inpos - 1]) << 13); + out[19 + outpos] = (in[19 + inpos] - in[19 + inpos - 1]) >>> (31 - 12) + | ((in[20 + inpos] - in[20 + inpos - 1]) << 12); + out[20 + outpos] = (in[20 + inpos] - in[20 + inpos - 1]) >>> (31 - 11) + | ((in[21 + inpos] - in[21 + inpos - 1]) << 11); + out[21 + outpos] = (in[21 + inpos] - in[21 + inpos - 1]) >>> (31 - 10) + | ((in[22 + inpos] - in[22 + inpos - 1]) << 10); + out[22 + outpos] = (in[22 + inpos] - in[22 + inpos - 1]) >>> (31 - 9) + | ((in[23 + inpos] - in[23 + inpos - 1]) << 9); + out[23 + outpos] = (in[23 + inpos] - in[23 + inpos - 1]) >>> (31 - 8) + | ((in[24 + inpos] - in[24 + inpos - 1]) << 8); + out[24 + outpos] = (in[24 + inpos] - in[24 + inpos - 1]) >>> (31 - 7) + | ((in[25 + inpos] - in[25 + inpos - 1]) << 7); + out[25 + outpos] = (in[25 + inpos] - in[25 + inpos - 1]) >>> (31 - 6) + | ((in[26 + inpos] - in[26 + inpos - 1]) << 6); + out[26 + outpos] = (in[26 + inpos] - in[26 + inpos - 1]) >>> (31 - 5) + | ((in[27 + inpos] - in[27 + inpos - 1]) << 5); + out[27 + outpos] = (in[27 + inpos] - in[27 + inpos - 1]) >>> (31 - 4) + | ((in[28 + inpos] - in[28 + inpos - 1]) << 4); + out[28 + outpos] = (in[28 + inpos] - in[28 + inpos - 1]) >>> (31 - 3) + | ((in[29 + inpos] - in[29 + inpos - 1]) << 3); + out[29 + outpos] = (in[29 + inpos] - in[29 + inpos - 1]) >>> (31 - 2) + | ((in[30 + inpos] - in[30 + inpos - 1]) << 2); + out[30 + outpos] = (in[30 + inpos] - in[30 + inpos - 1]) >>> (31 - 1) + | ((in[31 + inpos] - in[31 + inpos - 1]) << 1); + } + + protected static void integratedpack32(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + System.arraycopy(in, inpos, out, outpos, 32); // no sense in + // doing delta + // coding + } + + protected static void integratedpack4(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + out[0 + outpos] = (in[0 + inpos] - initoffset) + | ((in[1 + inpos] - in[1 + inpos - 1]) << 4) + | ((in[2 + inpos] - in[2 + inpos - 1]) << 8) + | ((in[3 + inpos] - in[3 + inpos - 1]) << 12) + | ((in[4 + inpos] - in[4 + inpos - 1]) << 16) + | ((in[5 + inpos] - in[5 + inpos - 1]) << 20) + | ((in[6 + inpos] - in[6 + inpos - 1]) << 24) + | ((in[7 + inpos] - in[7 + inpos - 1]) << 28); + out[1 + outpos] = (in[8 + inpos] - in[8 + inpos - 1]) + | ((in[9 + inpos] - in[9 + inpos - 1]) << 4) + | ((in[10 + inpos] - in[10 + inpos - 1]) << 8) + | ((in[11 + inpos] - in[11 + inpos - 1]) << 12) + | ((in[12 + inpos] - in[12 + inpos - 1]) << 16) + | ((in[13 + inpos] - in[13 + inpos - 1]) << 20) + | ((in[14 + inpos] - in[14 + inpos - 1]) << 24) + | ((in[15 + inpos] - in[15 + inpos - 1]) << 28); + out[2 + outpos] = (in[16 + inpos] - in[16 + inpos - 1]) + | ((in[17 + inpos] - in[17 + inpos - 1]) << 4) + | ((in[18 + inpos] - in[18 + inpos - 1]) << 8) + | ((in[19 + inpos] - in[19 + inpos - 1]) << 12) + | ((in[20 + inpos] - in[20 + inpos - 1]) << 16) + | ((in[21 + inpos] - in[21 + inpos - 1]) << 20) + | ((in[22 + inpos] - in[22 + inpos - 1]) << 24) + | ((in[23 + inpos] - in[23 + inpos - 1]) << 28); + out[3 + outpos] = (in[24 + inpos] - in[24 + inpos - 1]) + | ((in[25 + inpos] - in[25 + inpos - 1]) << 4) + | ((in[26 + inpos] - in[26 + inpos - 1]) << 8) + | ((in[27 + inpos] - in[27 + inpos - 1]) << 12) + | ((in[28 + inpos] - in[28 + inpos - 1]) << 16) + | ((in[29 + inpos] - in[29 + inpos - 1]) << 20) + | ((in[30 + inpos] - in[30 + inpos - 1]) << 24) + | ((in[31 + inpos] - in[31 + inpos - 1]) << 28); + } + + protected static void integratedpack5(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + out[0 + outpos] = (in[0 + inpos] - initoffset) + | ((in[1 + inpos] - in[1 + inpos - 1]) << 5) + | ((in[2 + inpos] - in[2 + inpos - 1]) << 10) + | ((in[3 + inpos] - in[3 + inpos - 1]) << 15) + | ((in[4 + inpos] - in[4 + inpos - 1]) << 20) + | ((in[5 + inpos] - in[5 + inpos - 1]) << 25) + | ((in[6 + inpos] - in[6 + inpos - 1]) << 30); + out[1 + outpos] = (in[6 + inpos] - in[6 + inpos - 1]) >>> (5 - 3) + | ((in[7 + inpos] - in[7 + inpos - 1]) << 3) + | ((in[8 + inpos] - in[8 + inpos - 1]) << 8) + | ((in[9 + inpos] - in[9 + inpos - 1]) << 13) + | ((in[10 + inpos] - in[10 + inpos - 1]) << 18) + | ((in[11 + inpos] - in[11 + inpos - 1]) << 23) + | ((in[12 + inpos] - in[12 + inpos - 1]) << 28); + out[2 + outpos] = (in[12 + inpos] - in[12 + inpos - 1]) >>> (5 - 1) + | ((in[13 + inpos] - in[13 + inpos - 1]) << 1) + | ((in[14 + inpos] - in[14 + inpos - 1]) << 6) + | ((in[15 + inpos] - in[15 + inpos - 1]) << 11) + | ((in[16 + inpos] - in[16 + inpos - 1]) << 16) + | ((in[17 + inpos] - in[17 + inpos - 1]) << 21) + | ((in[18 + inpos] - in[18 + inpos - 1]) << 26) + | ((in[19 + inpos] - in[19 + inpos - 1]) << 31); + out[3 + outpos] = (in[19 + inpos] - in[19 + inpos - 1]) >>> (5 - 4) + | ((in[20 + inpos] - in[20 + inpos - 1]) << 4) + | ((in[21 + inpos] - in[21 + inpos - 1]) << 9) + | ((in[22 + inpos] - in[22 + inpos - 1]) << 14) + | ((in[23 + inpos] - in[23 + inpos - 1]) << 19) + | ((in[24 + inpos] - in[24 + inpos - 1]) << 24) + | ((in[25 + inpos] - in[25 + inpos - 1]) << 29); + out[4 + outpos] = (in[25 + inpos] - in[25 + inpos - 1]) >>> (5 - 2) + | ((in[26 + inpos] - in[26 + inpos - 1]) << 2) + | ((in[27 + inpos] - in[27 + inpos - 1]) << 7) + | ((in[28 + inpos] - in[28 + inpos - 1]) << 12) + | ((in[29 + inpos] - in[29 + inpos - 1]) << 17) + | ((in[30 + inpos] - in[30 + inpos - 1]) << 22) + | ((in[31 + inpos] - in[31 + inpos - 1]) << 27); + } + + protected static void integratedpack6(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + out[0 + outpos] = (in[0 + inpos] - initoffset) + | ((in[1 + inpos] - in[1 + inpos - 1]) << 6) + | ((in[2 + inpos] - in[2 + inpos - 1]) << 12) + | ((in[3 + inpos] - in[3 + inpos - 1]) << 18) + | ((in[4 + inpos] - in[4 + inpos - 1]) << 24) + | ((in[5 + inpos] - in[5 + inpos - 1]) << 30); + out[1 + outpos] = (in[5 + inpos] - in[5 + inpos - 1]) >>> (6 - 4) + | ((in[6 + inpos] - in[6 + inpos - 1]) << 4) + | ((in[7 + inpos] - in[7 + inpos - 1]) << 10) + | ((in[8 + inpos] - in[8 + inpos - 1]) << 16) + | ((in[9 + inpos] - in[9 + inpos - 1]) << 22) + | ((in[10 + inpos] - in[10 + inpos - 1]) << 28); + out[2 + outpos] = (in[10 + inpos] - in[10 + inpos - 1]) >>> (6 - 2) + | ((in[11 + inpos] - in[11 + inpos - 1]) << 2) + | ((in[12 + inpos] - in[12 + inpos - 1]) << 8) + | ((in[13 + inpos] - in[13 + inpos - 1]) << 14) + | ((in[14 + inpos] - in[14 + inpos - 1]) << 20) + | ((in[15 + inpos] - in[15 + inpos - 1]) << 26); + out[3 + outpos] = (in[16 + inpos] - in[16 + inpos - 1]) + | ((in[17 + inpos] - in[17 + inpos - 1]) << 6) + | ((in[18 + inpos] - in[18 + inpos - 1]) << 12) + | ((in[19 + inpos] - in[19 + inpos - 1]) << 18) + | ((in[20 + inpos] - in[20 + inpos - 1]) << 24) + | ((in[21 + inpos] - in[21 + inpos - 1]) << 30); + out[4 + outpos] = (in[21 + inpos] - in[21 + inpos - 1]) >>> (6 - 4) + | ((in[22 + inpos] - in[22 + inpos - 1]) << 4) + | ((in[23 + inpos] - in[23 + inpos - 1]) << 10) + | ((in[24 + inpos] - in[24 + inpos - 1]) << 16) + | ((in[25 + inpos] - in[25 + inpos - 1]) << 22) + | ((in[26 + inpos] - in[26 + inpos - 1]) << 28); + out[5 + outpos] = (in[26 + inpos] - in[26 + inpos - 1]) >>> (6 - 2) + | ((in[27 + inpos] - in[27 + inpos - 1]) << 2) + | ((in[28 + inpos] - in[28 + inpos - 1]) << 8) + | ((in[29 + inpos] - in[29 + inpos - 1]) << 14) + | ((in[30 + inpos] - in[30 + inpos - 1]) << 20) + | ((in[31 + inpos] - in[31 + inpos - 1]) << 26); + } + + protected static void integratedpack7(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + out[0 + outpos] = (in[0 + inpos] - initoffset) + | ((in[1 + inpos] - in[1 + inpos - 1]) << 7) + | ((in[2 + inpos] - in[2 + inpos - 1]) << 14) + | ((in[3 + inpos] - in[3 + inpos - 1]) << 21) + | ((in[4 + inpos] - in[4 + inpos - 1]) << 28); + out[1 + outpos] = (in[4 + inpos] - in[4 + inpos - 1]) >>> (7 - 3) + | ((in[5 + inpos] - in[5 + inpos - 1]) << 3) + | ((in[6 + inpos] - in[6 + inpos - 1]) << 10) + | ((in[7 + inpos] - in[7 + inpos - 1]) << 17) + | ((in[8 + inpos] - in[8 + inpos - 1]) << 24) + | ((in[9 + inpos] - in[9 + inpos - 1]) << 31); + out[2 + outpos] = (in[9 + inpos] - in[9 + inpos - 1]) >>> (7 - 6) + | ((in[10 + inpos] - in[10 + inpos - 1]) << 6) + | ((in[11 + inpos] - in[11 + inpos - 1]) << 13) + | ((in[12 + inpos] - in[12 + inpos - 1]) << 20) + | ((in[13 + inpos] - in[13 + inpos - 1]) << 27); + out[3 + outpos] = (in[13 + inpos] - in[13 + inpos - 1]) >>> (7 - 2) + | ((in[14 + inpos] - in[14 + inpos - 1]) << 2) + | ((in[15 + inpos] - in[15 + inpos - 1]) << 9) + | ((in[16 + inpos] - in[16 + inpos - 1]) << 16) + | ((in[17 + inpos] - in[17 + inpos - 1]) << 23) + | ((in[18 + inpos] - in[18 + inpos - 1]) << 30); + out[4 + outpos] = (in[18 + inpos] - in[18 + inpos - 1]) >>> (7 - 5) + | ((in[19 + inpos] - in[19 + inpos - 1]) << 5) + | ((in[20 + inpos] - in[20 + inpos - 1]) << 12) + | ((in[21 + inpos] - in[21 + inpos - 1]) << 19) + | ((in[22 + inpos] - in[22 + inpos - 1]) << 26); + out[5 + outpos] = (in[22 + inpos] - in[22 + inpos - 1]) >>> (7 - 1) + | ((in[23 + inpos] - in[23 + inpos - 1]) << 1) + | ((in[24 + inpos] - in[24 + inpos - 1]) << 8) + | ((in[25 + inpos] - in[25 + inpos - 1]) << 15) + | ((in[26 + inpos] - in[26 + inpos - 1]) << 22) + | ((in[27 + inpos] - in[27 + inpos - 1]) << 29); + out[6 + outpos] = (in[27 + inpos] - in[27 + inpos - 1]) >>> (7 - 4) + | ((in[28 + inpos] - in[28 + inpos - 1]) << 4) + | ((in[29 + inpos] - in[29 + inpos - 1]) << 11) + | ((in[30 + inpos] - in[30 + inpos - 1]) << 18) + | ((in[31 + inpos] - in[31 + inpos - 1]) << 25); + } + + protected static void integratedpack8(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + out[0 + outpos] = (in[0 + inpos] - initoffset) + | ((in[1 + inpos] - in[1 + inpos - 1]) << 8) + | ((in[2 + inpos] - in[2 + inpos - 1]) << 16) + | ((in[3 + inpos] - in[3 + inpos - 1]) << 24); + out[1 + outpos] = (in[4 + inpos] - in[4 + inpos - 1]) + | ((in[5 + inpos] - in[5 + inpos - 1]) << 8) + | ((in[6 + inpos] - in[6 + inpos - 1]) << 16) + | ((in[7 + inpos] - in[7 + inpos - 1]) << 24); + out[2 + outpos] = (in[8 + inpos] - in[8 + inpos - 1]) + | ((in[9 + inpos] - in[9 + inpos - 1]) << 8) + | ((in[10 + inpos] - in[10 + inpos - 1]) << 16) + | ((in[11 + inpos] - in[11 + inpos - 1]) << 24); + out[3 + outpos] = (in[12 + inpos] - in[12 + inpos - 1]) + | ((in[13 + inpos] - in[13 + inpos - 1]) << 8) + | ((in[14 + inpos] - in[14 + inpos - 1]) << 16) + | ((in[15 + inpos] - in[15 + inpos - 1]) << 24); + out[4 + outpos] = (in[16 + inpos] - in[16 + inpos - 1]) + | ((in[17 + inpos] - in[17 + inpos - 1]) << 8) + | ((in[18 + inpos] - in[18 + inpos - 1]) << 16) + | ((in[19 + inpos] - in[19 + inpos - 1]) << 24); + out[5 + outpos] = (in[20 + inpos] - in[20 + inpos - 1]) + | ((in[21 + inpos] - in[21 + inpos - 1]) << 8) + | ((in[22 + inpos] - in[22 + inpos - 1]) << 16) + | ((in[23 + inpos] - in[23 + inpos - 1]) << 24); + out[6 + outpos] = (in[24 + inpos] - in[24 + inpos - 1]) + | ((in[25 + inpos] - in[25 + inpos - 1]) << 8) + | ((in[26 + inpos] - in[26 + inpos - 1]) << 16) + | ((in[27 + inpos] - in[27 + inpos - 1]) << 24); + out[7 + outpos] = (in[28 + inpos] - in[28 + inpos - 1]) + | ((in[29 + inpos] - in[29 + inpos - 1]) << 8) + | ((in[30 + inpos] - in[30 + inpos - 1]) << 16) + | ((in[31 + inpos] - in[31 + inpos - 1]) << 24); + } + + protected static void integratedpack9(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + out[0 + outpos] = (in[0 + inpos] - initoffset) + | ((in[1 + inpos] - in[1 + inpos - 1]) << 9) + | ((in[2 + inpos] - in[2 + inpos - 1]) << 18) + | ((in[3 + inpos] - in[3 + inpos - 1]) << 27); + out[1 + outpos] = (in[3 + inpos] - in[3 + inpos - 1]) >>> (9 - 4) + | ((in[4 + inpos] - in[4 + inpos - 1]) << 4) + | ((in[5 + inpos] - in[5 + inpos - 1]) << 13) + | ((in[6 + inpos] - in[6 + inpos - 1]) << 22) + | ((in[7 + inpos] - in[7 + inpos - 1]) << 31); + out[2 + outpos] = (in[7 + inpos] - in[7 + inpos - 1]) >>> (9 - 8) + | ((in[8 + inpos] - in[8 + inpos - 1]) << 8) + | ((in[9 + inpos] - in[9 + inpos - 1]) << 17) + | ((in[10 + inpos] - in[10 + inpos - 1]) << 26); + out[3 + outpos] = (in[10 + inpos] - in[10 + inpos - 1]) >>> (9 - 3) + | ((in[11 + inpos] - in[11 + inpos - 1]) << 3) + | ((in[12 + inpos] - in[12 + inpos - 1]) << 12) + | ((in[13 + inpos] - in[13 + inpos - 1]) << 21) + | ((in[14 + inpos] - in[14 + inpos - 1]) << 30); + out[4 + outpos] = (in[14 + inpos] - in[14 + inpos - 1]) >>> (9 - 7) + | ((in[15 + inpos] - in[15 + inpos - 1]) << 7) + | ((in[16 + inpos] - in[16 + inpos - 1]) << 16) + | ((in[17 + inpos] - in[17 + inpos - 1]) << 25); + out[5 + outpos] = (in[17 + inpos] - in[17 + inpos - 1]) >>> (9 - 2) + | ((in[18 + inpos] - in[18 + inpos - 1]) << 2) + | ((in[19 + inpos] - in[19 + inpos - 1]) << 11) + | ((in[20 + inpos] - in[20 + inpos - 1]) << 20) + | ((in[21 + inpos] - in[21 + inpos - 1]) << 29); + out[6 + outpos] = (in[21 + inpos] - in[21 + inpos - 1]) >>> (9 - 6) + | ((in[22 + inpos] - in[22 + inpos - 1]) << 6) + | ((in[23 + inpos] - in[23 + inpos - 1]) << 15) + | ((in[24 + inpos] - in[24 + inpos - 1]) << 24); + out[7 + outpos] = (in[24 + inpos] - in[24 + inpos - 1]) >>> (9 - 1) + | ((in[25 + inpos] - in[25 + inpos - 1]) << 1) + | ((in[26 + inpos] - in[26 + inpos - 1]) << 10) + | ((in[27 + inpos] - in[27 + inpos - 1]) << 19) + | ((in[28 + inpos] - in[28 + inpos - 1]) << 28); + out[8 + outpos] = (in[28 + inpos] - in[28 + inpos - 1]) >>> (9 - 5) + | ((in[29 + inpos] - in[29 + inpos - 1]) << 5) + | ((in[30 + inpos] - in[30 + inpos - 1]) << 14) + | ((in[31 + inpos] - in[31 + inpos - 1]) << 23); + } + + /** + * Unpack 32 integers along with prefix sum computation + * + * @param initoffset value to add to all outputted values + * @param in source array + * @param inpos initial position in source array + * @param out output array + * @param outpos initial position in output array + * @param bit number of bits to use per integer + */ + public static void integratedunpack(final int initoffset, + final int[] in, final int inpos, final int[] out, final int outpos, + final int bit) { + switch (bit) { + case 0: + integratedunpack0(initoffset, in, inpos, out, outpos); + break; + case 1: + integratedunpack1(initoffset, in, inpos, out, outpos); + break; + case 2: + integratedunpack2(initoffset, in, inpos, out, outpos); + break; + case 3: + integratedunpack3(initoffset, in, inpos, out, outpos); + break; + case 4: + integratedunpack4(initoffset, in, inpos, out, outpos); + break; + case 5: + integratedunpack5(initoffset, in, inpos, out, outpos); + break; + case 6: + integratedunpack6(initoffset, in, inpos, out, outpos); + break; + case 7: + integratedunpack7(initoffset, in, inpos, out, outpos); + break; + case 8: + integratedunpack8(initoffset, in, inpos, out, outpos); + break; + case 9: + integratedunpack9(initoffset, in, inpos, out, outpos); + break; + case 10: + integratedunpack10(initoffset, in, inpos, out, outpos); + break; + case 11: + integratedunpack11(initoffset, in, inpos, out, outpos); + break; + case 12: + integratedunpack12(initoffset, in, inpos, out, outpos); + break; + case 13: + integratedunpack13(initoffset, in, inpos, out, outpos); + break; + case 14: + integratedunpack14(initoffset, in, inpos, out, outpos); + break; + case 15: + integratedunpack15(initoffset, in, inpos, out, outpos); + break; + case 16: + integratedunpack16(initoffset, in, inpos, out, outpos); + break; + case 17: + integratedunpack17(initoffset, in, inpos, out, outpos); + break; + case 18: + integratedunpack18(initoffset, in, inpos, out, outpos); + break; + case 19: + integratedunpack19(initoffset, in, inpos, out, outpos); + break; + case 20: + integratedunpack20(initoffset, in, inpos, out, outpos); + break; + case 21: + integratedunpack21(initoffset, in, inpos, out, outpos); + break; + case 22: + integratedunpack22(initoffset, in, inpos, out, outpos); + break; + case 23: + integratedunpack23(initoffset, in, inpos, out, outpos); + break; + case 24: + integratedunpack24(initoffset, in, inpos, out, outpos); + break; + case 25: + integratedunpack25(initoffset, in, inpos, out, outpos); + break; + case 26: + integratedunpack26(initoffset, in, inpos, out, outpos); + break; + case 27: + integratedunpack27(initoffset, in, inpos, out, outpos); + break; + case 28: + integratedunpack28(initoffset, in, inpos, out, outpos); + break; + case 29: + integratedunpack29(initoffset, in, inpos, out, outpos); + break; + case 30: + integratedunpack30(initoffset, in, inpos, out, outpos); + break; + case 31: + integratedunpack31(initoffset, in, inpos, out, outpos); + break; + case 32: + integratedunpack32(initoffset, in, inpos, out, outpos); + break; + default: + throw new IllegalArgumentException( + "Unsupported bit width."); + } + } + + protected static void integratedunpack0(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + Arrays.fill(out, outpos, outpos + 32, initoffset); + } + + protected static void integratedunpack1(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + out[0 + outpos] = (((in[0 + inpos] >>> 0) & 1)) + initoffset; + out[1 + outpos] = (((in[0 + inpos] >>> 1) & 1)) + + out[1 + outpos - 1]; + out[2 + outpos] = (((in[0 + inpos] >>> 2) & 1)) + + out[2 + outpos - 1]; + out[3 + outpos] = (((in[0 + inpos] >>> 3) & 1)) + + out[3 + outpos - 1]; + out[4 + outpos] = (((in[0 + inpos] >>> 4) & 1)) + + out[4 + outpos - 1]; + out[5 + outpos] = (((in[0 + inpos] >>> 5) & 1)) + + out[5 + outpos - 1]; + out[6 + outpos] = (((in[0 + inpos] >>> 6) & 1)) + + out[6 + outpos - 1]; + out[7 + outpos] = (((in[0 + inpos] >>> 7) & 1)) + + out[7 + outpos - 1]; + out[8 + outpos] = (((in[0 + inpos] >>> 8) & 1)) + + out[8 + outpos - 1]; + out[9 + outpos] = (((in[0 + inpos] >>> 9) & 1)) + + out[9 + outpos - 1]; + out[10 + outpos] = (((in[0 + inpos] >>> 10) & 1)) + + out[10 + outpos - 1]; + out[11 + outpos] = (((in[0 + inpos] >>> 11) & 1)) + + out[11 + outpos - 1]; + out[12 + outpos] = (((in[0 + inpos] >>> 12) & 1)) + + out[12 + outpos - 1]; + out[13 + outpos] = (((in[0 + inpos] >>> 13) & 1)) + + out[13 + outpos - 1]; + out[14 + outpos] = (((in[0 + inpos] >>> 14) & 1)) + + out[14 + outpos - 1]; + out[15 + outpos] = (((in[0 + inpos] >>> 15) & 1)) + + out[15 + outpos - 1]; + out[16 + outpos] = (((in[0 + inpos] >>> 16) & 1)) + + out[16 + outpos - 1]; + out[17 + outpos] = (((in[0 + inpos] >>> 17) & 1)) + + out[17 + outpos - 1]; + out[18 + outpos] = (((in[0 + inpos] >>> 18) & 1)) + + out[18 + outpos - 1]; + out[19 + outpos] = (((in[0 + inpos] >>> 19) & 1)) + + out[19 + outpos - 1]; + out[20 + outpos] = (((in[0 + inpos] >>> 20) & 1)) + + out[20 + outpos - 1]; + out[21 + outpos] = (((in[0 + inpos] >>> 21) & 1)) + + out[21 + outpos - 1]; + out[22 + outpos] = (((in[0 + inpos] >>> 22) & 1)) + + out[22 + outpos - 1]; + out[23 + outpos] = (((in[0 + inpos] >>> 23) & 1)) + + out[23 + outpos - 1]; + out[24 + outpos] = (((in[0 + inpos] >>> 24) & 1)) + + out[24 + outpos - 1]; + out[25 + outpos] = (((in[0 + inpos] >>> 25) & 1)) + + out[25 + outpos - 1]; + out[26 + outpos] = (((in[0 + inpos] >>> 26) & 1)) + + out[26 + outpos - 1]; + out[27 + outpos] = (((in[0 + inpos] >>> 27) & 1)) + + out[27 + outpos - 1]; + out[28 + outpos] = (((in[0 + inpos] >>> 28) & 1)) + + out[28 + outpos - 1]; + out[29 + outpos] = (((in[0 + inpos] >>> 29) & 1)) + + out[29 + outpos - 1]; + out[30 + outpos] = (((in[0 + inpos] >>> 30) & 1)) + + out[30 + outpos - 1]; + out[31 + outpos] = ((in[0 + inpos] >>> 31)) + + out[31 + outpos - 1]; + } + + protected static void integratedunpack10(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + out[0 + outpos] = (((in[0 + inpos] >>> 0) & 1023)) + initoffset; + out[1 + outpos] = (((in[0 + inpos] >>> 10) & 1023)) + + out[1 + outpos - 1]; + out[2 + outpos] = (((in[0 + inpos] >>> 20) & 1023)) + + out[2 + outpos - 1]; + out[3 + outpos] = ((in[0 + inpos] >>> 30) | ((in[1 + inpos] & 255) << (10 - 8))) + + out[3 + outpos - 1]; + out[4 + outpos] = (((in[1 + inpos] >>> 8) & 1023)) + + out[4 + outpos - 1]; + out[5 + outpos] = (((in[1 + inpos] >>> 18) & 1023)) + + out[5 + outpos - 1]; + out[6 + outpos] = ((in[1 + inpos] >>> 28) | ((in[2 + inpos] & 63) << (10 - 6))) + + out[6 + outpos - 1]; + out[7 + outpos] = (((in[2 + inpos] >>> 6) & 1023)) + + out[7 + outpos - 1]; + out[8 + outpos] = (((in[2 + inpos] >>> 16) & 1023)) + + out[8 + outpos - 1]; + out[9 + outpos] = ((in[2 + inpos] >>> 26) | ((in[3 + inpos] & 15) << (10 - 4))) + + out[9 + outpos - 1]; + out[10 + outpos] = (((in[3 + inpos] >>> 4) & 1023)) + + out[10 + outpos - 1]; + out[11 + outpos] = (((in[3 + inpos] >>> 14) & 1023)) + + out[11 + outpos - 1]; + out[12 + outpos] = ((in[3 + inpos] >>> 24) | ((in[4 + inpos] & 3) << (10 - 2))) + + out[12 + outpos - 1]; + out[13 + outpos] = (((in[4 + inpos] >>> 2) & 1023)) + + out[13 + outpos - 1]; + out[14 + outpos] = (((in[4 + inpos] >>> 12) & 1023)) + + out[14 + outpos - 1]; + out[15 + outpos] = ((in[4 + inpos] >>> 22)) + + out[15 + outpos - 1]; + out[16 + outpos] = (((in[5 + inpos] >>> 0) & 1023)) + + out[16 + outpos - 1]; + out[17 + outpos] = (((in[5 + inpos] >>> 10) & 1023)) + + out[17 + outpos - 1]; + out[18 + outpos] = (((in[5 + inpos] >>> 20) & 1023)) + + out[18 + outpos - 1]; + out[19 + outpos] = ((in[5 + inpos] >>> 30) | ((in[6 + inpos] & 255) << (10 - 8))) + + out[19 + outpos - 1]; + out[20 + outpos] = (((in[6 + inpos] >>> 8) & 1023)) + + out[20 + outpos - 1]; + out[21 + outpos] = (((in[6 + inpos] >>> 18) & 1023)) + + out[21 + outpos - 1]; + out[22 + outpos] = ((in[6 + inpos] >>> 28) | ((in[7 + inpos] & 63) << (10 - 6))) + + out[22 + outpos - 1]; + out[23 + outpos] = (((in[7 + inpos] >>> 6) & 1023)) + + out[23 + outpos - 1]; + out[24 + outpos] = (((in[7 + inpos] >>> 16) & 1023)) + + out[24 + outpos - 1]; + out[25 + outpos] = ((in[7 + inpos] >>> 26) | ((in[8 + inpos] & 15) << (10 - 4))) + + out[25 + outpos - 1]; + out[26 + outpos] = (((in[8 + inpos] >>> 4) & 1023)) + + out[26 + outpos - 1]; + out[27 + outpos] = (((in[8 + inpos] >>> 14) & 1023)) + + out[27 + outpos - 1]; + out[28 + outpos] = ((in[8 + inpos] >>> 24) | ((in[9 + inpos] & 3) << (10 - 2))) + + out[28 + outpos - 1]; + out[29 + outpos] = (((in[9 + inpos] >>> 2) & 1023)) + + out[29 + outpos - 1]; + out[30 + outpos] = (((in[9 + inpos] >>> 12) & 1023)) + + out[30 + outpos - 1]; + out[31 + outpos] = ((in[9 + inpos] >>> 22)) + + out[31 + outpos - 1]; + } + + protected static void integratedunpack11(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + out[0 + outpos] = (((in[0 + inpos] >>> 0) & 2047)) + initoffset; + out[1 + outpos] = (((in[0 + inpos] >>> 11) & 2047)) + + out[1 + outpos - 1]; + out[2 + outpos] = ((in[0 + inpos] >>> 22) | ((in[1 + inpos] & 1) << (11 - 1))) + + out[2 + outpos - 1]; + out[3 + outpos] = (((in[1 + inpos] >>> 1) & 2047)) + + out[3 + outpos - 1]; + out[4 + outpos] = (((in[1 + inpos] >>> 12) & 2047)) + + out[4 + outpos - 1]; + out[5 + outpos] = ((in[1 + inpos] >>> 23) | ((in[2 + inpos] & 3) << (11 - 2))) + + out[5 + outpos - 1]; + out[6 + outpos] = (((in[2 + inpos] >>> 2) & 2047)) + + out[6 + outpos - 1]; + out[7 + outpos] = (((in[2 + inpos] >>> 13) & 2047)) + + out[7 + outpos - 1]; + out[8 + outpos] = ((in[2 + inpos] >>> 24) | ((in[3 + inpos] & 7) << (11 - 3))) + + out[8 + outpos - 1]; + out[9 + outpos] = (((in[3 + inpos] >>> 3) & 2047)) + + out[9 + outpos - 1]; + out[10 + outpos] = (((in[3 + inpos] >>> 14) & 2047)) + + out[10 + outpos - 1]; + out[11 + outpos] = ((in[3 + inpos] >>> 25) | ((in[4 + inpos] & 15) << (11 - 4))) + + out[11 + outpos - 1]; + out[12 + outpos] = (((in[4 + inpos] >>> 4) & 2047)) + + out[12 + outpos - 1]; + out[13 + outpos] = (((in[4 + inpos] >>> 15) & 2047)) + + out[13 + outpos - 1]; + out[14 + outpos] = ((in[4 + inpos] >>> 26) | ((in[5 + inpos] & 31) << (11 - 5))) + + out[14 + outpos - 1]; + out[15 + outpos] = (((in[5 + inpos] >>> 5) & 2047)) + + out[15 + outpos - 1]; + out[16 + outpos] = (((in[5 + inpos] >>> 16) & 2047)) + + out[16 + outpos - 1]; + out[17 + outpos] = ((in[5 + inpos] >>> 27) | ((in[6 + inpos] & 63) << (11 - 6))) + + out[17 + outpos - 1]; + out[18 + outpos] = (((in[6 + inpos] >>> 6) & 2047)) + + out[18 + outpos - 1]; + out[19 + outpos] = (((in[6 + inpos] >>> 17) & 2047)) + + out[19 + outpos - 1]; + out[20 + outpos] = ((in[6 + inpos] >>> 28) | ((in[7 + inpos] & 127) << (11 - 7))) + + out[20 + outpos - 1]; + out[21 + outpos] = (((in[7 + inpos] >>> 7) & 2047)) + + out[21 + outpos - 1]; + out[22 + outpos] = (((in[7 + inpos] >>> 18) & 2047)) + + out[22 + outpos - 1]; + out[23 + outpos] = ((in[7 + inpos] >>> 29) | ((in[8 + inpos] & 255) << (11 - 8))) + + out[23 + outpos - 1]; + out[24 + outpos] = (((in[8 + inpos] >>> 8) & 2047)) + + out[24 + outpos - 1]; + out[25 + outpos] = (((in[8 + inpos] >>> 19) & 2047)) + + out[25 + outpos - 1]; + out[26 + outpos] = ((in[8 + inpos] >>> 30) | ((in[9 + inpos] & 511) << (11 - 9))) + + out[26 + outpos - 1]; + out[27 + outpos] = (((in[9 + inpos] >>> 9) & 2047)) + + out[27 + outpos - 1]; + out[28 + outpos] = (((in[9 + inpos] >>> 20) & 2047)) + + out[28 + outpos - 1]; + out[29 + outpos] = ((in[9 + inpos] >>> 31) | ((in[10 + inpos] & 1023) << (11 - 10))) + + out[29 + outpos - 1]; + out[30 + outpos] = (((in[10 + inpos] >>> 10) & 2047)) + + out[30 + outpos - 1]; + out[31 + outpos] = ((in[10 + inpos] >>> 21)) + + out[31 + outpos - 1]; + } + + protected static void integratedunpack12(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + out[0 + outpos] = (((in[0 + inpos] >>> 0) & 4095)) + initoffset; + out[1 + outpos] = (((in[0 + inpos] >>> 12) & 4095)) + + out[1 + outpos - 1]; + out[2 + outpos] = ((in[0 + inpos] >>> 24) | ((in[1 + inpos] & 15) << (12 - 4))) + + out[2 + outpos - 1]; + out[3 + outpos] = (((in[1 + inpos] >>> 4) & 4095)) + + out[3 + outpos - 1]; + out[4 + outpos] = (((in[1 + inpos] >>> 16) & 4095)) + + out[4 + outpos - 1]; + out[5 + outpos] = ((in[1 + inpos] >>> 28) | ((in[2 + inpos] & 255) << (12 - 8))) + + out[5 + outpos - 1]; + out[6 + outpos] = (((in[2 + inpos] >>> 8) & 4095)) + + out[6 + outpos - 1]; + out[7 + outpos] = ((in[2 + inpos] >>> 20)) + + out[7 + outpos - 1]; + out[8 + outpos] = (((in[3 + inpos] >>> 0) & 4095)) + + out[8 + outpos - 1]; + out[9 + outpos] = (((in[3 + inpos] >>> 12) & 4095)) + + out[9 + outpos - 1]; + out[10 + outpos] = ((in[3 + inpos] >>> 24) | ((in[4 + inpos] & 15) << (12 - 4))) + + out[10 + outpos - 1]; + out[11 + outpos] = (((in[4 + inpos] >>> 4) & 4095)) + + out[11 + outpos - 1]; + out[12 + outpos] = (((in[4 + inpos] >>> 16) & 4095)) + + out[12 + outpos - 1]; + out[13 + outpos] = ((in[4 + inpos] >>> 28) | ((in[5 + inpos] & 255) << (12 - 8))) + + out[13 + outpos - 1]; + out[14 + outpos] = (((in[5 + inpos] >>> 8) & 4095)) + + out[14 + outpos - 1]; + out[15 + outpos] = ((in[5 + inpos] >>> 20)) + + out[15 + outpos - 1]; + out[16 + outpos] = (((in[6 + inpos] >>> 0) & 4095)) + + out[16 + outpos - 1]; + out[17 + outpos] = (((in[6 + inpos] >>> 12) & 4095)) + + out[17 + outpos - 1]; + out[18 + outpos] = ((in[6 + inpos] >>> 24) | ((in[7 + inpos] & 15) << (12 - 4))) + + out[18 + outpos - 1]; + out[19 + outpos] = (((in[7 + inpos] >>> 4) & 4095)) + + out[19 + outpos - 1]; + out[20 + outpos] = (((in[7 + inpos] >>> 16) & 4095)) + + out[20 + outpos - 1]; + out[21 + outpos] = ((in[7 + inpos] >>> 28) | ((in[8 + inpos] & 255) << (12 - 8))) + + out[21 + outpos - 1]; + out[22 + outpos] = (((in[8 + inpos] >>> 8) & 4095)) + + out[22 + outpos - 1]; + out[23 + outpos] = ((in[8 + inpos] >>> 20)) + + out[23 + outpos - 1]; + out[24 + outpos] = (((in[9 + inpos] >>> 0) & 4095)) + + out[24 + outpos - 1]; + out[25 + outpos] = (((in[9 + inpos] >>> 12) & 4095)) + + out[25 + outpos - 1]; + out[26 + outpos] = ((in[9 + inpos] >>> 24) | ((in[10 + inpos] & 15) << (12 - 4))) + + out[26 + outpos - 1]; + out[27 + outpos] = (((in[10 + inpos] >>> 4) & 4095)) + + out[27 + outpos - 1]; + out[28 + outpos] = (((in[10 + inpos] >>> 16) & 4095)) + + out[28 + outpos - 1]; + out[29 + outpos] = ((in[10 + inpos] >>> 28) | ((in[11 + inpos] & 255) << (12 - 8))) + + out[29 + outpos - 1]; + out[30 + outpos] = (((in[11 + inpos] >>> 8) & 4095)) + + out[30 + outpos - 1]; + out[31 + outpos] = ((in[11 + inpos] >>> 20)) + + out[31 + outpos - 1]; + } + + protected static void integratedunpack13(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + out[0 + outpos] = (((in[0 + inpos] >>> 0) & 8191)) + initoffset; + out[1 + outpos] = (((in[0 + inpos] >>> 13) & 8191)) + + out[1 + outpos - 1]; + out[2 + outpos] = ((in[0 + inpos] >>> 26) | ((in[1 + inpos] & 127) << (13 - 7))) + + out[2 + outpos - 1]; + out[3 + outpos] = (((in[1 + inpos] >>> 7) & 8191)) + + out[3 + outpos - 1]; + out[4 + outpos] = ((in[1 + inpos] >>> 20) | ((in[2 + inpos] & 1) << (13 - 1))) + + out[4 + outpos - 1]; + out[5 + outpos] = (((in[2 + inpos] >>> 1) & 8191)) + + out[5 + outpos - 1]; + out[6 + outpos] = (((in[2 + inpos] >>> 14) & 8191)) + + out[6 + outpos - 1]; + out[7 + outpos] = ((in[2 + inpos] >>> 27) | ((in[3 + inpos] & 255) << (13 - 8))) + + out[7 + outpos - 1]; + out[8 + outpos] = (((in[3 + inpos] >>> 8) & 8191)) + + out[8 + outpos - 1]; + out[9 + outpos] = ((in[3 + inpos] >>> 21) | ((in[4 + inpos] & 3) << (13 - 2))) + + out[9 + outpos - 1]; + out[10 + outpos] = (((in[4 + inpos] >>> 2) & 8191)) + + out[10 + outpos - 1]; + out[11 + outpos] = (((in[4 + inpos] >>> 15) & 8191)) + + out[11 + outpos - 1]; + out[12 + outpos] = ((in[4 + inpos] >>> 28) | ((in[5 + inpos] & 511) << (13 - 9))) + + out[12 + outpos - 1]; + out[13 + outpos] = (((in[5 + inpos] >>> 9) & 8191)) + + out[13 + outpos - 1]; + out[14 + outpos] = ((in[5 + inpos] >>> 22) | ((in[6 + inpos] & 7) << (13 - 3))) + + out[14 + outpos - 1]; + out[15 + outpos] = (((in[6 + inpos] >>> 3) & 8191)) + + out[15 + outpos - 1]; + out[16 + outpos] = (((in[6 + inpos] >>> 16) & 8191)) + + out[16 + outpos - 1]; + out[17 + outpos] = ((in[6 + inpos] >>> 29) | ((in[7 + inpos] & 1023) << (13 - 10))) + + out[17 + outpos - 1]; + out[18 + outpos] = (((in[7 + inpos] >>> 10) & 8191)) + + out[18 + outpos - 1]; + out[19 + outpos] = ((in[7 + inpos] >>> 23) | ((in[8 + inpos] & 15) << (13 - 4))) + + out[19 + outpos - 1]; + out[20 + outpos] = (((in[8 + inpos] >>> 4) & 8191)) + + out[20 + outpos - 1]; + out[21 + outpos] = (((in[8 + inpos] >>> 17) & 8191)) + + out[21 + outpos - 1]; + out[22 + outpos] = ((in[8 + inpos] >>> 30) | ((in[9 + inpos] & 2047) << (13 - 11))) + + out[22 + outpos - 1]; + out[23 + outpos] = (((in[9 + inpos] >>> 11) & 8191)) + + out[23 + outpos - 1]; + out[24 + outpos] = ((in[9 + inpos] >>> 24) | ((in[10 + inpos] & 31) << (13 - 5))) + + out[24 + outpos - 1]; + out[25 + outpos] = (((in[10 + inpos] >>> 5) & 8191)) + + out[25 + outpos - 1]; + out[26 + outpos] = (((in[10 + inpos] >>> 18) & 8191)) + + out[26 + outpos - 1]; + out[27 + outpos] = ((in[10 + inpos] >>> 31) | ((in[11 + inpos] & 4095) << (13 - 12))) + + out[27 + outpos - 1]; + out[28 + outpos] = (((in[11 + inpos] >>> 12) & 8191)) + + out[28 + outpos - 1]; + out[29 + outpos] = ((in[11 + inpos] >>> 25) | ((in[12 + inpos] & 63) << (13 - 6))) + + out[29 + outpos - 1]; + out[30 + outpos] = (((in[12 + inpos] >>> 6) & 8191)) + + out[30 + outpos - 1]; + out[31 + outpos] = ((in[12 + inpos] >>> 19)) + + out[31 + outpos - 1]; + } + + protected static void integratedunpack14(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + out[0 + outpos] = (((in[0 + inpos] >>> 0) & 16383)) + + initoffset; + out[1 + outpos] = (((in[0 + inpos] >>> 14) & 16383)) + + out[1 + outpos - 1]; + out[2 + outpos] = ((in[0 + inpos] >>> 28) | ((in[1 + inpos] & 1023) << (14 - 10))) + + out[2 + outpos - 1]; + out[3 + outpos] = (((in[1 + inpos] >>> 10) & 16383)) + + out[3 + outpos - 1]; + out[4 + outpos] = ((in[1 + inpos] >>> 24) | ((in[2 + inpos] & 63) << (14 - 6))) + + out[4 + outpos - 1]; + out[5 + outpos] = (((in[2 + inpos] >>> 6) & 16383)) + + out[5 + outpos - 1]; + out[6 + outpos] = ((in[2 + inpos] >>> 20) | ((in[3 + inpos] & 3) << (14 - 2))) + + out[6 + outpos - 1]; + out[7 + outpos] = (((in[3 + inpos] >>> 2) & 16383)) + + out[7 + outpos - 1]; + out[8 + outpos] = (((in[3 + inpos] >>> 16) & 16383)) + + out[8 + outpos - 1]; + out[9 + outpos] = ((in[3 + inpos] >>> 30) | ((in[4 + inpos] & 4095) << (14 - 12))) + + out[9 + outpos - 1]; + out[10 + outpos] = (((in[4 + inpos] >>> 12) & 16383)) + + out[10 + outpos - 1]; + out[11 + outpos] = ((in[4 + inpos] >>> 26) | ((in[5 + inpos] & 255) << (14 - 8))) + + out[11 + outpos - 1]; + out[12 + outpos] = (((in[5 + inpos] >>> 8) & 16383)) + + out[12 + outpos - 1]; + out[13 + outpos] = ((in[5 + inpos] >>> 22) | ((in[6 + inpos] & 15) << (14 - 4))) + + out[13 + outpos - 1]; + out[14 + outpos] = (((in[6 + inpos] >>> 4) & 16383)) + + out[14 + outpos - 1]; + out[15 + outpos] = ((in[6 + inpos] >>> 18)) + + out[15 + outpos - 1]; + out[16 + outpos] = (((in[7 + inpos] >>> 0) & 16383)) + + out[16 + outpos - 1]; + out[17 + outpos] = (((in[7 + inpos] >>> 14) & 16383)) + + out[17 + outpos - 1]; + out[18 + outpos] = ((in[7 + inpos] >>> 28) | ((in[8 + inpos] & 1023) << (14 - 10))) + + out[18 + outpos - 1]; + out[19 + outpos] = (((in[8 + inpos] >>> 10) & 16383)) + + out[19 + outpos - 1]; + out[20 + outpos] = ((in[8 + inpos] >>> 24) | ((in[9 + inpos] & 63) << (14 - 6))) + + out[20 + outpos - 1]; + out[21 + outpos] = (((in[9 + inpos] >>> 6) & 16383)) + + out[21 + outpos - 1]; + out[22 + outpos] = ((in[9 + inpos] >>> 20) | ((in[10 + inpos] & 3) << (14 - 2))) + + out[22 + outpos - 1]; + out[23 + outpos] = (((in[10 + inpos] >>> 2) & 16383)) + + out[23 + outpos - 1]; + out[24 + outpos] = (((in[10 + inpos] >>> 16) & 16383)) + + out[24 + outpos - 1]; + out[25 + outpos] = ((in[10 + inpos] >>> 30) | ((in[11 + inpos] & 4095) << (14 - 12))) + + out[25 + outpos - 1]; + out[26 + outpos] = (((in[11 + inpos] >>> 12) & 16383)) + + out[26 + outpos - 1]; + out[27 + outpos] = ((in[11 + inpos] >>> 26) | ((in[12 + inpos] & 255) << (14 - 8))) + + out[27 + outpos - 1]; + out[28 + outpos] = (((in[12 + inpos] >>> 8) & 16383)) + + out[28 + outpos - 1]; + out[29 + outpos] = ((in[12 + inpos] >>> 22) | ((in[13 + inpos] & 15) << (14 - 4))) + + out[29 + outpos - 1]; + out[30 + outpos] = (((in[13 + inpos] >>> 4) & 16383)) + + out[30 + outpos - 1]; + out[31 + outpos] = ((in[13 + inpos] >>> 18)) + + out[31 + outpos - 1]; + } + + protected static void integratedunpack15(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + out[0 + outpos] = (((in[0 + inpos] >>> 0) & 32767)) + + initoffset; + out[1 + outpos] = (((in[0 + inpos] >>> 15) & 32767)) + + out[1 + outpos - 1]; + out[2 + outpos] = ((in[0 + inpos] >>> 30) | ((in[1 + inpos] & 8191) << (15 - 13))) + + out[2 + outpos - 1]; + out[3 + outpos] = (((in[1 + inpos] >>> 13) & 32767)) + + out[3 + outpos - 1]; + out[4 + outpos] = ((in[1 + inpos] >>> 28) | ((in[2 + inpos] & 2047) << (15 - 11))) + + out[4 + outpos - 1]; + out[5 + outpos] = (((in[2 + inpos] >>> 11) & 32767)) + + out[5 + outpos - 1]; + out[6 + outpos] = ((in[2 + inpos] >>> 26) | ((in[3 + inpos] & 511) << (15 - 9))) + + out[6 + outpos - 1]; + out[7 + outpos] = (((in[3 + inpos] >>> 9) & 32767)) + + out[7 + outpos - 1]; + out[8 + outpos] = ((in[3 + inpos] >>> 24) | ((in[4 + inpos] & 127) << (15 - 7))) + + out[8 + outpos - 1]; + out[9 + outpos] = (((in[4 + inpos] >>> 7) & 32767)) + + out[9 + outpos - 1]; + out[10 + outpos] = ((in[4 + inpos] >>> 22) | ((in[5 + inpos] & 31) << (15 - 5))) + + out[10 + outpos - 1]; + out[11 + outpos] = (((in[5 + inpos] >>> 5) & 32767)) + + out[11 + outpos - 1]; + out[12 + outpos] = ((in[5 + inpos] >>> 20) | ((in[6 + inpos] & 7) << (15 - 3))) + + out[12 + outpos - 1]; + out[13 + outpos] = (((in[6 + inpos] >>> 3) & 32767)) + + out[13 + outpos - 1]; + out[14 + outpos] = ((in[6 + inpos] >>> 18) | ((in[7 + inpos] & 1) << (15 - 1))) + + out[14 + outpos - 1]; + out[15 + outpos] = (((in[7 + inpos] >>> 1) & 32767)) + + out[15 + outpos - 1]; + out[16 + outpos] = (((in[7 + inpos] >>> 16) & 32767)) + + out[16 + outpos - 1]; + out[17 + outpos] = ((in[7 + inpos] >>> 31) | ((in[8 + inpos] & 16383) << (15 - 14))) + + out[17 + outpos - 1]; + out[18 + outpos] = (((in[8 + inpos] >>> 14) & 32767)) + + out[18 + outpos - 1]; + out[19 + outpos] = ((in[8 + inpos] >>> 29) | ((in[9 + inpos] & 4095) << (15 - 12))) + + out[19 + outpos - 1]; + out[20 + outpos] = (((in[9 + inpos] >>> 12) & 32767)) + + out[20 + outpos - 1]; + out[21 + outpos] = ((in[9 + inpos] >>> 27) | ((in[10 + inpos] & 1023) << (15 - 10))) + + out[21 + outpos - 1]; + out[22 + outpos] = (((in[10 + inpos] >>> 10) & 32767)) + + out[22 + outpos - 1]; + out[23 + outpos] = ((in[10 + inpos] >>> 25) | ((in[11 + inpos] & 255) << (15 - 8))) + + out[23 + outpos - 1]; + out[24 + outpos] = (((in[11 + inpos] >>> 8) & 32767)) + + out[24 + outpos - 1]; + out[25 + outpos] = ((in[11 + inpos] >>> 23) | ((in[12 + inpos] & 63) << (15 - 6))) + + out[25 + outpos - 1]; + out[26 + outpos] = (((in[12 + inpos] >>> 6) & 32767)) + + out[26 + outpos - 1]; + out[27 + outpos] = ((in[12 + inpos] >>> 21) | ((in[13 + inpos] & 15) << (15 - 4))) + + out[27 + outpos - 1]; + out[28 + outpos] = (((in[13 + inpos] >>> 4) & 32767)) + + out[28 + outpos - 1]; + out[29 + outpos] = ((in[13 + inpos] >>> 19) | ((in[14 + inpos] & 3) << (15 - 2))) + + out[29 + outpos - 1]; + out[30 + outpos] = (((in[14 + inpos] >>> 2) & 32767)) + + out[30 + outpos - 1]; + out[31 + outpos] = ((in[14 + inpos] >>> 17)) + + out[31 + outpos - 1]; + } + + protected static void integratedunpack16(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + out[0 + outpos] = (((in[0 + inpos] >>> 0) & 65535)) + + initoffset; + out[1 + outpos] = ((in[0 + inpos] >>> 16)) + + out[1 + outpos - 1]; + out[2 + outpos] = (((in[1 + inpos] >>> 0) & 65535)) + + out[2 + outpos - 1]; + out[3 + outpos] = ((in[1 + inpos] >>> 16)) + + out[3 + outpos - 1]; + out[4 + outpos] = (((in[2 + inpos] >>> 0) & 65535)) + + out[4 + outpos - 1]; + out[5 + outpos] = ((in[2 + inpos] >>> 16)) + + out[5 + outpos - 1]; + out[6 + outpos] = (((in[3 + inpos] >>> 0) & 65535)) + + out[6 + outpos - 1]; + out[7 + outpos] = ((in[3 + inpos] >>> 16)) + + out[7 + outpos - 1]; + out[8 + outpos] = (((in[4 + inpos] >>> 0) & 65535)) + + out[8 + outpos - 1]; + out[9 + outpos] = ((in[4 + inpos] >>> 16)) + + out[9 + outpos - 1]; + out[10 + outpos] = (((in[5 + inpos] >>> 0) & 65535)) + + out[10 + outpos - 1]; + out[11 + outpos] = ((in[5 + inpos] >>> 16)) + + out[11 + outpos - 1]; + out[12 + outpos] = (((in[6 + inpos] >>> 0) & 65535)) + + out[12 + outpos - 1]; + out[13 + outpos] = ((in[6 + inpos] >>> 16)) + + out[13 + outpos - 1]; + out[14 + outpos] = (((in[7 + inpos] >>> 0) & 65535)) + + out[14 + outpos - 1]; + out[15 + outpos] = ((in[7 + inpos] >>> 16)) + + out[15 + outpos - 1]; + out[16 + outpos] = (((in[8 + inpos] >>> 0) & 65535)) + + out[16 + outpos - 1]; + out[17 + outpos] = ((in[8 + inpos] >>> 16)) + + out[17 + outpos - 1]; + out[18 + outpos] = (((in[9 + inpos] >>> 0) & 65535)) + + out[18 + outpos - 1]; + out[19 + outpos] = ((in[9 + inpos] >>> 16)) + + out[19 + outpos - 1]; + out[20 + outpos] = (((in[10 + inpos] >>> 0) & 65535)) + + out[20 + outpos - 1]; + out[21 + outpos] = ((in[10 + inpos] >>> 16)) + + out[21 + outpos - 1]; + out[22 + outpos] = (((in[11 + inpos] >>> 0) & 65535)) + + out[22 + outpos - 1]; + out[23 + outpos] = ((in[11 + inpos] >>> 16)) + + out[23 + outpos - 1]; + out[24 + outpos] = (((in[12 + inpos] >>> 0) & 65535)) + + out[24 + outpos - 1]; + out[25 + outpos] = ((in[12 + inpos] >>> 16)) + + out[25 + outpos - 1]; + out[26 + outpos] = (((in[13 + inpos] >>> 0) & 65535)) + + out[26 + outpos - 1]; + out[27 + outpos] = ((in[13 + inpos] >>> 16)) + + out[27 + outpos - 1]; + out[28 + outpos] = (((in[14 + inpos] >>> 0) & 65535)) + + out[28 + outpos - 1]; + out[29 + outpos] = ((in[14 + inpos] >>> 16)) + + out[29 + outpos - 1]; + out[30 + outpos] = (((in[15 + inpos] >>> 0) & 65535)) + + out[30 + outpos - 1]; + out[31 + outpos] = ((in[15 + inpos] >>> 16)) + + out[31 + outpos - 1]; + } + + protected static void integratedunpack17(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + out[0 + outpos] = (((in[0 + inpos] >>> 0) & 131071)) + + initoffset; + out[1 + outpos] = ((in[0 + inpos] >>> 17) | ((in[1 + inpos] & 3) << (17 - 2))) + + out[1 + outpos - 1]; + out[2 + outpos] = (((in[1 + inpos] >>> 2) & 131071)) + + out[2 + outpos - 1]; + out[3 + outpos] = ((in[1 + inpos] >>> 19) | ((in[2 + inpos] & 15) << (17 - 4))) + + out[3 + outpos - 1]; + out[4 + outpos] = (((in[2 + inpos] >>> 4) & 131071)) + + out[4 + outpos - 1]; + out[5 + outpos] = ((in[2 + inpos] >>> 21) | ((in[3 + inpos] & 63) << (17 - 6))) + + out[5 + outpos - 1]; + out[6 + outpos] = (((in[3 + inpos] >>> 6) & 131071)) + + out[6 + outpos - 1]; + out[7 + outpos] = ((in[3 + inpos] >>> 23) | ((in[4 + inpos] & 255) << (17 - 8))) + + out[7 + outpos - 1]; + out[8 + outpos] = (((in[4 + inpos] >>> 8) & 131071)) + + out[8 + outpos - 1]; + out[9 + outpos] = ((in[4 + inpos] >>> 25) | ((in[5 + inpos] & 1023) << (17 - 10))) + + out[9 + outpos - 1]; + out[10 + outpos] = (((in[5 + inpos] >>> 10) & 131071)) + + out[10 + outpos - 1]; + out[11 + outpos] = ((in[5 + inpos] >>> 27) | ((in[6 + inpos] & 4095) << (17 - 12))) + + out[11 + outpos - 1]; + out[12 + outpos] = (((in[6 + inpos] >>> 12) & 131071)) + + out[12 + outpos - 1]; + out[13 + outpos] = ((in[6 + inpos] >>> 29) | ((in[7 + inpos] & 16383) << (17 - 14))) + + out[13 + outpos - 1]; + out[14 + outpos] = (((in[7 + inpos] >>> 14) & 131071)) + + out[14 + outpos - 1]; + out[15 + outpos] = ((in[7 + inpos] >>> 31) | ((in[8 + inpos] & 65535) << (17 - 16))) + + out[15 + outpos - 1]; + out[16 + outpos] = ((in[8 + inpos] >>> 16) | ((in[9 + inpos] & 1) << (17 - 1))) + + out[16 + outpos - 1]; + out[17 + outpos] = (((in[9 + inpos] >>> 1) & 131071)) + + out[17 + outpos - 1]; + out[18 + outpos] = ((in[9 + inpos] >>> 18) | ((in[10 + inpos] & 7) << (17 - 3))) + + out[18 + outpos - 1]; + out[19 + outpos] = (((in[10 + inpos] >>> 3) & 131071)) + + out[19 + outpos - 1]; + out[20 + outpos] = ((in[10 + inpos] >>> 20) | ((in[11 + inpos] & 31) << (17 - 5))) + + out[20 + outpos - 1]; + out[21 + outpos] = (((in[11 + inpos] >>> 5) & 131071)) + + out[21 + outpos - 1]; + out[22 + outpos] = ((in[11 + inpos] >>> 22) | ((in[12 + inpos] & 127) << (17 - 7))) + + out[22 + outpos - 1]; + out[23 + outpos] = (((in[12 + inpos] >>> 7) & 131071)) + + out[23 + outpos - 1]; + out[24 + outpos] = ((in[12 + inpos] >>> 24) | ((in[13 + inpos] & 511) << (17 - 9))) + + out[24 + outpos - 1]; + out[25 + outpos] = (((in[13 + inpos] >>> 9) & 131071)) + + out[25 + outpos - 1]; + out[26 + outpos] = ((in[13 + inpos] >>> 26) | ((in[14 + inpos] & 2047) << (17 - 11))) + + out[26 + outpos - 1]; + out[27 + outpos] = (((in[14 + inpos] >>> 11) & 131071)) + + out[27 + outpos - 1]; + out[28 + outpos] = ((in[14 + inpos] >>> 28) | ((in[15 + inpos] & 8191) << (17 - 13))) + + out[28 + outpos - 1]; + out[29 + outpos] = (((in[15 + inpos] >>> 13) & 131071)) + + out[29 + outpos - 1]; + out[30 + outpos] = ((in[15 + inpos] >>> 30) | ((in[16 + inpos] & 32767) << (17 - 15))) + + out[30 + outpos - 1]; + out[31 + outpos] = ((in[16 + inpos] >>> 15)) + + out[31 + outpos - 1]; + } + + protected static void integratedunpack18(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + out[0 + outpos] = (((in[0 + inpos] >>> 0) & 262143)) + + initoffset; + out[1 + outpos] = ((in[0 + inpos] >>> 18) | ((in[1 + inpos] & 15) << (18 - 4))) + + out[1 + outpos - 1]; + out[2 + outpos] = (((in[1 + inpos] >>> 4) & 262143)) + + out[2 + outpos - 1]; + out[3 + outpos] = ((in[1 + inpos] >>> 22) | ((in[2 + inpos] & 255) << (18 - 8))) + + out[3 + outpos - 1]; + out[4 + outpos] = (((in[2 + inpos] >>> 8) & 262143)) + + out[4 + outpos - 1]; + out[5 + outpos] = ((in[2 + inpos] >>> 26) | ((in[3 + inpos] & 4095) << (18 - 12))) + + out[5 + outpos - 1]; + out[6 + outpos] = (((in[3 + inpos] >>> 12) & 262143)) + + out[6 + outpos - 1]; + out[7 + outpos] = ((in[3 + inpos] >>> 30) | ((in[4 + inpos] & 65535) << (18 - 16))) + + out[7 + outpos - 1]; + out[8 + outpos] = ((in[4 + inpos] >>> 16) | ((in[5 + inpos] & 3) << (18 - 2))) + + out[8 + outpos - 1]; + out[9 + outpos] = (((in[5 + inpos] >>> 2) & 262143)) + + out[9 + outpos - 1]; + out[10 + outpos] = ((in[5 + inpos] >>> 20) | ((in[6 + inpos] & 63) << (18 - 6))) + + out[10 + outpos - 1]; + out[11 + outpos] = (((in[6 + inpos] >>> 6) & 262143)) + + out[11 + outpos - 1]; + out[12 + outpos] = ((in[6 + inpos] >>> 24) | ((in[7 + inpos] & 1023) << (18 - 10))) + + out[12 + outpos - 1]; + out[13 + outpos] = (((in[7 + inpos] >>> 10) & 262143)) + + out[13 + outpos - 1]; + out[14 + outpos] = ((in[7 + inpos] >>> 28) | ((in[8 + inpos] & 16383) << (18 - 14))) + + out[14 + outpos - 1]; + out[15 + outpos] = ((in[8 + inpos] >>> 14)) + + out[15 + outpos - 1]; + out[16 + outpos] = (((in[9 + inpos] >>> 0) & 262143)) + + out[16 + outpos - 1]; + out[17 + outpos] = ((in[9 + inpos] >>> 18) | ((in[10 + inpos] & 15) << (18 - 4))) + + out[17 + outpos - 1]; + out[18 + outpos] = (((in[10 + inpos] >>> 4) & 262143)) + + out[18 + outpos - 1]; + out[19 + outpos] = ((in[10 + inpos] >>> 22) | ((in[11 + inpos] & 255) << (18 - 8))) + + out[19 + outpos - 1]; + out[20 + outpos] = (((in[11 + inpos] >>> 8) & 262143)) + + out[20 + outpos - 1]; + out[21 + outpos] = ((in[11 + inpos] >>> 26) | ((in[12 + inpos] & 4095) << (18 - 12))) + + out[21 + outpos - 1]; + out[22 + outpos] = (((in[12 + inpos] >>> 12) & 262143)) + + out[22 + outpos - 1]; + out[23 + outpos] = ((in[12 + inpos] >>> 30) | ((in[13 + inpos] & 65535) << (18 - 16))) + + out[23 + outpos - 1]; + out[24 + outpos] = ((in[13 + inpos] >>> 16) | ((in[14 + inpos] & 3) << (18 - 2))) + + out[24 + outpos - 1]; + out[25 + outpos] = (((in[14 + inpos] >>> 2) & 262143)) + + out[25 + outpos - 1]; + out[26 + outpos] = ((in[14 + inpos] >>> 20) | ((in[15 + inpos] & 63) << (18 - 6))) + + out[26 + outpos - 1]; + out[27 + outpos] = (((in[15 + inpos] >>> 6) & 262143)) + + out[27 + outpos - 1]; + out[28 + outpos] = ((in[15 + inpos] >>> 24) | ((in[16 + inpos] & 1023) << (18 - 10))) + + out[28 + outpos - 1]; + out[29 + outpos] = (((in[16 + inpos] >>> 10) & 262143)) + + out[29 + outpos - 1]; + out[30 + outpos] = ((in[16 + inpos] >>> 28) | ((in[17 + inpos] & 16383) << (18 - 14))) + + out[30 + outpos - 1]; + out[31 + outpos] = ((in[17 + inpos] >>> 14)) + + out[31 + outpos - 1]; + } + + protected static void integratedunpack19(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + out[0 + outpos] = (((in[0 + inpos] >>> 0) & 524287)) + + initoffset; + out[1 + outpos] = ((in[0 + inpos] >>> 19) | ((in[1 + inpos] & 63) << (19 - 6))) + + out[1 + outpos - 1]; + out[2 + outpos] = (((in[1 + inpos] >>> 6) & 524287)) + + out[2 + outpos - 1]; + out[3 + outpos] = ((in[1 + inpos] >>> 25) | ((in[2 + inpos] & 4095) << (19 - 12))) + + out[3 + outpos - 1]; + out[4 + outpos] = (((in[2 + inpos] >>> 12) & 524287)) + + out[4 + outpos - 1]; + out[5 + outpos] = ((in[2 + inpos] >>> 31) | ((in[3 + inpos] & 262143) << (19 - 18))) + + out[5 + outpos - 1]; + out[6 + outpos] = ((in[3 + inpos] >>> 18) | ((in[4 + inpos] & 31) << (19 - 5))) + + out[6 + outpos - 1]; + out[7 + outpos] = (((in[4 + inpos] >>> 5) & 524287)) + + out[7 + outpos - 1]; + out[8 + outpos] = ((in[4 + inpos] >>> 24) | ((in[5 + inpos] & 2047) << (19 - 11))) + + out[8 + outpos - 1]; + out[9 + outpos] = (((in[5 + inpos] >>> 11) & 524287)) + + out[9 + outpos - 1]; + out[10 + outpos] = ((in[5 + inpos] >>> 30) | ((in[6 + inpos] & 131071) << (19 - 17))) + + out[10 + outpos - 1]; + out[11 + outpos] = ((in[6 + inpos] >>> 17) | ((in[7 + inpos] & 15) << (19 - 4))) + + out[11 + outpos - 1]; + out[12 + outpos] = (((in[7 + inpos] >>> 4) & 524287)) + + out[12 + outpos - 1]; + out[13 + outpos] = ((in[7 + inpos] >>> 23) | ((in[8 + inpos] & 1023) << (19 - 10))) + + out[13 + outpos - 1]; + out[14 + outpos] = (((in[8 + inpos] >>> 10) & 524287)) + + out[14 + outpos - 1]; + out[15 + outpos] = ((in[8 + inpos] >>> 29) | ((in[9 + inpos] & 65535) << (19 - 16))) + + out[15 + outpos - 1]; + out[16 + outpos] = ((in[9 + inpos] >>> 16) | ((in[10 + inpos] & 7) << (19 - 3))) + + out[16 + outpos - 1]; + out[17 + outpos] = (((in[10 + inpos] >>> 3) & 524287)) + + out[17 + outpos - 1]; + out[18 + outpos] = ((in[10 + inpos] >>> 22) | ((in[11 + inpos] & 511) << (19 - 9))) + + out[18 + outpos - 1]; + out[19 + outpos] = (((in[11 + inpos] >>> 9) & 524287)) + + out[19 + outpos - 1]; + out[20 + outpos] = ((in[11 + inpos] >>> 28) | ((in[12 + inpos] & 32767) << (19 - 15))) + + out[20 + outpos - 1]; + out[21 + outpos] = ((in[12 + inpos] >>> 15) | ((in[13 + inpos] & 3) << (19 - 2))) + + out[21 + outpos - 1]; + out[22 + outpos] = (((in[13 + inpos] >>> 2) & 524287)) + + out[22 + outpos - 1]; + out[23 + outpos] = ((in[13 + inpos] >>> 21) | ((in[14 + inpos] & 255) << (19 - 8))) + + out[23 + outpos - 1]; + out[24 + outpos] = (((in[14 + inpos] >>> 8) & 524287)) + + out[24 + outpos - 1]; + out[25 + outpos] = ((in[14 + inpos] >>> 27) | ((in[15 + inpos] & 16383) << (19 - 14))) + + out[25 + outpos - 1]; + out[26 + outpos] = ((in[15 + inpos] >>> 14) | ((in[16 + inpos] & 1) << (19 - 1))) + + out[26 + outpos - 1]; + out[27 + outpos] = (((in[16 + inpos] >>> 1) & 524287)) + + out[27 + outpos - 1]; + out[28 + outpos] = ((in[16 + inpos] >>> 20) | ((in[17 + inpos] & 127) << (19 - 7))) + + out[28 + outpos - 1]; + out[29 + outpos] = (((in[17 + inpos] >>> 7) & 524287)) + + out[29 + outpos - 1]; + out[30 + outpos] = ((in[17 + inpos] >>> 26) | ((in[18 + inpos] & 8191) << (19 - 13))) + + out[30 + outpos - 1]; + out[31 + outpos] = ((in[18 + inpos] >>> 13)) + + out[31 + outpos - 1]; + } + + protected static void integratedunpack2(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + out[0 + outpos] = (((in[0 + inpos] >>> 0) & 3)) + initoffset; + out[1 + outpos] = (((in[0 + inpos] >>> 2) & 3)) + + out[1 + outpos - 1]; + out[2 + outpos] = (((in[0 + inpos] >>> 4) & 3)) + + out[2 + outpos - 1]; + out[3 + outpos] = (((in[0 + inpos] >>> 6) & 3)) + + out[3 + outpos - 1]; + out[4 + outpos] = (((in[0 + inpos] >>> 8) & 3)) + + out[4 + outpos - 1]; + out[5 + outpos] = (((in[0 + inpos] >>> 10) & 3)) + + out[5 + outpos - 1]; + out[6 + outpos] = (((in[0 + inpos] >>> 12) & 3)) + + out[6 + outpos - 1]; + out[7 + outpos] = (((in[0 + inpos] >>> 14) & 3)) + + out[7 + outpos - 1]; + out[8 + outpos] = (((in[0 + inpos] >>> 16) & 3)) + + out[8 + outpos - 1]; + out[9 + outpos] = (((in[0 + inpos] >>> 18) & 3)) + + out[9 + outpos - 1]; + out[10 + outpos] = (((in[0 + inpos] >>> 20) & 3)) + + out[10 + outpos - 1]; + out[11 + outpos] = (((in[0 + inpos] >>> 22) & 3)) + + out[11 + outpos - 1]; + out[12 + outpos] = (((in[0 + inpos] >>> 24) & 3)) + + out[12 + outpos - 1]; + out[13 + outpos] = (((in[0 + inpos] >>> 26) & 3)) + + out[13 + outpos - 1]; + out[14 + outpos] = (((in[0 + inpos] >>> 28) & 3)) + + out[14 + outpos - 1]; + out[15 + outpos] = ((in[0 + inpos] >>> 30)) + + out[15 + outpos - 1]; + out[16 + outpos] = (((in[1 + inpos] >>> 0) & 3)) + + out[16 + outpos - 1]; + out[17 + outpos] = (((in[1 + inpos] >>> 2) & 3)) + + out[17 + outpos - 1]; + out[18 + outpos] = (((in[1 + inpos] >>> 4) & 3)) + + out[18 + outpos - 1]; + out[19 + outpos] = (((in[1 + inpos] >>> 6) & 3)) + + out[19 + outpos - 1]; + out[20 + outpos] = (((in[1 + inpos] >>> 8) & 3)) + + out[20 + outpos - 1]; + out[21 + outpos] = (((in[1 + inpos] >>> 10) & 3)) + + out[21 + outpos - 1]; + out[22 + outpos] = (((in[1 + inpos] >>> 12) & 3)) + + out[22 + outpos - 1]; + out[23 + outpos] = (((in[1 + inpos] >>> 14) & 3)) + + out[23 + outpos - 1]; + out[24 + outpos] = (((in[1 + inpos] >>> 16) & 3)) + + out[24 + outpos - 1]; + out[25 + outpos] = (((in[1 + inpos] >>> 18) & 3)) + + out[25 + outpos - 1]; + out[26 + outpos] = (((in[1 + inpos] >>> 20) & 3)) + + out[26 + outpos - 1]; + out[27 + outpos] = (((in[1 + inpos] >>> 22) & 3)) + + out[27 + outpos - 1]; + out[28 + outpos] = (((in[1 + inpos] >>> 24) & 3)) + + out[28 + outpos - 1]; + out[29 + outpos] = (((in[1 + inpos] >>> 26) & 3)) + + out[29 + outpos - 1]; + out[30 + outpos] = (((in[1 + inpos] >>> 28) & 3)) + + out[30 + outpos - 1]; + out[31 + outpos] = ((in[1 + inpos] >>> 30)) + + out[31 + outpos - 1]; + } + + protected static void integratedunpack20(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + out[0 + outpos] = (((in[0 + inpos] >>> 0) & 1048575)) + + initoffset; + out[1 + outpos] = ((in[0 + inpos] >>> 20) | ((in[1 + inpos] & 255) << (20 - 8))) + + out[1 + outpos - 1]; + out[2 + outpos] = (((in[1 + inpos] >>> 8) & 1048575)) + + out[2 + outpos - 1]; + out[3 + outpos] = ((in[1 + inpos] >>> 28) | ((in[2 + inpos] & 65535) << (20 - 16))) + + out[3 + outpos - 1]; + out[4 + outpos] = ((in[2 + inpos] >>> 16) | ((in[3 + inpos] & 15) << (20 - 4))) + + out[4 + outpos - 1]; + out[5 + outpos] = (((in[3 + inpos] >>> 4) & 1048575)) + + out[5 + outpos - 1]; + out[6 + outpos] = ((in[3 + inpos] >>> 24) | ((in[4 + inpos] & 4095) << (20 - 12))) + + out[6 + outpos - 1]; + out[7 + outpos] = ((in[4 + inpos] >>> 12)) + + out[7 + outpos - 1]; + out[8 + outpos] = (((in[5 + inpos] >>> 0) & 1048575)) + + out[8 + outpos - 1]; + out[9 + outpos] = ((in[5 + inpos] >>> 20) | ((in[6 + inpos] & 255) << (20 - 8))) + + out[9 + outpos - 1]; + out[10 + outpos] = (((in[6 + inpos] >>> 8) & 1048575)) + + out[10 + outpos - 1]; + out[11 + outpos] = ((in[6 + inpos] >>> 28) | ((in[7 + inpos] & 65535) << (20 - 16))) + + out[11 + outpos - 1]; + out[12 + outpos] = ((in[7 + inpos] >>> 16) | ((in[8 + inpos] & 15) << (20 - 4))) + + out[12 + outpos - 1]; + out[13 + outpos] = (((in[8 + inpos] >>> 4) & 1048575)) + + out[13 + outpos - 1]; + out[14 + outpos] = ((in[8 + inpos] >>> 24) | ((in[9 + inpos] & 4095) << (20 - 12))) + + out[14 + outpos - 1]; + out[15 + outpos] = ((in[9 + inpos] >>> 12)) + + out[15 + outpos - 1]; + out[16 + outpos] = (((in[10 + inpos] >>> 0) & 1048575)) + + out[16 + outpos - 1]; + out[17 + outpos] = ((in[10 + inpos] >>> 20) | ((in[11 + inpos] & 255) << (20 - 8))) + + out[17 + outpos - 1]; + out[18 + outpos] = (((in[11 + inpos] >>> 8) & 1048575)) + + out[18 + outpos - 1]; + out[19 + outpos] = ((in[11 + inpos] >>> 28) | ((in[12 + inpos] & 65535) << (20 - 16))) + + out[19 + outpos - 1]; + out[20 + outpos] = ((in[12 + inpos] >>> 16) | ((in[13 + inpos] & 15) << (20 - 4))) + + out[20 + outpos - 1]; + out[21 + outpos] = (((in[13 + inpos] >>> 4) & 1048575)) + + out[21 + outpos - 1]; + out[22 + outpos] = ((in[13 + inpos] >>> 24) | ((in[14 + inpos] & 4095) << (20 - 12))) + + out[22 + outpos - 1]; + out[23 + outpos] = ((in[14 + inpos] >>> 12)) + + out[23 + outpos - 1]; + out[24 + outpos] = (((in[15 + inpos] >>> 0) & 1048575)) + + out[24 + outpos - 1]; + out[25 + outpos] = ((in[15 + inpos] >>> 20) | ((in[16 + inpos] & 255) << (20 - 8))) + + out[25 + outpos - 1]; + out[26 + outpos] = (((in[16 + inpos] >>> 8) & 1048575)) + + out[26 + outpos - 1]; + out[27 + outpos] = ((in[16 + inpos] >>> 28) | ((in[17 + inpos] & 65535) << (20 - 16))) + + out[27 + outpos - 1]; + out[28 + outpos] = ((in[17 + inpos] >>> 16) | ((in[18 + inpos] & 15) << (20 - 4))) + + out[28 + outpos - 1]; + out[29 + outpos] = (((in[18 + inpos] >>> 4) & 1048575)) + + out[29 + outpos - 1]; + out[30 + outpos] = ((in[18 + inpos] >>> 24) | ((in[19 + inpos] & 4095) << (20 - 12))) + + out[30 + outpos - 1]; + out[31 + outpos] = ((in[19 + inpos] >>> 12)) + + out[31 + outpos - 1]; + } + + protected static void integratedunpack21(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + out[0 + outpos] = (((in[0 + inpos] >>> 0) & 2097151)) + + initoffset; + out[1 + outpos] = ((in[0 + inpos] >>> 21) | ((in[1 + inpos] & 1023) << (21 - 10))) + + out[1 + outpos - 1]; + out[2 + outpos] = (((in[1 + inpos] >>> 10) & 2097151)) + + out[2 + outpos - 1]; + out[3 + outpos] = ((in[1 + inpos] >>> 31) | ((in[2 + inpos] & 1048575) << (21 - 20))) + + out[3 + outpos - 1]; + out[4 + outpos] = ((in[2 + inpos] >>> 20) | ((in[3 + inpos] & 511) << (21 - 9))) + + out[4 + outpos - 1]; + out[5 + outpos] = (((in[3 + inpos] >>> 9) & 2097151)) + + out[5 + outpos - 1]; + out[6 + outpos] = ((in[3 + inpos] >>> 30) | ((in[4 + inpos] & 524287) << (21 - 19))) + + out[6 + outpos - 1]; + out[7 + outpos] = ((in[4 + inpos] >>> 19) | ((in[5 + inpos] & 255) << (21 - 8))) + + out[7 + outpos - 1]; + out[8 + outpos] = (((in[5 + inpos] >>> 8) & 2097151)) + + out[8 + outpos - 1]; + out[9 + outpos] = ((in[5 + inpos] >>> 29) | ((in[6 + inpos] & 262143) << (21 - 18))) + + out[9 + outpos - 1]; + out[10 + outpos] = ((in[6 + inpos] >>> 18) | ((in[7 + inpos] & 127) << (21 - 7))) + + out[10 + outpos - 1]; + out[11 + outpos] = (((in[7 + inpos] >>> 7) & 2097151)) + + out[11 + outpos - 1]; + out[12 + outpos] = ((in[7 + inpos] >>> 28) | ((in[8 + inpos] & 131071) << (21 - 17))) + + out[12 + outpos - 1]; + out[13 + outpos] = ((in[8 + inpos] >>> 17) | ((in[9 + inpos] & 63) << (21 - 6))) + + out[13 + outpos - 1]; + out[14 + outpos] = (((in[9 + inpos] >>> 6) & 2097151)) + + out[14 + outpos - 1]; + out[15 + outpos] = ((in[9 + inpos] >>> 27) | ((in[10 + inpos] & 65535) << (21 - 16))) + + out[15 + outpos - 1]; + out[16 + outpos] = ((in[10 + inpos] >>> 16) | ((in[11 + inpos] & 31) << (21 - 5))) + + out[16 + outpos - 1]; + out[17 + outpos] = (((in[11 + inpos] >>> 5) & 2097151)) + + out[17 + outpos - 1]; + out[18 + outpos] = ((in[11 + inpos] >>> 26) | ((in[12 + inpos] & 32767) << (21 - 15))) + + out[18 + outpos - 1]; + out[19 + outpos] = ((in[12 + inpos] >>> 15) | ((in[13 + inpos] & 15) << (21 - 4))) + + out[19 + outpos - 1]; + out[20 + outpos] = (((in[13 + inpos] >>> 4) & 2097151)) + + out[20 + outpos - 1]; + out[21 + outpos] = ((in[13 + inpos] >>> 25) | ((in[14 + inpos] & 16383) << (21 - 14))) + + out[21 + outpos - 1]; + out[22 + outpos] = ((in[14 + inpos] >>> 14) | ((in[15 + inpos] & 7) << (21 - 3))) + + out[22 + outpos - 1]; + out[23 + outpos] = (((in[15 + inpos] >>> 3) & 2097151)) + + out[23 + outpos - 1]; + out[24 + outpos] = ((in[15 + inpos] >>> 24) | ((in[16 + inpos] & 8191) << (21 - 13))) + + out[24 + outpos - 1]; + out[25 + outpos] = ((in[16 + inpos] >>> 13) | ((in[17 + inpos] & 3) << (21 - 2))) + + out[25 + outpos - 1]; + out[26 + outpos] = (((in[17 + inpos] >>> 2) & 2097151)) + + out[26 + outpos - 1]; + out[27 + outpos] = ((in[17 + inpos] >>> 23) | ((in[18 + inpos] & 4095) << (21 - 12))) + + out[27 + outpos - 1]; + out[28 + outpos] = ((in[18 + inpos] >>> 12) | ((in[19 + inpos] & 1) << (21 - 1))) + + out[28 + outpos - 1]; + out[29 + outpos] = (((in[19 + inpos] >>> 1) & 2097151)) + + out[29 + outpos - 1]; + out[30 + outpos] = ((in[19 + inpos] >>> 22) | ((in[20 + inpos] & 2047) << (21 - 11))) + + out[30 + outpos - 1]; + out[31 + outpos] = ((in[20 + inpos] >>> 11)) + + out[31 + outpos - 1]; + } + + protected static void integratedunpack22(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + out[0 + outpos] = (((in[0 + inpos] >>> 0) & 4194303)) + + initoffset; + out[1 + outpos] = ((in[0 + inpos] >>> 22) | ((in[1 + inpos] & 4095) << (22 - 12))) + + out[1 + outpos - 1]; + out[2 + outpos] = ((in[1 + inpos] >>> 12) | ((in[2 + inpos] & 3) << (22 - 2))) + + out[2 + outpos - 1]; + out[3 + outpos] = (((in[2 + inpos] >>> 2) & 4194303)) + + out[3 + outpos - 1]; + out[4 + outpos] = ((in[2 + inpos] >>> 24) | ((in[3 + inpos] & 16383) << (22 - 14))) + + out[4 + outpos - 1]; + out[5 + outpos] = ((in[3 + inpos] >>> 14) | ((in[4 + inpos] & 15) << (22 - 4))) + + out[5 + outpos - 1]; + out[6 + outpos] = (((in[4 + inpos] >>> 4) & 4194303)) + + out[6 + outpos - 1]; + out[7 + outpos] = ((in[4 + inpos] >>> 26) | ((in[5 + inpos] & 65535) << (22 - 16))) + + out[7 + outpos - 1]; + out[8 + outpos] = ((in[5 + inpos] >>> 16) | ((in[6 + inpos] & 63) << (22 - 6))) + + out[8 + outpos - 1]; + out[9 + outpos] = (((in[6 + inpos] >>> 6) & 4194303)) + + out[9 + outpos - 1]; + out[10 + outpos] = ((in[6 + inpos] >>> 28) | ((in[7 + inpos] & 262143) << (22 - 18))) + + out[10 + outpos - 1]; + out[11 + outpos] = ((in[7 + inpos] >>> 18) | ((in[8 + inpos] & 255) << (22 - 8))) + + out[11 + outpos - 1]; + out[12 + outpos] = (((in[8 + inpos] >>> 8) & 4194303)) + + out[12 + outpos - 1]; + out[13 + outpos] = ((in[8 + inpos] >>> 30) | ((in[9 + inpos] & 1048575) << (22 - 20))) + + out[13 + outpos - 1]; + out[14 + outpos] = ((in[9 + inpos] >>> 20) | ((in[10 + inpos] & 1023) << (22 - 10))) + + out[14 + outpos - 1]; + out[15 + outpos] = ((in[10 + inpos] >>> 10)) + + out[15 + outpos - 1]; + out[16 + outpos] = (((in[11 + inpos] >>> 0) & 4194303)) + + out[16 + outpos - 1]; + out[17 + outpos] = ((in[11 + inpos] >>> 22) | ((in[12 + inpos] & 4095) << (22 - 12))) + + out[17 + outpos - 1]; + out[18 + outpos] = ((in[12 + inpos] >>> 12) | ((in[13 + inpos] & 3) << (22 - 2))) + + out[18 + outpos - 1]; + out[19 + outpos] = (((in[13 + inpos] >>> 2) & 4194303)) + + out[19 + outpos - 1]; + out[20 + outpos] = ((in[13 + inpos] >>> 24) | ((in[14 + inpos] & 16383) << (22 - 14))) + + out[20 + outpos - 1]; + out[21 + outpos] = ((in[14 + inpos] >>> 14) | ((in[15 + inpos] & 15) << (22 - 4))) + + out[21 + outpos - 1]; + out[22 + outpos] = (((in[15 + inpos] >>> 4) & 4194303)) + + out[22 + outpos - 1]; + out[23 + outpos] = ((in[15 + inpos] >>> 26) | ((in[16 + inpos] & 65535) << (22 - 16))) + + out[23 + outpos - 1]; + out[24 + outpos] = ((in[16 + inpos] >>> 16) | ((in[17 + inpos] & 63) << (22 - 6))) + + out[24 + outpos - 1]; + out[25 + outpos] = (((in[17 + inpos] >>> 6) & 4194303)) + + out[25 + outpos - 1]; + out[26 + outpos] = ((in[17 + inpos] >>> 28) | ((in[18 + inpos] & 262143) << (22 - 18))) + + out[26 + outpos - 1]; + out[27 + outpos] = ((in[18 + inpos] >>> 18) | ((in[19 + inpos] & 255) << (22 - 8))) + + out[27 + outpos - 1]; + out[28 + outpos] = (((in[19 + inpos] >>> 8) & 4194303)) + + out[28 + outpos - 1]; + out[29 + outpos] = ((in[19 + inpos] >>> 30) | ((in[20 + inpos] & 1048575) << (22 - 20))) + + out[29 + outpos - 1]; + out[30 + outpos] = ((in[20 + inpos] >>> 20) | ((in[21 + inpos] & 1023) << (22 - 10))) + + out[30 + outpos - 1]; + out[31 + outpos] = ((in[21 + inpos] >>> 10)) + + out[31 + outpos - 1]; + } + + protected static void integratedunpack23(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + out[0 + outpos] = (((in[0 + inpos] >>> 0) & 8388607)) + + initoffset; + out[1 + outpos] = ((in[0 + inpos] >>> 23) | ((in[1 + inpos] & 16383) << (23 - 14))) + + out[1 + outpos - 1]; + out[2 + outpos] = ((in[1 + inpos] >>> 14) | ((in[2 + inpos] & 31) << (23 - 5))) + + out[2 + outpos - 1]; + out[3 + outpos] = (((in[2 + inpos] >>> 5) & 8388607)) + + out[3 + outpos - 1]; + out[4 + outpos] = ((in[2 + inpos] >>> 28) | ((in[3 + inpos] & 524287) << (23 - 19))) + + out[4 + outpos - 1]; + out[5 + outpos] = ((in[3 + inpos] >>> 19) | ((in[4 + inpos] & 1023) << (23 - 10))) + + out[5 + outpos - 1]; + out[6 + outpos] = ((in[4 + inpos] >>> 10) | ((in[5 + inpos] & 1) << (23 - 1))) + + out[6 + outpos - 1]; + out[7 + outpos] = (((in[5 + inpos] >>> 1) & 8388607)) + + out[7 + outpos - 1]; + out[8 + outpos] = ((in[5 + inpos] >>> 24) | ((in[6 + inpos] & 32767) << (23 - 15))) + + out[8 + outpos - 1]; + out[9 + outpos] = ((in[6 + inpos] >>> 15) | ((in[7 + inpos] & 63) << (23 - 6))) + + out[9 + outpos - 1]; + out[10 + outpos] = (((in[7 + inpos] >>> 6) & 8388607)) + + out[10 + outpos - 1]; + out[11 + outpos] = ((in[7 + inpos] >>> 29) | ((in[8 + inpos] & 1048575) << (23 - 20))) + + out[11 + outpos - 1]; + out[12 + outpos] = ((in[8 + inpos] >>> 20) | ((in[9 + inpos] & 2047) << (23 - 11))) + + out[12 + outpos - 1]; + out[13 + outpos] = ((in[9 + inpos] >>> 11) | ((in[10 + inpos] & 3) << (23 - 2))) + + out[13 + outpos - 1]; + out[14 + outpos] = (((in[10 + inpos] >>> 2) & 8388607)) + + out[14 + outpos - 1]; + out[15 + outpos] = ((in[10 + inpos] >>> 25) | ((in[11 + inpos] & 65535) << (23 - 16))) + + out[15 + outpos - 1]; + out[16 + outpos] = ((in[11 + inpos] >>> 16) | ((in[12 + inpos] & 127) << (23 - 7))) + + out[16 + outpos - 1]; + out[17 + outpos] = (((in[12 + inpos] >>> 7) & 8388607)) + + out[17 + outpos - 1]; + out[18 + outpos] = ((in[12 + inpos] >>> 30) | ((in[13 + inpos] & 2097151) << (23 - 21))) + + out[18 + outpos - 1]; + out[19 + outpos] = ((in[13 + inpos] >>> 21) | ((in[14 + inpos] & 4095) << (23 - 12))) + + out[19 + outpos - 1]; + out[20 + outpos] = ((in[14 + inpos] >>> 12) | ((in[15 + inpos] & 7) << (23 - 3))) + + out[20 + outpos - 1]; + out[21 + outpos] = (((in[15 + inpos] >>> 3) & 8388607)) + + out[21 + outpos - 1]; + out[22 + outpos] = ((in[15 + inpos] >>> 26) | ((in[16 + inpos] & 131071) << (23 - 17))) + + out[22 + outpos - 1]; + out[23 + outpos] = ((in[16 + inpos] >>> 17) | ((in[17 + inpos] & 255) << (23 - 8))) + + out[23 + outpos - 1]; + out[24 + outpos] = (((in[17 + inpos] >>> 8) & 8388607)) + + out[24 + outpos - 1]; + out[25 + outpos] = ((in[17 + inpos] >>> 31) | ((in[18 + inpos] & 4194303) << (23 - 22))) + + out[25 + outpos - 1]; + out[26 + outpos] = ((in[18 + inpos] >>> 22) | ((in[19 + inpos] & 8191) << (23 - 13))) + + out[26 + outpos - 1]; + out[27 + outpos] = ((in[19 + inpos] >>> 13) | ((in[20 + inpos] & 15) << (23 - 4))) + + out[27 + outpos - 1]; + out[28 + outpos] = (((in[20 + inpos] >>> 4) & 8388607)) + + out[28 + outpos - 1]; + out[29 + outpos] = ((in[20 + inpos] >>> 27) | ((in[21 + inpos] & 262143) << (23 - 18))) + + out[29 + outpos - 1]; + out[30 + outpos] = ((in[21 + inpos] >>> 18) | ((in[22 + inpos] & 511) << (23 - 9))) + + out[30 + outpos - 1]; + out[31 + outpos] = ((in[22 + inpos] >>> 9)) + + out[31 + outpos - 1]; + } + + protected static void integratedunpack24(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + out[0 + outpos] = (((in[0 + inpos] >>> 0) & 16777215)) + + initoffset; + out[1 + outpos] = ((in[0 + inpos] >>> 24) | ((in[1 + inpos] & 65535) << (24 - 16))) + + out[1 + outpos - 1]; + out[2 + outpos] = ((in[1 + inpos] >>> 16) | ((in[2 + inpos] & 255) << (24 - 8))) + + out[2 + outpos - 1]; + out[3 + outpos] = ((in[2 + inpos] >>> 8)) + out[3 + outpos - 1]; + out[4 + outpos] = (((in[3 + inpos] >>> 0) & 16777215)) + + out[4 + outpos - 1]; + out[5 + outpos] = ((in[3 + inpos] >>> 24) | ((in[4 + inpos] & 65535) << (24 - 16))) + + out[5 + outpos - 1]; + out[6 + outpos] = ((in[4 + inpos] >>> 16) | ((in[5 + inpos] & 255) << (24 - 8))) + + out[6 + outpos - 1]; + out[7 + outpos] = ((in[5 + inpos] >>> 8)) + out[7 + outpos - 1]; + out[8 + outpos] = (((in[6 + inpos] >>> 0) & 16777215)) + + out[8 + outpos - 1]; + out[9 + outpos] = ((in[6 + inpos] >>> 24) | ((in[7 + inpos] & 65535) << (24 - 16))) + + out[9 + outpos - 1]; + out[10 + outpos] = ((in[7 + inpos] >>> 16) | ((in[8 + inpos] & 255) << (24 - 8))) + + out[10 + outpos - 1]; + out[11 + outpos] = ((in[8 + inpos] >>> 8)) + + out[11 + outpos - 1]; + out[12 + outpos] = (((in[9 + inpos] >>> 0) & 16777215)) + + out[12 + outpos - 1]; + out[13 + outpos] = ((in[9 + inpos] >>> 24) | ((in[10 + inpos] & 65535) << (24 - 16))) + + out[13 + outpos - 1]; + out[14 + outpos] = ((in[10 + inpos] >>> 16) | ((in[11 + inpos] & 255) << (24 - 8))) + + out[14 + outpos - 1]; + out[15 + outpos] = ((in[11 + inpos] >>> 8)) + + out[15 + outpos - 1]; + out[16 + outpos] = (((in[12 + inpos] >>> 0) & 16777215)) + + out[16 + outpos - 1]; + out[17 + outpos] = ((in[12 + inpos] >>> 24) | ((in[13 + inpos] & 65535) << (24 - 16))) + + out[17 + outpos - 1]; + out[18 + outpos] = ((in[13 + inpos] >>> 16) | ((in[14 + inpos] & 255) << (24 - 8))) + + out[18 + outpos - 1]; + out[19 + outpos] = ((in[14 + inpos] >>> 8)) + + out[19 + outpos - 1]; + out[20 + outpos] = (((in[15 + inpos] >>> 0) & 16777215)) + + out[20 + outpos - 1]; + out[21 + outpos] = ((in[15 + inpos] >>> 24) | ((in[16 + inpos] & 65535) << (24 - 16))) + + out[21 + outpos - 1]; + out[22 + outpos] = ((in[16 + inpos] >>> 16) | ((in[17 + inpos] & 255) << (24 - 8))) + + out[22 + outpos - 1]; + out[23 + outpos] = ((in[17 + inpos] >>> 8)) + + out[23 + outpos - 1]; + out[24 + outpos] = (((in[18 + inpos] >>> 0) & 16777215)) + + out[24 + outpos - 1]; + out[25 + outpos] = ((in[18 + inpos] >>> 24) | ((in[19 + inpos] & 65535) << (24 - 16))) + + out[25 + outpos - 1]; + out[26 + outpos] = ((in[19 + inpos] >>> 16) | ((in[20 + inpos] & 255) << (24 - 8))) + + out[26 + outpos - 1]; + out[27 + outpos] = ((in[20 + inpos] >>> 8)) + + out[27 + outpos - 1]; + out[28 + outpos] = (((in[21 + inpos] >>> 0) & 16777215)) + + out[28 + outpos - 1]; + out[29 + outpos] = ((in[21 + inpos] >>> 24) | ((in[22 + inpos] & 65535) << (24 - 16))) + + out[29 + outpos - 1]; + out[30 + outpos] = ((in[22 + inpos] >>> 16) | ((in[23 + inpos] & 255) << (24 - 8))) + + out[30 + outpos - 1]; + out[31 + outpos] = ((in[23 + inpos] >>> 8)) + + out[31 + outpos - 1]; + } + + protected static void integratedunpack25(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + out[0 + outpos] = (((in[0 + inpos] >>> 0) & 33554431)) + + initoffset; + out[1 + outpos] = ((in[0 + inpos] >>> 25) | ((in[1 + inpos] & 262143) << (25 - 18))) + + out[1 + outpos - 1]; + out[2 + outpos] = ((in[1 + inpos] >>> 18) | ((in[2 + inpos] & 2047) << (25 - 11))) + + out[2 + outpos - 1]; + out[3 + outpos] = ((in[2 + inpos] >>> 11) | ((in[3 + inpos] & 15) << (25 - 4))) + + out[3 + outpos - 1]; + out[4 + outpos] = (((in[3 + inpos] >>> 4) & 33554431)) + + out[4 + outpos - 1]; + out[5 + outpos] = ((in[3 + inpos] >>> 29) | ((in[4 + inpos] & 4194303) << (25 - 22))) + + out[5 + outpos - 1]; + out[6 + outpos] = ((in[4 + inpos] >>> 22) | ((in[5 + inpos] & 32767) << (25 - 15))) + + out[6 + outpos - 1]; + out[7 + outpos] = ((in[5 + inpos] >>> 15) | ((in[6 + inpos] & 255) << (25 - 8))) + + out[7 + outpos - 1]; + out[8 + outpos] = ((in[6 + inpos] >>> 8) | ((in[7 + inpos] & 1) << (25 - 1))) + + out[8 + outpos - 1]; + out[9 + outpos] = (((in[7 + inpos] >>> 1) & 33554431)) + + out[9 + outpos - 1]; + out[10 + outpos] = ((in[7 + inpos] >>> 26) | ((in[8 + inpos] & 524287) << (25 - 19))) + + out[10 + outpos - 1]; + out[11 + outpos] = ((in[8 + inpos] >>> 19) | ((in[9 + inpos] & 4095) << (25 - 12))) + + out[11 + outpos - 1]; + out[12 + outpos] = ((in[9 + inpos] >>> 12) | ((in[10 + inpos] & 31) << (25 - 5))) + + out[12 + outpos - 1]; + out[13 + outpos] = (((in[10 + inpos] >>> 5) & 33554431)) + + out[13 + outpos - 1]; + out[14 + outpos] = ((in[10 + inpos] >>> 30) | ((in[11 + inpos] & 8388607) << (25 - 23))) + + out[14 + outpos - 1]; + out[15 + outpos] = ((in[11 + inpos] >>> 23) | ((in[12 + inpos] & 65535) << (25 - 16))) + + out[15 + outpos - 1]; + out[16 + outpos] = ((in[12 + inpos] >>> 16) | ((in[13 + inpos] & 511) << (25 - 9))) + + out[16 + outpos - 1]; + out[17 + outpos] = ((in[13 + inpos] >>> 9) | ((in[14 + inpos] & 3) << (25 - 2))) + + out[17 + outpos - 1]; + out[18 + outpos] = (((in[14 + inpos] >>> 2) & 33554431)) + + out[18 + outpos - 1]; + out[19 + outpos] = ((in[14 + inpos] >>> 27) | ((in[15 + inpos] & 1048575) << (25 - 20))) + + out[19 + outpos - 1]; + out[20 + outpos] = ((in[15 + inpos] >>> 20) | ((in[16 + inpos] & 8191) << (25 - 13))) + + out[20 + outpos - 1]; + out[21 + outpos] = ((in[16 + inpos] >>> 13) | ((in[17 + inpos] & 63) << (25 - 6))) + + out[21 + outpos - 1]; + out[22 + outpos] = (((in[17 + inpos] >>> 6) & 33554431)) + + out[22 + outpos - 1]; + out[23 + outpos] = ((in[17 + inpos] >>> 31) | ((in[18 + inpos] & 16777215) << (25 - 24))) + + out[23 + outpos - 1]; + out[24 + outpos] = ((in[18 + inpos] >>> 24) | ((in[19 + inpos] & 131071) << (25 - 17))) + + out[24 + outpos - 1]; + out[25 + outpos] = ((in[19 + inpos] >>> 17) | ((in[20 + inpos] & 1023) << (25 - 10))) + + out[25 + outpos - 1]; + out[26 + outpos] = ((in[20 + inpos] >>> 10) | ((in[21 + inpos] & 7) << (25 - 3))) + + out[26 + outpos - 1]; + out[27 + outpos] = (((in[21 + inpos] >>> 3) & 33554431)) + + out[27 + outpos - 1]; + out[28 + outpos] = ((in[21 + inpos] >>> 28) | ((in[22 + inpos] & 2097151) << (25 - 21))) + + out[28 + outpos - 1]; + out[29 + outpos] = ((in[22 + inpos] >>> 21) | ((in[23 + inpos] & 16383) << (25 - 14))) + + out[29 + outpos - 1]; + out[30 + outpos] = ((in[23 + inpos] >>> 14) | ((in[24 + inpos] & 127) << (25 - 7))) + + out[30 + outpos - 1]; + out[31 + outpos] = ((in[24 + inpos] >>> 7)) + + out[31 + outpos - 1]; + } + + protected static void integratedunpack26(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + out[0 + outpos] = (((in[0 + inpos] >>> 0) & 67108863)) + + initoffset; + out[1 + outpos] = ((in[0 + inpos] >>> 26) | ((in[1 + inpos] & 1048575) << (26 - 20))) + + out[1 + outpos - 1]; + out[2 + outpos] = ((in[1 + inpos] >>> 20) | ((in[2 + inpos] & 16383) << (26 - 14))) + + out[2 + outpos - 1]; + out[3 + outpos] = ((in[2 + inpos] >>> 14) | ((in[3 + inpos] & 255) << (26 - 8))) + + out[3 + outpos - 1]; + out[4 + outpos] = ((in[3 + inpos] >>> 8) | ((in[4 + inpos] & 3) << (26 - 2))) + + out[4 + outpos - 1]; + out[5 + outpos] = (((in[4 + inpos] >>> 2) & 67108863)) + + out[5 + outpos - 1]; + out[6 + outpos] = ((in[4 + inpos] >>> 28) | ((in[5 + inpos] & 4194303) << (26 - 22))) + + out[6 + outpos - 1]; + out[7 + outpos] = ((in[5 + inpos] >>> 22) | ((in[6 + inpos] & 65535) << (26 - 16))) + + out[7 + outpos - 1]; + out[8 + outpos] = ((in[6 + inpos] >>> 16) | ((in[7 + inpos] & 1023) << (26 - 10))) + + out[8 + outpos - 1]; + out[9 + outpos] = ((in[7 + inpos] >>> 10) | ((in[8 + inpos] & 15) << (26 - 4))) + + out[9 + outpos - 1]; + out[10 + outpos] = (((in[8 + inpos] >>> 4) & 67108863)) + + out[10 + outpos - 1]; + out[11 + outpos] = ((in[8 + inpos] >>> 30) | ((in[9 + inpos] & 16777215) << (26 - 24))) + + out[11 + outpos - 1]; + out[12 + outpos] = ((in[9 + inpos] >>> 24) | ((in[10 + inpos] & 262143) << (26 - 18))) + + out[12 + outpos - 1]; + out[13 + outpos] = ((in[10 + inpos] >>> 18) | ((in[11 + inpos] & 4095) << (26 - 12))) + + out[13 + outpos - 1]; + out[14 + outpos] = ((in[11 + inpos] >>> 12) | ((in[12 + inpos] & 63) << (26 - 6))) + + out[14 + outpos - 1]; + out[15 + outpos] = ((in[12 + inpos] >>> 6)) + + out[15 + outpos - 1]; + out[16 + outpos] = (((in[13 + inpos] >>> 0) & 67108863)) + + out[16 + outpos - 1]; + out[17 + outpos] = ((in[13 + inpos] >>> 26) | ((in[14 + inpos] & 1048575) << (26 - 20))) + + out[17 + outpos - 1]; + out[18 + outpos] = ((in[14 + inpos] >>> 20) | ((in[15 + inpos] & 16383) << (26 - 14))) + + out[18 + outpos - 1]; + out[19 + outpos] = ((in[15 + inpos] >>> 14) | ((in[16 + inpos] & 255) << (26 - 8))) + + out[19 + outpos - 1]; + out[20 + outpos] = ((in[16 + inpos] >>> 8) | ((in[17 + inpos] & 3) << (26 - 2))) + + out[20 + outpos - 1]; + out[21 + outpos] = (((in[17 + inpos] >>> 2) & 67108863)) + + out[21 + outpos - 1]; + out[22 + outpos] = ((in[17 + inpos] >>> 28) | ((in[18 + inpos] & 4194303) << (26 - 22))) + + out[22 + outpos - 1]; + out[23 + outpos] = ((in[18 + inpos] >>> 22) | ((in[19 + inpos] & 65535) << (26 - 16))) + + out[23 + outpos - 1]; + out[24 + outpos] = ((in[19 + inpos] >>> 16) | ((in[20 + inpos] & 1023) << (26 - 10))) + + out[24 + outpos - 1]; + out[25 + outpos] = ((in[20 + inpos] >>> 10) | ((in[21 + inpos] & 15) << (26 - 4))) + + out[25 + outpos - 1]; + out[26 + outpos] = (((in[21 + inpos] >>> 4) & 67108863)) + + out[26 + outpos - 1]; + out[27 + outpos] = ((in[21 + inpos] >>> 30) | ((in[22 + inpos] & 16777215) << (26 - 24))) + + out[27 + outpos - 1]; + out[28 + outpos] = ((in[22 + inpos] >>> 24) | ((in[23 + inpos] & 262143) << (26 - 18))) + + out[28 + outpos - 1]; + out[29 + outpos] = ((in[23 + inpos] >>> 18) | ((in[24 + inpos] & 4095) << (26 - 12))) + + out[29 + outpos - 1]; + out[30 + outpos] = ((in[24 + inpos] >>> 12) | ((in[25 + inpos] & 63) << (26 - 6))) + + out[30 + outpos - 1]; + out[31 + outpos] = ((in[25 + inpos] >>> 6)) + + out[31 + outpos - 1]; + } + + protected static void integratedunpack27(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + out[0 + outpos] = (((in[0 + inpos] >>> 0) & 134217727)) + + initoffset; + out[1 + outpos] = ((in[0 + inpos] >>> 27) | ((in[1 + inpos] & 4194303) << (27 - 22))) + + out[1 + outpos - 1]; + out[2 + outpos] = ((in[1 + inpos] >>> 22) | ((in[2 + inpos] & 131071) << (27 - 17))) + + out[2 + outpos - 1]; + out[3 + outpos] = ((in[2 + inpos] >>> 17) | ((in[3 + inpos] & 4095) << (27 - 12))) + + out[3 + outpos - 1]; + out[4 + outpos] = ((in[3 + inpos] >>> 12) | ((in[4 + inpos] & 127) << (27 - 7))) + + out[4 + outpos - 1]; + out[5 + outpos] = ((in[4 + inpos] >>> 7) | ((in[5 + inpos] & 3) << (27 - 2))) + + out[5 + outpos - 1]; + out[6 + outpos] = (((in[5 + inpos] >>> 2) & 134217727)) + + out[6 + outpos - 1]; + out[7 + outpos] = ((in[5 + inpos] >>> 29) | ((in[6 + inpos] & 16777215) << (27 - 24))) + + out[7 + outpos - 1]; + out[8 + outpos] = ((in[6 + inpos] >>> 24) | ((in[7 + inpos] & 524287) << (27 - 19))) + + out[8 + outpos - 1]; + out[9 + outpos] = ((in[7 + inpos] >>> 19) | ((in[8 + inpos] & 16383) << (27 - 14))) + + out[9 + outpos - 1]; + out[10 + outpos] = ((in[8 + inpos] >>> 14) | ((in[9 + inpos] & 511) << (27 - 9))) + + out[10 + outpos - 1]; + out[11 + outpos] = ((in[9 + inpos] >>> 9) | ((in[10 + inpos] & 15) << (27 - 4))) + + out[11 + outpos - 1]; + out[12 + outpos] = (((in[10 + inpos] >>> 4) & 134217727)) + + out[12 + outpos - 1]; + out[13 + outpos] = ((in[10 + inpos] >>> 31) | ((in[11 + inpos] & 67108863) << (27 - 26))) + + out[13 + outpos - 1]; + out[14 + outpos] = ((in[11 + inpos] >>> 26) | ((in[12 + inpos] & 2097151) << (27 - 21))) + + out[14 + outpos - 1]; + out[15 + outpos] = ((in[12 + inpos] >>> 21) | ((in[13 + inpos] & 65535) << (27 - 16))) + + out[15 + outpos - 1]; + out[16 + outpos] = ((in[13 + inpos] >>> 16) | ((in[14 + inpos] & 2047) << (27 - 11))) + + out[16 + outpos - 1]; + out[17 + outpos] = ((in[14 + inpos] >>> 11) | ((in[15 + inpos] & 63) << (27 - 6))) + + out[17 + outpos - 1]; + out[18 + outpos] = ((in[15 + inpos] >>> 6) | ((in[16 + inpos] & 1) << (27 - 1))) + + out[18 + outpos - 1]; + out[19 + outpos] = (((in[16 + inpos] >>> 1) & 134217727)) + + out[19 + outpos - 1]; + out[20 + outpos] = ((in[16 + inpos] >>> 28) | ((in[17 + inpos] & 8388607) << (27 - 23))) + + out[20 + outpos - 1]; + out[21 + outpos] = ((in[17 + inpos] >>> 23) | ((in[18 + inpos] & 262143) << (27 - 18))) + + out[21 + outpos - 1]; + out[22 + outpos] = ((in[18 + inpos] >>> 18) | ((in[19 + inpos] & 8191) << (27 - 13))) + + out[22 + outpos - 1]; + out[23 + outpos] = ((in[19 + inpos] >>> 13) | ((in[20 + inpos] & 255) << (27 - 8))) + + out[23 + outpos - 1]; + out[24 + outpos] = ((in[20 + inpos] >>> 8) | ((in[21 + inpos] & 7) << (27 - 3))) + + out[24 + outpos - 1]; + out[25 + outpos] = (((in[21 + inpos] >>> 3) & 134217727)) + + out[25 + outpos - 1]; + out[26 + outpos] = ((in[21 + inpos] >>> 30) | ((in[22 + inpos] & 33554431) << (27 - 25))) + + out[26 + outpos - 1]; + out[27 + outpos] = ((in[22 + inpos] >>> 25) | ((in[23 + inpos] & 1048575) << (27 - 20))) + + out[27 + outpos - 1]; + out[28 + outpos] = ((in[23 + inpos] >>> 20) | ((in[24 + inpos] & 32767) << (27 - 15))) + + out[28 + outpos - 1]; + out[29 + outpos] = ((in[24 + inpos] >>> 15) | ((in[25 + inpos] & 1023) << (27 - 10))) + + out[29 + outpos - 1]; + out[30 + outpos] = ((in[25 + inpos] >>> 10) | ((in[26 + inpos] & 31) << (27 - 5))) + + out[30 + outpos - 1]; + out[31 + outpos] = ((in[26 + inpos] >>> 5)) + + out[31 + outpos - 1]; + } + + protected static void integratedunpack28(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + out[0 + outpos] = (((in[0 + inpos] >>> 0) & 268435455)) + + initoffset; + out[1 + outpos] = ((in[0 + inpos] >>> 28) | ((in[1 + inpos] & 16777215) << (28 - 24))) + + out[1 + outpos - 1]; + out[2 + outpos] = ((in[1 + inpos] >>> 24) | ((in[2 + inpos] & 1048575) << (28 - 20))) + + out[2 + outpos - 1]; + out[3 + outpos] = ((in[2 + inpos] >>> 20) | ((in[3 + inpos] & 65535) << (28 - 16))) + + out[3 + outpos - 1]; + out[4 + outpos] = ((in[3 + inpos] >>> 16) | ((in[4 + inpos] & 4095) << (28 - 12))) + + out[4 + outpos - 1]; + out[5 + outpos] = ((in[4 + inpos] >>> 12) | ((in[5 + inpos] & 255) << (28 - 8))) + + out[5 + outpos - 1]; + out[6 + outpos] = ((in[5 + inpos] >>> 8) | ((in[6 + inpos] & 15) << (28 - 4))) + + out[6 + outpos - 1]; + out[7 + outpos] = ((in[6 + inpos] >>> 4)) + out[7 + outpos - 1]; + out[8 + outpos] = (((in[7 + inpos] >>> 0) & 268435455)) + + out[8 + outpos - 1]; + out[9 + outpos] = ((in[7 + inpos] >>> 28) | ((in[8 + inpos] & 16777215) << (28 - 24))) + + out[9 + outpos - 1]; + out[10 + outpos] = ((in[8 + inpos] >>> 24) | ((in[9 + inpos] & 1048575) << (28 - 20))) + + out[10 + outpos - 1]; + out[11 + outpos] = ((in[9 + inpos] >>> 20) | ((in[10 + inpos] & 65535) << (28 - 16))) + + out[11 + outpos - 1]; + out[12 + outpos] = ((in[10 + inpos] >>> 16) | ((in[11 + inpos] & 4095) << (28 - 12))) + + out[12 + outpos - 1]; + out[13 + outpos] = ((in[11 + inpos] >>> 12) | ((in[12 + inpos] & 255) << (28 - 8))) + + out[13 + outpos - 1]; + out[14 + outpos] = ((in[12 + inpos] >>> 8) | ((in[13 + inpos] & 15) << (28 - 4))) + + out[14 + outpos - 1]; + out[15 + outpos] = ((in[13 + inpos] >>> 4)) + + out[15 + outpos - 1]; + out[16 + outpos] = (((in[14 + inpos] >>> 0) & 268435455)) + + out[16 + outpos - 1]; + out[17 + outpos] = ((in[14 + inpos] >>> 28) | ((in[15 + inpos] & 16777215) << (28 - 24))) + + out[17 + outpos - 1]; + out[18 + outpos] = ((in[15 + inpos] >>> 24) | ((in[16 + inpos] & 1048575) << (28 - 20))) + + out[18 + outpos - 1]; + out[19 + outpos] = ((in[16 + inpos] >>> 20) | ((in[17 + inpos] & 65535) << (28 - 16))) + + out[19 + outpos - 1]; + out[20 + outpos] = ((in[17 + inpos] >>> 16) | ((in[18 + inpos] & 4095) << (28 - 12))) + + out[20 + outpos - 1]; + out[21 + outpos] = ((in[18 + inpos] >>> 12) | ((in[19 + inpos] & 255) << (28 - 8))) + + out[21 + outpos - 1]; + out[22 + outpos] = ((in[19 + inpos] >>> 8) | ((in[20 + inpos] & 15) << (28 - 4))) + + out[22 + outpos - 1]; + out[23 + outpos] = ((in[20 + inpos] >>> 4)) + + out[23 + outpos - 1]; + out[24 + outpos] = (((in[21 + inpos] >>> 0) & 268435455)) + + out[24 + outpos - 1]; + out[25 + outpos] = ((in[21 + inpos] >>> 28) | ((in[22 + inpos] & 16777215) << (28 - 24))) + + out[25 + outpos - 1]; + out[26 + outpos] = ((in[22 + inpos] >>> 24) | ((in[23 + inpos] & 1048575) << (28 - 20))) + + out[26 + outpos - 1]; + out[27 + outpos] = ((in[23 + inpos] >>> 20) | ((in[24 + inpos] & 65535) << (28 - 16))) + + out[27 + outpos - 1]; + out[28 + outpos] = ((in[24 + inpos] >>> 16) | ((in[25 + inpos] & 4095) << (28 - 12))) + + out[28 + outpos - 1]; + out[29 + outpos] = ((in[25 + inpos] >>> 12) | ((in[26 + inpos] & 255) << (28 - 8))) + + out[29 + outpos - 1]; + out[30 + outpos] = ((in[26 + inpos] >>> 8) | ((in[27 + inpos] & 15) << (28 - 4))) + + out[30 + outpos - 1]; + out[31 + outpos] = ((in[27 + inpos] >>> 4)) + + out[31 + outpos - 1]; + } + + protected static void integratedunpack29(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + out[0 + outpos] = (((in[0 + inpos] >>> 0) & 536870911)) + + initoffset; + out[1 + outpos] = ((in[0 + inpos] >>> 29) | ((in[1 + inpos] & 67108863) << (29 - 26))) + + out[1 + outpos - 1]; + out[2 + outpos] = ((in[1 + inpos] >>> 26) | ((in[2 + inpos] & 8388607) << (29 - 23))) + + out[2 + outpos - 1]; + out[3 + outpos] = ((in[2 + inpos] >>> 23) | ((in[3 + inpos] & 1048575) << (29 - 20))) + + out[3 + outpos - 1]; + out[4 + outpos] = ((in[3 + inpos] >>> 20) | ((in[4 + inpos] & 131071) << (29 - 17))) + + out[4 + outpos - 1]; + out[5 + outpos] = ((in[4 + inpos] >>> 17) | ((in[5 + inpos] & 16383) << (29 - 14))) + + out[5 + outpos - 1]; + out[6 + outpos] = ((in[5 + inpos] >>> 14) | ((in[6 + inpos] & 2047) << (29 - 11))) + + out[6 + outpos - 1]; + out[7 + outpos] = ((in[6 + inpos] >>> 11) | ((in[7 + inpos] & 255) << (29 - 8))) + + out[7 + outpos - 1]; + out[8 + outpos] = ((in[7 + inpos] >>> 8) | ((in[8 + inpos] & 31) << (29 - 5))) + + out[8 + outpos - 1]; + out[9 + outpos] = ((in[8 + inpos] >>> 5) | ((in[9 + inpos] & 3) << (29 - 2))) + + out[9 + outpos - 1]; + out[10 + outpos] = (((in[9 + inpos] >>> 2) & 536870911)) + + out[10 + outpos - 1]; + out[11 + outpos] = ((in[9 + inpos] >>> 31) | ((in[10 + inpos] & 268435455) << (29 - 28))) + + out[11 + outpos - 1]; + out[12 + outpos] = ((in[10 + inpos] >>> 28) | ((in[11 + inpos] & 33554431) << (29 - 25))) + + out[12 + outpos - 1]; + out[13 + outpos] = ((in[11 + inpos] >>> 25) | ((in[12 + inpos] & 4194303) << (29 - 22))) + + out[13 + outpos - 1]; + out[14 + outpos] = ((in[12 + inpos] >>> 22) | ((in[13 + inpos] & 524287) << (29 - 19))) + + out[14 + outpos - 1]; + out[15 + outpos] = ((in[13 + inpos] >>> 19) | ((in[14 + inpos] & 65535) << (29 - 16))) + + out[15 + outpos - 1]; + out[16 + outpos] = ((in[14 + inpos] >>> 16) | ((in[15 + inpos] & 8191) << (29 - 13))) + + out[16 + outpos - 1]; + out[17 + outpos] = ((in[15 + inpos] >>> 13) | ((in[16 + inpos] & 1023) << (29 - 10))) + + out[17 + outpos - 1]; + out[18 + outpos] = ((in[16 + inpos] >>> 10) | ((in[17 + inpos] & 127) << (29 - 7))) + + out[18 + outpos - 1]; + out[19 + outpos] = ((in[17 + inpos] >>> 7) | ((in[18 + inpos] & 15) << (29 - 4))) + + out[19 + outpos - 1]; + out[20 + outpos] = ((in[18 + inpos] >>> 4) | ((in[19 + inpos] & 1) << (29 - 1))) + + out[20 + outpos - 1]; + out[21 + outpos] = (((in[19 + inpos] >>> 1) & 536870911)) + + out[21 + outpos - 1]; + out[22 + outpos] = ((in[19 + inpos] >>> 30) | ((in[20 + inpos] & 134217727) << (29 - 27))) + + out[22 + outpos - 1]; + out[23 + outpos] = ((in[20 + inpos] >>> 27) | ((in[21 + inpos] & 16777215) << (29 - 24))) + + out[23 + outpos - 1]; + out[24 + outpos] = ((in[21 + inpos] >>> 24) | ((in[22 + inpos] & 2097151) << (29 - 21))) + + out[24 + outpos - 1]; + out[25 + outpos] = ((in[22 + inpos] >>> 21) | ((in[23 + inpos] & 262143) << (29 - 18))) + + out[25 + outpos - 1]; + out[26 + outpos] = ((in[23 + inpos] >>> 18) | ((in[24 + inpos] & 32767) << (29 - 15))) + + out[26 + outpos - 1]; + out[27 + outpos] = ((in[24 + inpos] >>> 15) | ((in[25 + inpos] & 4095) << (29 - 12))) + + out[27 + outpos - 1]; + out[28 + outpos] = ((in[25 + inpos] >>> 12) | ((in[26 + inpos] & 511) << (29 - 9))) + + out[28 + outpos - 1]; + out[29 + outpos] = ((in[26 + inpos] >>> 9) | ((in[27 + inpos] & 63) << (29 - 6))) + + out[29 + outpos - 1]; + out[30 + outpos] = ((in[27 + inpos] >>> 6) | ((in[28 + inpos] & 7) << (29 - 3))) + + out[30 + outpos - 1]; + out[31 + outpos] = ((in[28 + inpos] >>> 3)) + + out[31 + outpos - 1]; + } + + protected static void integratedunpack3(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + out[0 + outpos] = (((in[0 + inpos] >>> 0) & 7)) + initoffset; + out[1 + outpos] = (((in[0 + inpos] >>> 3) & 7)) + + out[1 + outpos - 1]; + out[2 + outpos] = (((in[0 + inpos] >>> 6) & 7)) + + out[2 + outpos - 1]; + out[3 + outpos] = (((in[0 + inpos] >>> 9) & 7)) + + out[3 + outpos - 1]; + out[4 + outpos] = (((in[0 + inpos] >>> 12) & 7)) + + out[4 + outpos - 1]; + out[5 + outpos] = (((in[0 + inpos] >>> 15) & 7)) + + out[5 + outpos - 1]; + out[6 + outpos] = (((in[0 + inpos] >>> 18) & 7)) + + out[6 + outpos - 1]; + out[7 + outpos] = (((in[0 + inpos] >>> 21) & 7)) + + out[7 + outpos - 1]; + out[8 + outpos] = (((in[0 + inpos] >>> 24) & 7)) + + out[8 + outpos - 1]; + out[9 + outpos] = (((in[0 + inpos] >>> 27) & 7)) + + out[9 + outpos - 1]; + out[10 + outpos] = ((in[0 + inpos] >>> 30) | ((in[1 + inpos] & 1) << (3 - 1))) + + out[10 + outpos - 1]; + out[11 + outpos] = (((in[1 + inpos] >>> 1) & 7)) + + out[11 + outpos - 1]; + out[12 + outpos] = (((in[1 + inpos] >>> 4) & 7)) + + out[12 + outpos - 1]; + out[13 + outpos] = (((in[1 + inpos] >>> 7) & 7)) + + out[13 + outpos - 1]; + out[14 + outpos] = (((in[1 + inpos] >>> 10) & 7)) + + out[14 + outpos - 1]; + out[15 + outpos] = (((in[1 + inpos] >>> 13) & 7)) + + out[15 + outpos - 1]; + out[16 + outpos] = (((in[1 + inpos] >>> 16) & 7)) + + out[16 + outpos - 1]; + out[17 + outpos] = (((in[1 + inpos] >>> 19) & 7)) + + out[17 + outpos - 1]; + out[18 + outpos] = (((in[1 + inpos] >>> 22) & 7)) + + out[18 + outpos - 1]; + out[19 + outpos] = (((in[1 + inpos] >>> 25) & 7)) + + out[19 + outpos - 1]; + out[20 + outpos] = (((in[1 + inpos] >>> 28) & 7)) + + out[20 + outpos - 1]; + out[21 + outpos] = ((in[1 + inpos] >>> 31) | ((in[2 + inpos] & 3) << (3 - 2))) + + out[21 + outpos - 1]; + out[22 + outpos] = (((in[2 + inpos] >>> 2) & 7)) + + out[22 + outpos - 1]; + out[23 + outpos] = (((in[2 + inpos] >>> 5) & 7)) + + out[23 + outpos - 1]; + out[24 + outpos] = (((in[2 + inpos] >>> 8) & 7)) + + out[24 + outpos - 1]; + out[25 + outpos] = (((in[2 + inpos] >>> 11) & 7)) + + out[25 + outpos - 1]; + out[26 + outpos] = (((in[2 + inpos] >>> 14) & 7)) + + out[26 + outpos - 1]; + out[27 + outpos] = (((in[2 + inpos] >>> 17) & 7)) + + out[27 + outpos - 1]; + out[28 + outpos] = (((in[2 + inpos] >>> 20) & 7)) + + out[28 + outpos - 1]; + out[29 + outpos] = (((in[2 + inpos] >>> 23) & 7)) + + out[29 + outpos - 1]; + out[30 + outpos] = (((in[2 + inpos] >>> 26) & 7)) + + out[30 + outpos - 1]; + out[31 + outpos] = ((in[2 + inpos] >>> 29)) + + out[31 + outpos - 1]; + } + + protected static void integratedunpack30(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + out[0 + outpos] = (((in[0 + inpos] >>> 0) & 1073741823)) + + initoffset; + out[1 + outpos] = ((in[0 + inpos] >>> 30) | ((in[1 + inpos] & 268435455) << (30 - 28))) + + out[1 + outpos - 1]; + out[2 + outpos] = ((in[1 + inpos] >>> 28) | ((in[2 + inpos] & 67108863) << (30 - 26))) + + out[2 + outpos - 1]; + out[3 + outpos] = ((in[2 + inpos] >>> 26) | ((in[3 + inpos] & 16777215) << (30 - 24))) + + out[3 + outpos - 1]; + out[4 + outpos] = ((in[3 + inpos] >>> 24) | ((in[4 + inpos] & 4194303) << (30 - 22))) + + out[4 + outpos - 1]; + out[5 + outpos] = ((in[4 + inpos] >>> 22) | ((in[5 + inpos] & 1048575) << (30 - 20))) + + out[5 + outpos - 1]; + out[6 + outpos] = ((in[5 + inpos] >>> 20) | ((in[6 + inpos] & 262143) << (30 - 18))) + + out[6 + outpos - 1]; + out[7 + outpos] = ((in[6 + inpos] >>> 18) | ((in[7 + inpos] & 65535) << (30 - 16))) + + out[7 + outpos - 1]; + out[8 + outpos] = ((in[7 + inpos] >>> 16) | ((in[8 + inpos] & 16383) << (30 - 14))) + + out[8 + outpos - 1]; + out[9 + outpos] = ((in[8 + inpos] >>> 14) | ((in[9 + inpos] & 4095) << (30 - 12))) + + out[9 + outpos - 1]; + out[10 + outpos] = ((in[9 + inpos] >>> 12) | ((in[10 + inpos] & 1023) << (30 - 10))) + + out[10 + outpos - 1]; + out[11 + outpos] = ((in[10 + inpos] >>> 10) | ((in[11 + inpos] & 255) << (30 - 8))) + + out[11 + outpos - 1]; + out[12 + outpos] = ((in[11 + inpos] >>> 8) | ((in[12 + inpos] & 63) << (30 - 6))) + + out[12 + outpos - 1]; + out[13 + outpos] = ((in[12 + inpos] >>> 6) | ((in[13 + inpos] & 15) << (30 - 4))) + + out[13 + outpos - 1]; + out[14 + outpos] = ((in[13 + inpos] >>> 4) | ((in[14 + inpos] & 3) << (30 - 2))) + + out[14 + outpos - 1]; + out[15 + outpos] = ((in[14 + inpos] >>> 2)) + + out[15 + outpos - 1]; + out[16 + outpos] = (((in[15 + inpos] >>> 0) & 1073741823)) + + out[16 + outpos - 1]; + out[17 + outpos] = ((in[15 + inpos] >>> 30) | ((in[16 + inpos] & 268435455) << (30 - 28))) + + out[17 + outpos - 1]; + out[18 + outpos] = ((in[16 + inpos] >>> 28) | ((in[17 + inpos] & 67108863) << (30 - 26))) + + out[18 + outpos - 1]; + out[19 + outpos] = ((in[17 + inpos] >>> 26) | ((in[18 + inpos] & 16777215) << (30 - 24))) + + out[19 + outpos - 1]; + out[20 + outpos] = ((in[18 + inpos] >>> 24) | ((in[19 + inpos] & 4194303) << (30 - 22))) + + out[20 + outpos - 1]; + out[21 + outpos] = ((in[19 + inpos] >>> 22) | ((in[20 + inpos] & 1048575) << (30 - 20))) + + out[21 + outpos - 1]; + out[22 + outpos] = ((in[20 + inpos] >>> 20) | ((in[21 + inpos] & 262143) << (30 - 18))) + + out[22 + outpos - 1]; + out[23 + outpos] = ((in[21 + inpos] >>> 18) | ((in[22 + inpos] & 65535) << (30 - 16))) + + out[23 + outpos - 1]; + out[24 + outpos] = ((in[22 + inpos] >>> 16) | ((in[23 + inpos] & 16383) << (30 - 14))) + + out[24 + outpos - 1]; + out[25 + outpos] = ((in[23 + inpos] >>> 14) | ((in[24 + inpos] & 4095) << (30 - 12))) + + out[25 + outpos - 1]; + out[26 + outpos] = ((in[24 + inpos] >>> 12) | ((in[25 + inpos] & 1023) << (30 - 10))) + + out[26 + outpos - 1]; + out[27 + outpos] = ((in[25 + inpos] >>> 10) | ((in[26 + inpos] & 255) << (30 - 8))) + + out[27 + outpos - 1]; + out[28 + outpos] = ((in[26 + inpos] >>> 8) | ((in[27 + inpos] & 63) << (30 - 6))) + + out[28 + outpos - 1]; + out[29 + outpos] = ((in[27 + inpos] >>> 6) | ((in[28 + inpos] & 15) << (30 - 4))) + + out[29 + outpos - 1]; + out[30 + outpos] = ((in[28 + inpos] >>> 4) | ((in[29 + inpos] & 3) << (30 - 2))) + + out[30 + outpos - 1]; + out[31 + outpos] = ((in[29 + inpos] >>> 2)) + + out[31 + outpos - 1]; + } + + protected static void integratedunpack31(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + out[0 + outpos] = (((in[0 + inpos] >>> 0) & 2147483647)) + + initoffset; + out[1 + outpos] = ((in[0 + inpos] >>> 31) | ((in[1 + inpos] & 1073741823) << (31 - 30))) + + out[1 + outpos - 1]; + out[2 + outpos] = ((in[1 + inpos] >>> 30) | ((in[2 + inpos] & 536870911) << (31 - 29))) + + out[2 + outpos - 1]; + out[3 + outpos] = ((in[2 + inpos] >>> 29) | ((in[3 + inpos] & 268435455) << (31 - 28))) + + out[3 + outpos - 1]; + out[4 + outpos] = ((in[3 + inpos] >>> 28) | ((in[4 + inpos] & 134217727) << (31 - 27))) + + out[4 + outpos - 1]; + out[5 + outpos] = ((in[4 + inpos] >>> 27) | ((in[5 + inpos] & 67108863) << (31 - 26))) + + out[5 + outpos - 1]; + out[6 + outpos] = ((in[5 + inpos] >>> 26) | ((in[6 + inpos] & 33554431) << (31 - 25))) + + out[6 + outpos - 1]; + out[7 + outpos] = ((in[6 + inpos] >>> 25) | ((in[7 + inpos] & 16777215) << (31 - 24))) + + out[7 + outpos - 1]; + out[8 + outpos] = ((in[7 + inpos] >>> 24) | ((in[8 + inpos] & 8388607) << (31 - 23))) + + out[8 + outpos - 1]; + out[9 + outpos] = ((in[8 + inpos] >>> 23) | ((in[9 + inpos] & 4194303) << (31 - 22))) + + out[9 + outpos - 1]; + out[10 + outpos] = ((in[9 + inpos] >>> 22) | ((in[10 + inpos] & 2097151) << (31 - 21))) + + out[10 + outpos - 1]; + out[11 + outpos] = ((in[10 + inpos] >>> 21) | ((in[11 + inpos] & 1048575) << (31 - 20))) + + out[11 + outpos - 1]; + out[12 + outpos] = ((in[11 + inpos] >>> 20) | ((in[12 + inpos] & 524287) << (31 - 19))) + + out[12 + outpos - 1]; + out[13 + outpos] = ((in[12 + inpos] >>> 19) | ((in[13 + inpos] & 262143) << (31 - 18))) + + out[13 + outpos - 1]; + out[14 + outpos] = ((in[13 + inpos] >>> 18) | ((in[14 + inpos] & 131071) << (31 - 17))) + + out[14 + outpos - 1]; + out[15 + outpos] = ((in[14 + inpos] >>> 17) | ((in[15 + inpos] & 65535) << (31 - 16))) + + out[15 + outpos - 1]; + out[16 + outpos] = ((in[15 + inpos] >>> 16) | ((in[16 + inpos] & 32767) << (31 - 15))) + + out[16 + outpos - 1]; + out[17 + outpos] = ((in[16 + inpos] >>> 15) | ((in[17 + inpos] & 16383) << (31 - 14))) + + out[17 + outpos - 1]; + out[18 + outpos] = ((in[17 + inpos] >>> 14) | ((in[18 + inpos] & 8191) << (31 - 13))) + + out[18 + outpos - 1]; + out[19 + outpos] = ((in[18 + inpos] >>> 13) | ((in[19 + inpos] & 4095) << (31 - 12))) + + out[19 + outpos - 1]; + out[20 + outpos] = ((in[19 + inpos] >>> 12) | ((in[20 + inpos] & 2047) << (31 - 11))) + + out[20 + outpos - 1]; + out[21 + outpos] = ((in[20 + inpos] >>> 11) | ((in[21 + inpos] & 1023) << (31 - 10))) + + out[21 + outpos - 1]; + out[22 + outpos] = ((in[21 + inpos] >>> 10) | ((in[22 + inpos] & 511) << (31 - 9))) + + out[22 + outpos - 1]; + out[23 + outpos] = ((in[22 + inpos] >>> 9) | ((in[23 + inpos] & 255) << (31 - 8))) + + out[23 + outpos - 1]; + out[24 + outpos] = ((in[23 + inpos] >>> 8) | ((in[24 + inpos] & 127) << (31 - 7))) + + out[24 + outpos - 1]; + out[25 + outpos] = ((in[24 + inpos] >>> 7) | ((in[25 + inpos] & 63) << (31 - 6))) + + out[25 + outpos - 1]; + out[26 + outpos] = ((in[25 + inpos] >>> 6) | ((in[26 + inpos] & 31) << (31 - 5))) + + out[26 + outpos - 1]; + out[27 + outpos] = ((in[26 + inpos] >>> 5) | ((in[27 + inpos] & 15) << (31 - 4))) + + out[27 + outpos - 1]; + out[28 + outpos] = ((in[27 + inpos] >>> 4) | ((in[28 + inpos] & 7) << (31 - 3))) + + out[28 + outpos - 1]; + out[29 + outpos] = ((in[28 + inpos] >>> 3) | ((in[29 + inpos] & 3) << (31 - 2))) + + out[29 + outpos - 1]; + out[30 + outpos] = ((in[29 + inpos] >>> 2) | ((in[30 + inpos] & 1) << (31 - 1))) + + out[30 + outpos - 1]; + out[31 + outpos] = ((in[30 + inpos] >>> 1)) + + out[31 + outpos - 1]; + } + + protected static void integratedunpack32(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + System.arraycopy(in, inpos, out, outpos, 32); // no sense in + // doing delta + // coding + } + + protected static void integratedunpack4(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + out[0 + outpos] = (((in[0 + inpos] >>> 0) & 15)) + initoffset; + out[1 + outpos] = (((in[0 + inpos] >>> 4) & 15)) + + out[1 + outpos - 1]; + out[2 + outpos] = (((in[0 + inpos] >>> 8) & 15)) + + out[2 + outpos - 1]; + out[3 + outpos] = (((in[0 + inpos] >>> 12) & 15)) + + out[3 + outpos - 1]; + out[4 + outpos] = (((in[0 + inpos] >>> 16) & 15)) + + out[4 + outpos - 1]; + out[5 + outpos] = (((in[0 + inpos] >>> 20) & 15)) + + out[5 + outpos - 1]; + out[6 + outpos] = (((in[0 + inpos] >>> 24) & 15)) + + out[6 + outpos - 1]; + out[7 + outpos] = ((in[0 + inpos] >>> 28)) + + out[7 + outpos - 1]; + out[8 + outpos] = (((in[1 + inpos] >>> 0) & 15)) + + out[8 + outpos - 1]; + out[9 + outpos] = (((in[1 + inpos] >>> 4) & 15)) + + out[9 + outpos - 1]; + out[10 + outpos] = (((in[1 + inpos] >>> 8) & 15)) + + out[10 + outpos - 1]; + out[11 + outpos] = (((in[1 + inpos] >>> 12) & 15)) + + out[11 + outpos - 1]; + out[12 + outpos] = (((in[1 + inpos] >>> 16) & 15)) + + out[12 + outpos - 1]; + out[13 + outpos] = (((in[1 + inpos] >>> 20) & 15)) + + out[13 + outpos - 1]; + out[14 + outpos] = (((in[1 + inpos] >>> 24) & 15)) + + out[14 + outpos - 1]; + out[15 + outpos] = ((in[1 + inpos] >>> 28)) + + out[15 + outpos - 1]; + out[16 + outpos] = (((in[2 + inpos] >>> 0) & 15)) + + out[16 + outpos - 1]; + out[17 + outpos] = (((in[2 + inpos] >>> 4) & 15)) + + out[17 + outpos - 1]; + out[18 + outpos] = (((in[2 + inpos] >>> 8) & 15)) + + out[18 + outpos - 1]; + out[19 + outpos] = (((in[2 + inpos] >>> 12) & 15)) + + out[19 + outpos - 1]; + out[20 + outpos] = (((in[2 + inpos] >>> 16) & 15)) + + out[20 + outpos - 1]; + out[21 + outpos] = (((in[2 + inpos] >>> 20) & 15)) + + out[21 + outpos - 1]; + out[22 + outpos] = (((in[2 + inpos] >>> 24) & 15)) + + out[22 + outpos - 1]; + out[23 + outpos] = ((in[2 + inpos] >>> 28)) + + out[23 + outpos - 1]; + out[24 + outpos] = (((in[3 + inpos] >>> 0) & 15)) + + out[24 + outpos - 1]; + out[25 + outpos] = (((in[3 + inpos] >>> 4) & 15)) + + out[25 + outpos - 1]; + out[26 + outpos] = (((in[3 + inpos] >>> 8) & 15)) + + out[26 + outpos - 1]; + out[27 + outpos] = (((in[3 + inpos] >>> 12) & 15)) + + out[27 + outpos - 1]; + out[28 + outpos] = (((in[3 + inpos] >>> 16) & 15)) + + out[28 + outpos - 1]; + out[29 + outpos] = (((in[3 + inpos] >>> 20) & 15)) + + out[29 + outpos - 1]; + out[30 + outpos] = (((in[3 + inpos] >>> 24) & 15)) + + out[30 + outpos - 1]; + out[31 + outpos] = ((in[3 + inpos] >>> 28)) + + out[31 + outpos - 1]; + } + + protected static void integratedunpack5(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + out[0 + outpos] = (((in[0 + inpos] >>> 0) & 31)) + initoffset; + out[1 + outpos] = (((in[0 + inpos] >>> 5) & 31)) + + out[1 + outpos - 1]; + out[2 + outpos] = (((in[0 + inpos] >>> 10) & 31)) + + out[2 + outpos - 1]; + out[3 + outpos] = (((in[0 + inpos] >>> 15) & 31)) + + out[3 + outpos - 1]; + out[4 + outpos] = (((in[0 + inpos] >>> 20) & 31)) + + out[4 + outpos - 1]; + out[5 + outpos] = (((in[0 + inpos] >>> 25) & 31)) + + out[5 + outpos - 1]; + out[6 + outpos] = ((in[0 + inpos] >>> 30) | ((in[1 + inpos] & 7) << (5 - 3))) + + out[6 + outpos - 1]; + out[7 + outpos] = (((in[1 + inpos] >>> 3) & 31)) + + out[7 + outpos - 1]; + out[8 + outpos] = (((in[1 + inpos] >>> 8) & 31)) + + out[8 + outpos - 1]; + out[9 + outpos] = (((in[1 + inpos] >>> 13) & 31)) + + out[9 + outpos - 1]; + out[10 + outpos] = (((in[1 + inpos] >>> 18) & 31)) + + out[10 + outpos - 1]; + out[11 + outpos] = (((in[1 + inpos] >>> 23) & 31)) + + out[11 + outpos - 1]; + out[12 + outpos] = ((in[1 + inpos] >>> 28) | ((in[2 + inpos] & 1) << (5 - 1))) + + out[12 + outpos - 1]; + out[13 + outpos] = (((in[2 + inpos] >>> 1) & 31)) + + out[13 + outpos - 1]; + out[14 + outpos] = (((in[2 + inpos] >>> 6) & 31)) + + out[14 + outpos - 1]; + out[15 + outpos] = (((in[2 + inpos] >>> 11) & 31)) + + out[15 + outpos - 1]; + out[16 + outpos] = (((in[2 + inpos] >>> 16) & 31)) + + out[16 + outpos - 1]; + out[17 + outpos] = (((in[2 + inpos] >>> 21) & 31)) + + out[17 + outpos - 1]; + out[18 + outpos] = (((in[2 + inpos] >>> 26) & 31)) + + out[18 + outpos - 1]; + out[19 + outpos] = ((in[2 + inpos] >>> 31) | ((in[3 + inpos] & 15) << (5 - 4))) + + out[19 + outpos - 1]; + out[20 + outpos] = (((in[3 + inpos] >>> 4) & 31)) + + out[20 + outpos - 1]; + out[21 + outpos] = (((in[3 + inpos] >>> 9) & 31)) + + out[21 + outpos - 1]; + out[22 + outpos] = (((in[3 + inpos] >>> 14) & 31)) + + out[22 + outpos - 1]; + out[23 + outpos] = (((in[3 + inpos] >>> 19) & 31)) + + out[23 + outpos - 1]; + out[24 + outpos] = (((in[3 + inpos] >>> 24) & 31)) + + out[24 + outpos - 1]; + out[25 + outpos] = ((in[3 + inpos] >>> 29) | ((in[4 + inpos] & 3) << (5 - 2))) + + out[25 + outpos - 1]; + out[26 + outpos] = (((in[4 + inpos] >>> 2) & 31)) + + out[26 + outpos - 1]; + out[27 + outpos] = (((in[4 + inpos] >>> 7) & 31)) + + out[27 + outpos - 1]; + out[28 + outpos] = (((in[4 + inpos] >>> 12) & 31)) + + out[28 + outpos - 1]; + out[29 + outpos] = (((in[4 + inpos] >>> 17) & 31)) + + out[29 + outpos - 1]; + out[30 + outpos] = (((in[4 + inpos] >>> 22) & 31)) + + out[30 + outpos - 1]; + out[31 + outpos] = ((in[4 + inpos] >>> 27)) + + out[31 + outpos - 1]; + } + + protected static void integratedunpack6(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + out[0 + outpos] = (((in[0 + inpos] >>> 0) & 63)) + initoffset; + out[1 + outpos] = (((in[0 + inpos] >>> 6) & 63)) + + out[1 + outpos - 1]; + out[2 + outpos] = (((in[0 + inpos] >>> 12) & 63)) + + out[2 + outpos - 1]; + out[3 + outpos] = (((in[0 + inpos] >>> 18) & 63)) + + out[3 + outpos - 1]; + out[4 + outpos] = (((in[0 + inpos] >>> 24) & 63)) + + out[4 + outpos - 1]; + out[5 + outpos] = ((in[0 + inpos] >>> 30) | ((in[1 + inpos] & 15) << (6 - 4))) + + out[5 + outpos - 1]; + out[6 + outpos] = (((in[1 + inpos] >>> 4) & 63)) + + out[6 + outpos - 1]; + out[7 + outpos] = (((in[1 + inpos] >>> 10) & 63)) + + out[7 + outpos - 1]; + out[8 + outpos] = (((in[1 + inpos] >>> 16) & 63)) + + out[8 + outpos - 1]; + out[9 + outpos] = (((in[1 + inpos] >>> 22) & 63)) + + out[9 + outpos - 1]; + out[10 + outpos] = ((in[1 + inpos] >>> 28) | ((in[2 + inpos] & 3) << (6 - 2))) + + out[10 + outpos - 1]; + out[11 + outpos] = (((in[2 + inpos] >>> 2) & 63)) + + out[11 + outpos - 1]; + out[12 + outpos] = (((in[2 + inpos] >>> 8) & 63)) + + out[12 + outpos - 1]; + out[13 + outpos] = (((in[2 + inpos] >>> 14) & 63)) + + out[13 + outpos - 1]; + out[14 + outpos] = (((in[2 + inpos] >>> 20) & 63)) + + out[14 + outpos - 1]; + out[15 + outpos] = ((in[2 + inpos] >>> 26)) + + out[15 + outpos - 1]; + out[16 + outpos] = (((in[3 + inpos] >>> 0) & 63)) + + out[16 + outpos - 1]; + out[17 + outpos] = (((in[3 + inpos] >>> 6) & 63)) + + out[17 + outpos - 1]; + out[18 + outpos] = (((in[3 + inpos] >>> 12) & 63)) + + out[18 + outpos - 1]; + out[19 + outpos] = (((in[3 + inpos] >>> 18) & 63)) + + out[19 + outpos - 1]; + out[20 + outpos] = (((in[3 + inpos] >>> 24) & 63)) + + out[20 + outpos - 1]; + out[21 + outpos] = ((in[3 + inpos] >>> 30) | ((in[4 + inpos] & 15) << (6 - 4))) + + out[21 + outpos - 1]; + out[22 + outpos] = (((in[4 + inpos] >>> 4) & 63)) + + out[22 + outpos - 1]; + out[23 + outpos] = (((in[4 + inpos] >>> 10) & 63)) + + out[23 + outpos - 1]; + out[24 + outpos] = (((in[4 + inpos] >>> 16) & 63)) + + out[24 + outpos - 1]; + out[25 + outpos] = (((in[4 + inpos] >>> 22) & 63)) + + out[25 + outpos - 1]; + out[26 + outpos] = ((in[4 + inpos] >>> 28) | ((in[5 + inpos] & 3) << (6 - 2))) + + out[26 + outpos - 1]; + out[27 + outpos] = (((in[5 + inpos] >>> 2) & 63)) + + out[27 + outpos - 1]; + out[28 + outpos] = (((in[5 + inpos] >>> 8) & 63)) + + out[28 + outpos - 1]; + out[29 + outpos] = (((in[5 + inpos] >>> 14) & 63)) + + out[29 + outpos - 1]; + out[30 + outpos] = (((in[5 + inpos] >>> 20) & 63)) + + out[30 + outpos - 1]; + out[31 + outpos] = ((in[5 + inpos] >>> 26)) + + out[31 + outpos - 1]; + } + + protected static void integratedunpack7(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + out[0 + outpos] = (((in[0 + inpos] >>> 0) & 127)) + initoffset; + out[1 + outpos] = (((in[0 + inpos] >>> 7) & 127)) + + out[1 + outpos - 1]; + out[2 + outpos] = (((in[0 + inpos] >>> 14) & 127)) + + out[2 + outpos - 1]; + out[3 + outpos] = (((in[0 + inpos] >>> 21) & 127)) + + out[3 + outpos - 1]; + out[4 + outpos] = ((in[0 + inpos] >>> 28) | ((in[1 + inpos] & 7) << (7 - 3))) + + out[4 + outpos - 1]; + out[5 + outpos] = (((in[1 + inpos] >>> 3) & 127)) + + out[5 + outpos - 1]; + out[6 + outpos] = (((in[1 + inpos] >>> 10) & 127)) + + out[6 + outpos - 1]; + out[7 + outpos] = (((in[1 + inpos] >>> 17) & 127)) + + out[7 + outpos - 1]; + out[8 + outpos] = (((in[1 + inpos] >>> 24) & 127)) + + out[8 + outpos - 1]; + out[9 + outpos] = ((in[1 + inpos] >>> 31) | ((in[2 + inpos] & 63) << (7 - 6))) + + out[9 + outpos - 1]; + out[10 + outpos] = (((in[2 + inpos] >>> 6) & 127)) + + out[10 + outpos - 1]; + out[11 + outpos] = (((in[2 + inpos] >>> 13) & 127)) + + out[11 + outpos - 1]; + out[12 + outpos] = (((in[2 + inpos] >>> 20) & 127)) + + out[12 + outpos - 1]; + out[13 + outpos] = ((in[2 + inpos] >>> 27) | ((in[3 + inpos] & 3) << (7 - 2))) + + out[13 + outpos - 1]; + out[14 + outpos] = (((in[3 + inpos] >>> 2) & 127)) + + out[14 + outpos - 1]; + out[15 + outpos] = (((in[3 + inpos] >>> 9) & 127)) + + out[15 + outpos - 1]; + out[16 + outpos] = (((in[3 + inpos] >>> 16) & 127)) + + out[16 + outpos - 1]; + out[17 + outpos] = (((in[3 + inpos] >>> 23) & 127)) + + out[17 + outpos - 1]; + out[18 + outpos] = ((in[3 + inpos] >>> 30) | ((in[4 + inpos] & 31) << (7 - 5))) + + out[18 + outpos - 1]; + out[19 + outpos] = (((in[4 + inpos] >>> 5) & 127)) + + out[19 + outpos - 1]; + out[20 + outpos] = (((in[4 + inpos] >>> 12) & 127)) + + out[20 + outpos - 1]; + out[21 + outpos] = (((in[4 + inpos] >>> 19) & 127)) + + out[21 + outpos - 1]; + out[22 + outpos] = ((in[4 + inpos] >>> 26) | ((in[5 + inpos] & 1) << (7 - 1))) + + out[22 + outpos - 1]; + out[23 + outpos] = (((in[5 + inpos] >>> 1) & 127)) + + out[23 + outpos - 1]; + out[24 + outpos] = (((in[5 + inpos] >>> 8) & 127)) + + out[24 + outpos - 1]; + out[25 + outpos] = (((in[5 + inpos] >>> 15) & 127)) + + out[25 + outpos - 1]; + out[26 + outpos] = (((in[5 + inpos] >>> 22) & 127)) + + out[26 + outpos - 1]; + out[27 + outpos] = ((in[5 + inpos] >>> 29) | ((in[6 + inpos] & 15) << (7 - 4))) + + out[27 + outpos - 1]; + out[28 + outpos] = (((in[6 + inpos] >>> 4) & 127)) + + out[28 + outpos - 1]; + out[29 + outpos] = (((in[6 + inpos] >>> 11) & 127)) + + out[29 + outpos - 1]; + out[30 + outpos] = (((in[6 + inpos] >>> 18) & 127)) + + out[30 + outpos - 1]; + out[31 + outpos] = ((in[6 + inpos] >>> 25)) + + out[31 + outpos - 1]; + } + + protected static void integratedunpack8(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + out[0 + outpos] = (((in[0 + inpos] >>> 0) & 255)) + initoffset; + out[1 + outpos] = (((in[0 + inpos] >>> 8) & 255)) + + out[1 + outpos - 1]; + out[2 + outpos] = (((in[0 + inpos] >>> 16) & 255)) + + out[2 + outpos - 1]; + out[3 + outpos] = ((in[0 + inpos] >>> 24)) + + out[3 + outpos - 1]; + out[4 + outpos] = (((in[1 + inpos] >>> 0) & 255)) + + out[4 + outpos - 1]; + out[5 + outpos] = (((in[1 + inpos] >>> 8) & 255)) + + out[5 + outpos - 1]; + out[6 + outpos] = (((in[1 + inpos] >>> 16) & 255)) + + out[6 + outpos - 1]; + out[7 + outpos] = ((in[1 + inpos] >>> 24)) + + out[7 + outpos - 1]; + out[8 + outpos] = (((in[2 + inpos] >>> 0) & 255)) + + out[8 + outpos - 1]; + out[9 + outpos] = (((in[2 + inpos] >>> 8) & 255)) + + out[9 + outpos - 1]; + out[10 + outpos] = (((in[2 + inpos] >>> 16) & 255)) + + out[10 + outpos - 1]; + out[11 + outpos] = ((in[2 + inpos] >>> 24)) + + out[11 + outpos - 1]; + out[12 + outpos] = (((in[3 + inpos] >>> 0) & 255)) + + out[12 + outpos - 1]; + out[13 + outpos] = (((in[3 + inpos] >>> 8) & 255)) + + out[13 + outpos - 1]; + out[14 + outpos] = (((in[3 + inpos] >>> 16) & 255)) + + out[14 + outpos - 1]; + out[15 + outpos] = ((in[3 + inpos] >>> 24)) + + out[15 + outpos - 1]; + out[16 + outpos] = (((in[4 + inpos] >>> 0) & 255)) + + out[16 + outpos - 1]; + out[17 + outpos] = (((in[4 + inpos] >>> 8) & 255)) + + out[17 + outpos - 1]; + out[18 + outpos] = (((in[4 + inpos] >>> 16) & 255)) + + out[18 + outpos - 1]; + out[19 + outpos] = ((in[4 + inpos] >>> 24)) + + out[19 + outpos - 1]; + out[20 + outpos] = (((in[5 + inpos] >>> 0) & 255)) + + out[20 + outpos - 1]; + out[21 + outpos] = (((in[5 + inpos] >>> 8) & 255)) + + out[21 + outpos - 1]; + out[22 + outpos] = (((in[5 + inpos] >>> 16) & 255)) + + out[22 + outpos - 1]; + out[23 + outpos] = ((in[5 + inpos] >>> 24)) + + out[23 + outpos - 1]; + out[24 + outpos] = (((in[6 + inpos] >>> 0) & 255)) + + out[24 + outpos - 1]; + out[25 + outpos] = (((in[6 + inpos] >>> 8) & 255)) + + out[25 + outpos - 1]; + out[26 + outpos] = (((in[6 + inpos] >>> 16) & 255)) + + out[26 + outpos - 1]; + out[27 + outpos] = ((in[6 + inpos] >>> 24)) + + out[27 + outpos - 1]; + out[28 + outpos] = (((in[7 + inpos] >>> 0) & 255)) + + out[28 + outpos - 1]; + out[29 + outpos] = (((in[7 + inpos] >>> 8) & 255)) + + out[29 + outpos - 1]; + out[30 + outpos] = (((in[7 + inpos] >>> 16) & 255)) + + out[30 + outpos - 1]; + out[31 + outpos] = ((in[7 + inpos] >>> 24)) + + out[31 + outpos - 1]; + } + + protected static void integratedunpack9(final int initoffset, + final int[] in, int inpos, final int[] out, int outpos) { + out[0 + outpos] = (((in[0 + inpos] >>> 0) & 511)) + initoffset; + out[1 + outpos] = (((in[0 + inpos] >>> 9) & 511)) + + out[1 + outpos - 1]; + out[2 + outpos] = (((in[0 + inpos] >>> 18) & 511)) + + out[2 + outpos - 1]; + out[3 + outpos] = ((in[0 + inpos] >>> 27) | ((in[1 + inpos] & 15) << (9 - 4))) + + out[3 + outpos - 1]; + out[4 + outpos] = (((in[1 + inpos] >>> 4) & 511)) + + out[4 + outpos - 1]; + out[5 + outpos] = (((in[1 + inpos] >>> 13) & 511)) + + out[5 + outpos - 1]; + out[6 + outpos] = (((in[1 + inpos] >>> 22) & 511)) + + out[6 + outpos - 1]; + out[7 + outpos] = ((in[1 + inpos] >>> 31) | ((in[2 + inpos] & 255) << (9 - 8))) + + out[7 + outpos - 1]; + out[8 + outpos] = (((in[2 + inpos] >>> 8) & 511)) + + out[8 + outpos - 1]; + out[9 + outpos] = (((in[2 + inpos] >>> 17) & 511)) + + out[9 + outpos - 1]; + out[10 + outpos] = ((in[2 + inpos] >>> 26) | ((in[3 + inpos] & 7) << (9 - 3))) + + out[10 + outpos - 1]; + out[11 + outpos] = (((in[3 + inpos] >>> 3) & 511)) + + out[11 + outpos - 1]; + out[12 + outpos] = (((in[3 + inpos] >>> 12) & 511)) + + out[12 + outpos - 1]; + out[13 + outpos] = (((in[3 + inpos] >>> 21) & 511)) + + out[13 + outpos - 1]; + out[14 + outpos] = ((in[3 + inpos] >>> 30) | ((in[4 + inpos] & 127) << (9 - 7))) + + out[14 + outpos - 1]; + out[15 + outpos] = (((in[4 + inpos] >>> 7) & 511)) + + out[15 + outpos - 1]; + out[16 + outpos] = (((in[4 + inpos] >>> 16) & 511)) + + out[16 + outpos - 1]; + out[17 + outpos] = ((in[4 + inpos] >>> 25) | ((in[5 + inpos] & 3) << (9 - 2))) + + out[17 + outpos - 1]; + out[18 + outpos] = (((in[5 + inpos] >>> 2) & 511)) + + out[18 + outpos - 1]; + out[19 + outpos] = (((in[5 + inpos] >>> 11) & 511)) + + out[19 + outpos - 1]; + out[20 + outpos] = (((in[5 + inpos] >>> 20) & 511)) + + out[20 + outpos - 1]; + out[21 + outpos] = ((in[5 + inpos] >>> 29) | ((in[6 + inpos] & 63) << (9 - 6))) + + out[21 + outpos - 1]; + out[22 + outpos] = (((in[6 + inpos] >>> 6) & 511)) + + out[22 + outpos - 1]; + out[23 + outpos] = (((in[6 + inpos] >>> 15) & 511)) + + out[23 + outpos - 1]; + out[24 + outpos] = ((in[6 + inpos] >>> 24) | ((in[7 + inpos] & 1) << (9 - 1))) + + out[24 + outpos - 1]; + out[25 + outpos] = (((in[7 + inpos] >>> 1) & 511)) + + out[25 + outpos - 1]; + out[26 + outpos] = (((in[7 + inpos] >>> 10) & 511)) + + out[26 + outpos - 1]; + out[27 + outpos] = (((in[7 + inpos] >>> 19) & 511)) + + out[27 + outpos - 1]; + out[28 + outpos] = ((in[7 + inpos] >>> 28) | ((in[8 + inpos] & 31) << (9 - 5))) + + out[28 + outpos - 1]; + out[29 + outpos] = (((in[8 + inpos] >>> 5) & 511)) + + out[29 + outpos - 1]; + out[30 + outpos] = (((in[8 + inpos] >>> 14) & 511)) + + out[30 + outpos - 1]; + out[31 + outpos] = ((in[8 + inpos] >>> 23)) + + out[31 + outpos - 1]; + } + +} diff --git a/src/main/java/me/lemire/integercompression/differential/IntegratedByteIntegerCODEC.java b/src/main/java/me/lemire/integercompression/differential/IntegratedByteIntegerCODEC.java new file mode 100644 index 0000000..b0184b8 --- /dev/null +++ b/src/main/java/me/lemire/integercompression/differential/IntegratedByteIntegerCODEC.java @@ -0,0 +1,21 @@ +/** + * This code is released under the + * Apache License Version 2.0 http://www.apache.org/licenses/. + * + * (c) Daniel Lemire, http://lemire.me/en/ + */ + +package me.lemire.integercompression.differential; + +import me.lemire.integercompression.ByteIntegerCODEC; + +/** + * Interface describing a CODEC to compress integers to bytes. + * + * "Integrated" means that it uses differential coding. + * + * @author Daniel Lemire + * + */ +public interface IntegratedByteIntegerCODEC extends ByteIntegerCODEC { +} \ No newline at end of file diff --git a/src/main/java/me/lemire/integercompression/differential/IntegratedComposition.java b/src/main/java/me/lemire/integercompression/differential/IntegratedComposition.java new file mode 100644 index 0000000..dd4257e --- /dev/null +++ b/src/main/java/me/lemire/integercompression/differential/IntegratedComposition.java @@ -0,0 +1,73 @@ +/** + * This code is released under the + * Apache License Version 2.0 http://www.apache.org/licenses/. + * + * (c) Daniel Lemire, http://lemire.me/en/ + */ +package me.lemire.integercompression.differential; + +import me.lemire.integercompression.IntWrapper; + +/** + * Helper class to compose schemes. + * + * @author Daniel Lemire + */ +public class IntegratedComposition implements IntegratedIntegerCODEC { + IntegratedIntegerCODEC F1, F2; + + /** + * Compose a scheme from a first one (f1) and a second one (f2). The + * first one is called first and then the second one tries to compress + * whatever remains from the first run. + * + * By convention, the first scheme should be such that if, during + * decoding, a 32-bit zero is first encountered, then there is no + * output. + * + * @param f1 + * first codec + * @param f2 + * second codec + */ + public IntegratedComposition(IntegratedIntegerCODEC f1, + IntegratedIntegerCODEC f2) { + F1 = f1; + F2 = f2; + } + + + @Override + public void compress(int[] in, IntWrapper inpos, int inlength, + int[] out, IntWrapper outpos) { + if (inlength == 0) { + return; + } + int inposInit = inpos.get(); + int outposInit = outpos.get(); + F1.compress(in, inpos, inlength, out, outpos); + if (outpos.get() == outposInit) { + out[outposInit] = 0; + outpos.increment(); + } + inlength -= inpos.get() - inposInit; + F2.compress(in, inpos, inlength, out, outpos); + } + + @Override + public void uncompress(int[] in, IntWrapper inpos, int inlength, + int[] out, IntWrapper outpos) { + if (inlength == 0) + return; + int init = inpos.get(); + F1.uncompress(in, inpos, inlength, out, outpos); + inlength -= inpos.get() - init; + F2.uncompress(in, inpos, inlength, out, outpos); + } + + @Override + public String toString() { + return F1.toString() + " + " + F2.toString(); + } + +} diff --git a/src/main/java/me/lemire/integercompression/differential/IntegratedIntCompressor.java b/src/main/java/me/lemire/integercompression/differential/IntegratedIntCompressor.java new file mode 100644 index 0000000..1d935c4 --- /dev/null +++ b/src/main/java/me/lemire/integercompression/differential/IntegratedIntCompressor.java @@ -0,0 +1,66 @@ +package me.lemire.integercompression.differential; + +import java.util.Arrays; + +import me.lemire.integercompression.IntWrapper; + +/** + * This is a convenience class that wraps a codec to provide + * a "friendly" API. It is useful to compress sorted integers. + * If your integers are not sorted (not even nearly so), please + * consider the IntCompressor class instead. + * + */ +public class IntegratedIntCompressor { + SkippableIntegratedIntegerCODEC codec; + /** + * Constructor wrapping a codec. + * + * @param c the underlying codec + */ + public IntegratedIntCompressor(SkippableIntegratedIntegerCODEC c) { + codec = c; + } + + /** + * Constructor with default codec. + */ + public IntegratedIntCompressor() { + codec = new SkippableIntegratedComposition(new IntegratedBinaryPacking(), + new IntegratedVariableByte()); + } + + /** + * Compress an array and returns the compressed result as a new array. + * + * @param input array to be compressed + * @return compressed array + */ + public int[] compress(int[] input) { + int maxCompressedLength = codec.maxHeadlessCompressedLength(new IntWrapper(0), input.length); + int [] compressed = new int[maxCompressedLength + 1]; // +1 to store the length of the input + compressed[0] = input.length; + IntWrapper outpos = new IntWrapper(1); + IntWrapper initvalue = new IntWrapper(0); + codec.headlessCompress(input, new IntWrapper(0), input.length, compressed, outpos, initvalue); + compressed = Arrays.copyOf(compressed,outpos.intValue()); + return compressed; + } + + /** + * Uncompress an array and returns the uncompressed result as a new array. + * + * @param compressed compressed array + * @return uncompressed array + */ + public int[] uncompress(int[] compressed) { + int[] decompressed = new int[compressed[0]]; + IntWrapper inpos = new IntWrapper(1); + codec.headlessUncompress(compressed, inpos, + compressed.length - inpos.intValue(), + decompressed, new IntWrapper(0), + decompressed.length, new IntWrapper(0)); + return decompressed; + } + +} diff --git a/src/main/java/me/lemire/integercompression/differential/IntegratedIntegerCODEC.java b/src/main/java/me/lemire/integercompression/differential/IntegratedIntegerCODEC.java new file mode 100644 index 0000000..4c03d29 --- /dev/null +++ b/src/main/java/me/lemire/integercompression/differential/IntegratedIntegerCODEC.java @@ -0,0 +1,19 @@ +/** + * This code is released under the + * Apache License Version 2.0 http://www.apache.org/licenses/. + * + * (c) Daniel Lemire, http://lemire.me/en/ + */ +package me.lemire.integercompression.differential; + +import me.lemire.integercompression.IntegerCODEC; + +/** + * This is just like IntegerCODEC, except that it indicates that delta coding is + * "integrated", so that you don't need a separate step for delta coding. + * + * @author Daniel Lemire + */ +public interface IntegratedIntegerCODEC extends IntegerCODEC { + +} diff --git a/src/main/java/me/lemire/integercompression/differential/IntegratedVariableByte.java b/src/main/java/me/lemire/integercompression/differential/IntegratedVariableByte.java new file mode 100644 index 0000000..a577031 --- /dev/null +++ b/src/main/java/me/lemire/integercompression/differential/IntegratedVariableByte.java @@ -0,0 +1,280 @@ +/** + * This code is released under the + * Apache License Version 2.0 http://www.apache.org/licenses/. + * + * (c) Daniel Lemire, http://lemire.me/en/ + */ +package me.lemire.integercompression.differential; + +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.nio.IntBuffer; + +import me.lemire.integercompression.IntWrapper; + +/** + * Implementation of variable-byte with differential coding. For best + * performance, use it using the IntegratedByteIntegerCODEC interface. + * + * You should only use this scheme on sorted arrays. Use VariableByte if you + * have unsorted arrays. + * + * @author Daniel Lemire + */ +public class IntegratedVariableByte implements IntegratedIntegerCODEC, IntegratedByteIntegerCODEC, +SkippableIntegratedIntegerCODEC { + + private static final int MAX_BYTES_PER_INT = 5; + + private static byte extract7bits(int i, long val) { + return (byte)((val >> (7 * i)) & ((1 << 7) - 1)); + } + + private static byte extract7bitsmaskless(int i, long val) { + return (byte)((val >> (7 * i))); + } + + @Override + public void compress(int[] in, IntWrapper inpos, int inlength, + int[] out, IntWrapper outpos) { + if (inlength == 0) + return; + int initoffset = 0; + ByteBuffer buf = makeBuffer(inlength * 8); + buf.order(ByteOrder.LITTLE_ENDIAN); + for (int k = inpos.get(); k < inpos.get() + inlength; ++k) { + final long val = (in[k] - initoffset) & 0xFFFFFFFFL; // To be consistent with unsigned integers in C/C++ + initoffset = in[k]; + if (val < (1 << 7)) { + buf.put((byte)(val | (1 << 7))); + } else if (val < (1 << 14)) { + buf.put((byte)extract7bits(0, val)); + buf.put((byte)(extract7bitsmaskless(1, (val)) | (1 << 7))); + } else if (val < (1 << 21)) { + buf.put((byte)extract7bits(0, val)); + buf.put((byte)extract7bits(1, val)); + buf.put((byte)(extract7bitsmaskless(2, (val)) | (1 << 7))); + } else if (val < (1 << 28)) { + buf.put((byte)extract7bits(0, val)); + buf.put((byte)extract7bits(1, val)); + buf.put((byte)extract7bits(2, val)); + buf.put((byte)(extract7bitsmaskless(3, (val)) | (1 << 7))); + } else { + buf.put((byte)extract7bits(0, val)); + buf.put((byte)extract7bits(1, val)); + buf.put((byte)extract7bits(2, val)); + buf.put((byte)extract7bits(3, val)); + buf.put((byte)(extract7bitsmaskless(4, (val)) | (1 << 7))); + } + } + while (buf.position() % 4 != 0) + buf.put((byte) 0); + final int length = buf.position(); + buf.flip(); + IntBuffer ibuf = buf.asIntBuffer(); + ibuf.get(out, outpos.get(), length / 4); + outpos.add(length / 4); + inpos.add(inlength); + } + + @Override + public void compress(int[] in, IntWrapper inpos, int inlength, + byte[] out, IntWrapper outpos) { + if (inlength == 0) + return; + int initoffset = 0; + int outpostmp = outpos.get(); + for (int k = inpos.get(); k < inpos.get() + inlength; ++k) { + final long val = (in[k] - initoffset) & 0xFFFFFFFFL; // To be consistent with unsigned integers in C/C++ + initoffset = in[k]; + if (val < (1 << 7)) { + out[outpostmp++] = (byte)(val | (1 << 7)); + } else if (val < (1 << 14)) { + out[outpostmp++] = (byte)extract7bits(0, val); + out[outpostmp++] = (byte)(extract7bitsmaskless(1, (val)) | (1 << 7)); + } else if (val < (1 << 21)) { + out[outpostmp++] = (byte)extract7bits(0, val); + out[outpostmp++] = (byte)extract7bits(1, val); + out[outpostmp++] = (byte)(extract7bitsmaskless(2, (val)) | (1 << 7)); + } else if (val < (1 << 28)) { + out[outpostmp++] = (byte)extract7bits(0, val); + out[outpostmp++] = (byte)extract7bits(1, val); + out[outpostmp++] = (byte)extract7bits(2, val); + out[outpostmp++] = (byte)(extract7bitsmaskless(3, (val)) | (1 << 7)); + } else { + out[outpostmp++] = (byte)extract7bits(0, val); + out[outpostmp++] = (byte)extract7bits(1, val); + out[outpostmp++] = (byte)extract7bits(2, val); + out[outpostmp++] = (byte)extract7bits(3, val); + out[outpostmp++] = (byte)(extract7bitsmaskless(4, (val)) | (1 << 7)); + } + } + outpos.set(outpostmp); + inpos.add(inlength); + } + + @Override + public void uncompress(int[] in, IntWrapper inpos, int inlength, + int[] out, IntWrapper outpos) { + int s = 0; + int val = 0; + int p = inpos.get(); + int finalp = inpos.get() + inlength; + int tmpoutpos = outpos.get(); + int initoffset = 0; + for (int v = 0, shift =0; p < finalp;) { + val = in[p]; + int c = (byte) (val >>> s); + s += 8; + p += s>>5; + s = s & 31; + v += ((c & 127) << shift); + if ((c & 128) == 128) { + out[tmpoutpos] = v + initoffset; + initoffset = out[tmpoutpos]; + tmpoutpos++; + v = 0; + shift = 0; + } else + shift +=7; + } + outpos.set(tmpoutpos); + inpos.add(inlength); + } + + @Override + public void uncompress(byte[] in, IntWrapper inpos, int inlength, + int[] out, IntWrapper outpos) { + int p = inpos.get(); + int initoffset = 0; + int finalp = inpos.get() + inlength; + int tmpoutpos = outpos.get(); + for (int v = 0;p < finalp; out[tmpoutpos++] = (initoffset = initoffset + v)) { + v = in[p] & 0x7F; + if (in[p] < 0 ) { + p+= 1; + continue; + } + v = ((in[p+1] & 0x7F)<<7) | v; + if (in[p+1] < 0) { + p+= 2; + continue; + } + v = ((in[p+2] & 0x7F)<<14) | v; + if (in[p+2] < 0) { + p+= 3; + continue; + } + v = ((in[p+3] & 0x7F)<<21) | v; + if (in[p+3] < 0) { + p+= 4; + continue; + } + v = ((in[p+4] & 0x7F)<<28) | v; + p+= 5; + } + outpos.set(tmpoutpos); + inpos.add(p); + } + + @Override + public String toString() { + return this.getClass().getSimpleName(); + } + + @Override + public void headlessCompress(int[] in, IntWrapper inpos, int inlength, + int[] out, IntWrapper outpos, IntWrapper initvalue) { + if (inlength == 0) + return; + int initoffset = initvalue.get(); + initvalue.set(in[inpos.get()+inlength -1]); + ByteBuffer buf = makeBuffer(inlength * 8); + buf.order(ByteOrder.LITTLE_ENDIAN); + for (int k = inpos.get(); k < inpos.get() + inlength; ++k) { + final long val = (in[k] - initoffset) & 0xFFFFFFFFL; // To be consistent with unsigned integers in C/C++ + initoffset = in[k]; + if (val < (1 << 7)) { + buf.put((byte) (val | (1 << 7))); + } else if (val < (1 << 14)) { + buf.put((byte) extract7bits(0, val)); + buf.put((byte) (extract7bitsmaskless(1, (val)) | (1 << 7))); + } else if (val < (1 << 21)) { + buf.put((byte) extract7bits(0, val)); + buf.put((byte) extract7bits(1, val)); + buf.put((byte) (extract7bitsmaskless(2, (val)) | (1 << 7))); + } else if (val < (1 << 28)) { + buf.put((byte) extract7bits(0, val)); + buf.put((byte) extract7bits(1, val)); + buf.put((byte) extract7bits(2, val)); + buf.put((byte) (extract7bitsmaskless(3, (val)) | (1 << 7))); + } else { + buf.put((byte) extract7bits(0, val)); + buf.put((byte) extract7bits(1, val)); + buf.put((byte) extract7bits(2, val)); + buf.put((byte) extract7bits(3, val)); + buf.put((byte) (extract7bitsmaskless(4, (val)) | (1 << 7))); + } + } + while (buf.position() % 4 != 0) + buf.put((byte) 0); + final int length = buf.position(); + buf.flip(); + IntBuffer ibuf = buf.asIntBuffer(); + ibuf.get(out, outpos.get(), length / 4); + outpos.add(length / 4); + inpos.add(inlength); + } + + @Override + public void headlessUncompress(int[] in, IntWrapper inpos, int inlength, + int[] out, IntWrapper outpos, int num, IntWrapper initvalue) { + int s = 0; + int val = 0; + + int p = inpos.get(); + int initoffset = initvalue.get(); + int tmpoutpos = outpos.get(); + int finaloutpos = num + tmpoutpos; + for (int v = 0, shift = 0; tmpoutpos < finaloutpos;) { + + val = in[p]; + int c = (byte) (val >>> s); + s += 8; + p += s>>5; + s = s & 31; + v += ((c & 127) << shift); + + if ((c & 128) == 128) { + + out[tmpoutpos++] = (initoffset = initoffset + v); + v = 0; + shift = 0; + } else + shift += 7; + } + initvalue.set(out[tmpoutpos-1]); + outpos.set(tmpoutpos); + + inpos.set(p + (s!=0 ? 1 : 0)); + } + + @Override + public int maxHeadlessCompressedLength(IntWrapper compressedPositions, int inlength) { + int maxLengthInBytes = inlength * MAX_BYTES_PER_INT; + int maxLengthInInts = (maxLengthInBytes + Integer.BYTES - 1) / Integer.BYTES; + compressedPositions.add(inlength); + return maxLengthInInts; + } + + /** + * Creates a new buffer of the requested size. + * + * In case you need a different way to allocate buffers, you can override this method + * with a custom behavior. The default implementation allocates a new Java direct + * {@link ByteBuffer} on each invocation. + */ + protected ByteBuffer makeBuffer(int sizeInBytes) { + return ByteBuffer.allocateDirect(sizeInBytes); + } +} diff --git a/src/main/java/me/lemire/integercompression/differential/SkippableIntegratedComposition.java b/src/main/java/me/lemire/integercompression/differential/SkippableIntegratedComposition.java new file mode 100644 index 0000000..4786ec5 --- /dev/null +++ b/src/main/java/me/lemire/integercompression/differential/SkippableIntegratedComposition.java @@ -0,0 +1,90 @@ +/** + * This code is released under the + * Apache License Version 2.0 http://www.apache.org/licenses/. + * + * (c) Daniel Lemire, http://lemire.me/en/ + */ +package me.lemire.integercompression.differential; + +import me.lemire.integercompression.IntWrapper; + +/** + * Helper class to compose schemes. + * + * @author Daniel Lemire + */ +public class SkippableIntegratedComposition implements + SkippableIntegratedIntegerCODEC { + SkippableIntegratedIntegerCODEC F1, F2; + + /** + * Compose a scheme from a first one (f1) and a second one (f2). The first + * one is called first and then the second one tries to compress whatever + * remains from the first run. + * + * By convention, the first scheme should be such that if, during decoding, + * a 32-bit zero is first encountered, then there is no output. + * + * @param f1 + * first codec + * @param f2 + * second codec + */ + public SkippableIntegratedComposition(SkippableIntegratedIntegerCODEC f1, + SkippableIntegratedIntegerCODEC f2) { + F1 = f1; + F2 = f2; + } + + + + @Override + public String toString() { + return F1.toString() + " + " + F2.toString(); + } + + @Override + public void headlessCompress(int[] in, IntWrapper inpos, int inlength, + int[] out, IntWrapper outpos, IntWrapper initvalue) { + if (inlength == 0) + return; + final int init = inpos.get(); + int outposInit = outpos.get(); + + F1.headlessCompress(in, inpos, inlength, out, outpos, initvalue); + if (outpos.get() == outposInit) { + out[outposInit] = 0; + outpos.increment(); + } + inlength -= inpos.get() - init; + F2.headlessCompress(in, inpos, inlength, out, outpos, initvalue); + } + + @Override + public void headlessUncompress(int[] in, IntWrapper inpos, int inlength, + int[] out, IntWrapper outpos, int num, IntWrapper initvalue) { + if (inlength == 0) + return; + int init = inpos.get(); + int outposInit = outpos.get(); + + F1.headlessUncompress(in, inpos, inlength, out, outpos,num,initvalue); + if (inpos.get() == init) { + inpos.increment(); + } + inlength -= inpos.get() - init; + + num -= outpos.get() - outposInit; + F2.headlessUncompress(in, inpos, inlength, out, outpos,num,initvalue); + } + + @Override + public int maxHeadlessCompressedLength(IntWrapper compressedPositions, int inlength) { + int init = compressedPositions.get(); + int maxLength = F1.maxHeadlessCompressedLength(compressedPositions, inlength); + maxLength += 1; // Add +1 for the potential F2 header. Question: is this header actually needed in the headless version? + inlength -= compressedPositions.get() - init; + maxLength += F2.maxHeadlessCompressedLength(compressedPositions, inlength); + return maxLength; + } +} diff --git a/src/main/java/me/lemire/integercompression/differential/SkippableIntegratedIntegerCODEC.java b/src/main/java/me/lemire/integercompression/differential/SkippableIntegratedIntegerCODEC.java new file mode 100644 index 0000000..e2df754 --- /dev/null +++ b/src/main/java/me/lemire/integercompression/differential/SkippableIntegratedIntegerCODEC.java @@ -0,0 +1,91 @@ +/** + * This is code is released under the + * Apache License Version 2.0 http://www.apache.org/licenses/. + * + * (c) Daniel Lemire, http://lemire.me/en/ + */ + +package me.lemire.integercompression.differential; + +import me.lemire.integercompression.IntWrapper; + + +/** + * Interface describing a standard CODEC to compress integers. This is a + * variation on the IntegerCODEC interface meant to be used for random access + * and with integrated differential coding + * (i.e., given a large array, you can segment it and decode just the subarray you need). + * + * The main differences are that we must specify the number of integers we wish to + * decode as well as the initial value (for differential coding). This information + * might be stored elsewhere. + * + * + * @author Daniel Lemire + * + */ +public interface SkippableIntegratedIntegerCODEC { + /** + * Compress data from an array to another array. + * + * Both inpos and outpos are modified to represent how much data was read + * and written to if 12 ints (inlength = 12) are compressed to 3 ints, then + * inpos will be incremented by 12 while outpos will be incremented by 3 we + * use IntWrapper to pass the values by reference. + * + * @param in + * input array + * @param inpos + * location in the input array + * @param inlength + * how many integers to compress + * @param out + * output array + * @param outpos + * where to write in the output array + * @param initvalue initial value for the purpose of differential coding, the value is automatically updated + */ + public void headlessCompress(int[] in, IntWrapper inpos, int inlength, int[] out, + IntWrapper outpos, IntWrapper initvalue); + + /** + * Uncompress data from an array to another array. + * + * Both inpos and outpos parameters are modified to indicate new positions + * after read/write. + * + * @param in + * array containing data in compressed form + * @param inpos + * where to start reading in the array + * @param inlength + * length of the compressed data (ignored by some schemes) + * @param out + * array where to write the compressed output + * @param outpos + * where to write the compressed output in out + * @param num + * number of integers we want to decode, the actual number of integers decoded can be less + * @param initvalue initial value for the purpose of differential coding, the value is automatically updated + */ + public void headlessUncompress(int[] in, IntWrapper inpos, int inlength, int[] out, + IntWrapper outpos, int num, IntWrapper initvalue); + + /** + * Compute the maximum number of integers that might be required to store + * the compressed form of a given input array segment, without headers. + *

+ * This is useful to pre-allocate the output buffer before calling + * {@link #headlessCompress(int[], IntWrapper, int, int[], IntWrapper, IntWrapper)}. + *

+ * + * @param compressedPositions + * since not all schemes compress every input integer, this parameter + * returns how many input integers will actually be compressed. + * This is useful when composing multiple schemes. + * @param inlength + * number of integers to be compressed + * @return the maximum number of integers needed in the output array + */ + int maxHeadlessCompressedLength(IntWrapper compressedPositions, int inlength); +} diff --git a/src/main/java/me/lemire/integercompression/differential/XorBinaryPacking.java b/src/main/java/me/lemire/integercompression/differential/XorBinaryPacking.java new file mode 100644 index 0000000..0e2b067 --- /dev/null +++ b/src/main/java/me/lemire/integercompression/differential/XorBinaryPacking.java @@ -0,0 +1,139 @@ +/** + * This code is released under the + * Apache License Version 2.0 http://www.apache.org/licenses/. + */ +package me.lemire.integercompression.differential; + +import me.lemire.integercompression.BitPacking; +import me.lemire.integercompression.IntWrapper; + +/** + * BinaryPacking over XOR differential. + * + *
IntegratedIntegerCODEC is = 
+ * new Composition(new XorBinaryPacking(), new VariableByte())
+ * + * @author MURAOKA Taro http://github.com/koron + */ +public final class XorBinaryPacking implements IntegratedIntegerCODEC { + + private static final int BLOCK_LENGTH = 128; + + @Override + public void compress(final int[] inBuf, final IntWrapper inPos, + int inLen, final int[] outBuf, final IntWrapper outPos) { + inLen = inLen - inLen % BLOCK_LENGTH; + if (inLen == 0) + return; + + outBuf[outPos.get()] = inLen; + outPos.increment(); + + int context = 0; + final int[] work = new int[32]; + + int op = outPos.get(); + int ip = inPos.get(); + final int inPosLast = ip + inLen; + for (; ip < inPosLast; ip += BLOCK_LENGTH) { + final int bits1 = xorMaxBits(inBuf, ip + 0, 32, context); + final int bits2 = xorMaxBits(inBuf, ip + 32, 32, + inBuf[ip + 31]); + final int bits3 = xorMaxBits(inBuf, ip + 64, 32, + inBuf[ip + 63]); + final int bits4 = xorMaxBits(inBuf, ip + 96, 32, + inBuf[ip + 95]); + outBuf[op++] = (bits1 << 24) | (bits2 << 16) + | (bits3 << 8) | (bits4 << 0); + op += xorPack(inBuf, ip + 0, outBuf, op, bits1, + context, work); + op += xorPack(inBuf, ip + 32, outBuf, op, bits2, + inBuf[ip + 31], work); + op += xorPack(inBuf, ip + 64, outBuf, op, bits3, + inBuf[ip + 63], work); + op += xorPack(inBuf, ip + 96, outBuf, op, bits4, + inBuf[ip + 95], work); + context = inBuf[ip + 127]; + } + + inPos.add(inLen); + outPos.set(op); + } + + @Override + public void uncompress(int[] inBuf, IntWrapper inPos, int inLen, + int[] outBuf, IntWrapper outPos) { + if (inLen == 0) + return; + + final int outLen = inBuf[inPos.get()]; + inPos.increment(); + + int context = 0; + final int[] work = new int[32]; + + int ip = inPos.get(); + int op = outPos.get(); + final int outPosLast = op + outLen; + for (; op < outPosLast; op += BLOCK_LENGTH) { + final int bits1 = (inBuf[ip] >>> 24); + final int bits2 = (inBuf[ip] >>> 16) & 0xFF; + final int bits3 = (inBuf[ip] >>> 8) & 0xFF; + final int bits4 = (inBuf[ip] >>> 0) & 0xFF; + ++ip; + ip += xorUnpack(inBuf, ip, outBuf, op + 0, bits1, + context, work); + ip += xorUnpack(inBuf, ip, outBuf, op + 32, bits2, + outBuf[op + 31], work); + ip += xorUnpack(inBuf, ip, outBuf, op + 64, bits3, + outBuf[op + 63], work); + ip += xorUnpack(inBuf, ip, outBuf, op + 96, bits4, + outBuf[op + 95], work); + context = outBuf[op + 127]; + } + + outPos.add(outLen); + inPos.set(ip); + } + + @Override + public String toString() { + return this.getClass().getSimpleName(); + } + + private static int xorMaxBits(final int[] buf, final int offset, + final int length, final int context) { + int mask = buf[offset] ^ context; + final int M = offset + length; + for (int i = offset + 1, prev = offset; i < M; ++i, ++prev) { + mask |= buf[i] ^ buf[prev]; + } + + return 32 - Integer.numberOfLeadingZeros(mask); + } + + private static int xorPack(final int[] inBuf, final int inOff, + final int[] outBuf, final int outOff, final int validBits, + final int context, final int[] work) { + work[0] = inBuf[inOff] ^ context; + for (int i = 1, p = inOff + 1; i < 32; ++i, ++p) { + work[i] = inBuf[p] ^ inBuf[p - 1]; + } + BitPacking.fastpackwithoutmask(work, 0, outBuf, outOff, + validBits); + + return validBits; + } + + private static int xorUnpack(final int[] inBuf, final int inOff, + final int[] outBuf, final int outOff, final int validBits, + int context, final int[] work) { + + BitPacking.fastunpack(inBuf, inOff, work, 0, validBits); + outBuf[outOff] = context = work[0] ^ context; + for (int i = 1, p = outOff + 1; i < 32; ++i, ++p) { + outBuf[p] = context = work[i] ^ context; + } + return validBits; + } +} diff --git a/src/main/java/me/lemire/integercompression/synth/ClusteredDataGenerator.java b/src/main/java/me/lemire/integercompression/synth/ClusteredDataGenerator.java index c1293a5..12bf550 100644 --- a/src/main/java/me/lemire/integercompression/synth/ClusteredDataGenerator.java +++ b/src/main/java/me/lemire/integercompression/synth/ClusteredDataGenerator.java @@ -7,66 +7,82 @@ package me.lemire.integercompression.synth; /** - * This class will generate lists of random integers based on the clustered model: + * This class will generate lists of random integers based on the clustered + * model: * - * Reference: - * Vo Ngoc Anh and Alistair Moffat. 2010. Index compression using 64-bit words. - * Softw. Pract. Exper.40, 2 (February 2010), 131-147. + * Reference: Vo Ngoc Anh and Alistair Moffat. 2010. Index compression using + * 64-bit words. Softw. Pract. Exper.40, 2 (February 2010), 131-147. * * @author Daniel Lemire */ public class ClusteredDataGenerator { - UniformDataGenerator unidg = new UniformDataGenerator(); + UniformDataGenerator unidg = new UniformDataGenerator(); - public ClusteredDataGenerator() { - } - - void fillUniform(int[] array, int offset, int length, int Min, int Max) { - int[] v = this.unidg.generateUniform(length, Max - Min); - for (int k = 0; k < v.length; ++k) - array[k + offset] = Min + v[k]; - } + /** + * Creating random array generator. + */ + public ClusteredDataGenerator() { + } - void fillClustered(int[] array, int offset, int length, int Min, int Max) { - final int range = Max - Min; - if ((range == length) || (length <= 10)) { - fillUniform(array, offset, length, Min, Max); - return; + void fillUniform(int[] array, int offset, int length, int Min, int Max) { + int[] v = this.unidg.generateUniform(length, Max - Min); + for (int k = 0; k < v.length; ++k) + array[k + offset] = Min + v[k]; } - final int cut = length - / 2 - + ((range - length - 1 > 0) ? this.unidg.rand.nextInt(range - length - 1) - : 0); - final double p = this.unidg.rand.nextDouble(); - if (p < 0.25) { - fillUniform(array, offset, length / 2, Min, Min + cut); - fillClustered(array, offset + length / 2, length - length / 2, Min + cut, - Max); - } else if (p < 0.5) { - fillClustered(array, offset, length / 2, Min, Min + cut); - fillUniform(array, offset + length / 2, length - length / 2, Min + cut, - Max); - } else { - fillClustered(array, offset, length / 2, Min, Min + cut); - fillClustered(array, offset + length / 2, length - length / 2, Min + cut, - Max); + + void fillClustered(int[] array, int offset, int length, int Min, int Max) { + final int range = Max - Min; + if ((range == length) || (length <= 10)) { + fillUniform(array, offset, length, Min, Max); + return; + } + final int cut = length + / 2 + + ((range - length - 1 > 0) ? this.unidg.rand + .nextInt(range - length - 1) : 0); + final double p = this.unidg.rand.nextDouble(); + if (p < 0.25) { + fillUniform(array, offset, length / 2, Min, Min + cut); + fillClustered(array, offset + length / 2, length + - length / 2, Min + cut, Max); + } else if (p < 0.5) { + fillClustered(array, offset, length / 2, Min, Min + cut); + fillUniform(array, offset + length / 2, length - length + / 2, Min + cut, Max); + } else { + fillClustered(array, offset, length / 2, Min, Min + cut); + fillClustered(array, offset + length / 2, length + - length / 2, Min + cut, Max); + } } - } - /** - * generates randomly N distinct integers from 0 to Max. - */ - public int[] generateClustered(int N, int Max) { - int[] array = new int[N]; - fillClustered(array, 0, N, 0, Max); - return array; - } + /** + * generates randomly N distinct integers from 0 to Max. + * + * @param N + * number of integers to generate + * @param Max + * maximal value of the integers + * @return array containing the integers + */ + public int[] generateClustered(int N, int Max) { + int[] array = new int[N]; + fillClustered(array, 0, N, 0, Max); + return array; + } - public static void main(String[] args) { - int[] example = (new ClusteredDataGenerator()).generateClustered(20, 1000); - for (int k = 0; k < example.length; ++k) - System.out.println(example[k]); - } + /** + * Little test program. + * + * @param args + * arguments are ignored + */ + public static void main(final String[] args) { + int[] example = (new ClusteredDataGenerator()) + .generateClustered(20, 1000); + for (int k = 0; k < example.length; ++k) + System.out.println(example[k]); + } } diff --git a/src/main/java/me/lemire/integercompression/synth/UniformDataGenerator.java b/src/main/java/me/lemire/integercompression/synth/UniformDataGenerator.java index f93e2b5..a50497c 100644 --- a/src/main/java/me/lemire/integercompression/synth/UniformDataGenerator.java +++ b/src/main/java/me/lemire/integercompression/synth/UniformDataGenerator.java @@ -11,11 +11,10 @@ import java.util.HashSet; import java.util.Iterator; import java.util.Random; -import java.util.TreeSet; /** - * This class will generate "uniform" lists of random integers. - * + * This class will generate "uniform" lists of random integers. + * * @author Daniel Lemire */ public class UniformDataGenerator { @@ -27,7 +26,8 @@ public UniformDataGenerator() { } /** - * @param seed random seed + * @param seed + * random seed */ public UniformDataGenerator(final int seed) { this.rand = new Random(seed); @@ -42,7 +42,7 @@ int[] generateUniformHash(int N, int Max) { int[] ans = new int[N]; HashSet s = new HashSet(); while (s.size() < N) - s.add(new Integer(this.rand.nextInt(Max))); + s.add(this.rand.nextInt(Max)); Iterator i = s.iterator(); for (int k = 0; k < N; ++k) ans[k] = i.next().intValue(); @@ -51,9 +51,8 @@ int[] generateUniformHash(int N, int Max) { } /** - * output all integers from the range [0,Max) that are not - * in the array - */ + * output all integers from the range [0,Max) that are not in the array + */ static int[] negate(int[] x, int Max) { int[] ans = new int[Max - x.length]; int i = 0; @@ -69,16 +68,18 @@ static int[] negate(int[] x, int Max) { return ans; } - /** * generates randomly N distinct integers from 0 to Max. - * @param N number of integers to generate - * @param Max bound on the value of integers + * + * @param N + * number of integers to generate + * @param Max + * bound on the value of integers * @return an array containing randomly selected integers */ public int[] generateUniform(int N, int Max) { - if(N * 2 > Max) { - return negate( generateUniform(Max - N, Max), Max ); + if (N * 2 > Max) { + return negate(generateUniform(Max - N, Max), Max); } if (2048 * N > Max) return generateUniformBitmap(N, Max); diff --git a/src/main/java/me/lemire/integercompression/vector/VectorBitPacker.java b/src/main/java/me/lemire/integercompression/vector/VectorBitPacker.java new file mode 100644 index 0000000..9b2e1ca --- /dev/null +++ b/src/main/java/me/lemire/integercompression/vector/VectorBitPacker.java @@ -0,0 +1,12790 @@ +// Copyright (C) 2022 Intel Corporation + +// SPDX-License-Identifier: Apache-2.0 + +package me.lemire.integercompression.vector; + +import java.util.Arrays; +import jdk.incubator.vector.*; + +/** + * Vectorized bitpacking routines. This class is a version of the + * VectorBitPackerTerse class that with less branch instructions. + * + * The code is machine generated from VectorBitPackerTerse.java using helper + * classes. + * + */ +public class VectorBitPacker { + private static final VectorSpecies SPECIES_512 = + IntVector.SPECIES_512; + private static final VectorSpecies SPECIES_256 = + IntVector.SPECIES_256; + private static final int VLEN_512 = 16; + private static final int VLEN_256 = 8; + private static final int BLOCK_SIZE = 256; + + private static final IntVector MASK_1 = + IntVector.broadcast(SPECIES_256, (1 << 1) - 1); + private static final IntVector MASK_2 = + IntVector.broadcast(SPECIES_512, (1 << 2) - 1); + private static final IntVector MASK_3 = + IntVector.broadcast(SPECIES_256, (1 << 3) - 1); + private static final IntVector MASK_4 = + IntVector.broadcast(SPECIES_512, (1 << 4) - 1); + private static final IntVector MASK_5 = + IntVector.broadcast(SPECIES_256, (1 << 5) - 1); + private static final IntVector MASK_6 = + IntVector.broadcast(SPECIES_512, (1 << 6) - 1); + private static final IntVector MASK_7 = + IntVector.broadcast(SPECIES_256, (1 << 7) - 1); + private static final IntVector MASK_8 = + IntVector.broadcast(SPECIES_512, (1 << 8) - 1); + private static final IntVector MASK_9 = + IntVector.broadcast(SPECIES_256, (1 << 9) - 1); + private static final IntVector MASK_10 = + IntVector.broadcast(SPECIES_512, (1 << 10) - 1); + private static final IntVector MASK_11 = + IntVector.broadcast(SPECIES_256, (1 << 11) - 1); + private static final IntVector MASK_12 = + IntVector.broadcast(SPECIES_512, (1 << 12) - 1); + private static final IntVector MASK_13 = + IntVector.broadcast(SPECIES_256, (1 << 13) - 1); + private static final IntVector MASK_14 = + IntVector.broadcast(SPECIES_512, (1 << 14) - 1); + private static final IntVector MASK_15 = + IntVector.broadcast(SPECIES_256, (1 << 15) - 1); + private static final IntVector MASK_16 = + IntVector.broadcast(SPECIES_512, (1 << 16) - 1); + private static final IntVector MASK_17 = + IntVector.broadcast(SPECIES_256, (1 << 17) - 1); + private static final IntVector MASK_18 = + IntVector.broadcast(SPECIES_512, (1 << 18) - 1); + private static final IntVector MASK_19 = + IntVector.broadcast(SPECIES_256, (1 << 19) - 1); + private static final IntVector MASK_20 = + IntVector.broadcast(SPECIES_512, (1 << 20) - 1); + private static final IntVector MASK_21 = + IntVector.broadcast(SPECIES_256, (1 << 21) - 1); + private static final IntVector MASK_22 = + IntVector.broadcast(SPECIES_512, (1 << 22) - 1); + private static final IntVector MASK_23 = + IntVector.broadcast(SPECIES_256, (1 << 23) - 1); + private static final IntVector MASK_24 = + IntVector.broadcast(SPECIES_512, (1 << 24) - 1); + private static final IntVector MASK_25 = + IntVector.broadcast(SPECIES_256, (1 << 25) - 1); + private static final IntVector MASK_26 = + IntVector.broadcast(SPECIES_512, (1 << 26) - 1); + private static final IntVector MASK_27 = + IntVector.broadcast(SPECIES_256, (1 << 27) - 1); + private static final IntVector MASK_28 = + IntVector.broadcast(SPECIES_512, (1 << 28) - 1); + private static final IntVector MASK_29 = + IntVector.broadcast(SPECIES_256, (1 << 29) - 1); + private static final IntVector MASK_30 = + IntVector.broadcast(SPECIES_512, (1 << 30) - 1); + private static final IntVector MASK_31 = + IntVector.broadcast(SPECIES_256, (1 << 31) - 1); + + /** + * Pack 32 integers + * + * @param in + * source array + * @param inpos + * position in source array + * @param out + * output array + * @param outpos + * position in output array + * @param b + * number of bits to use per integer + */ + public static void fastpack(final int[] in, int inpos, final int[] out, + int outpos, int b) { + switch (b) { + case 0: + break; + case 1: + fastpack1(in, inpos, out, outpos); + break; + case 2: + fastpack2(in, inpos, out, outpos); + break; + case 3: + fastpack3(in, inpos, out, outpos); + break; + case 4: + fastpack4(in, inpos, out, outpos); + break; + case 5: + fastpack5(in, inpos, out, outpos); + break; + case 6: + fastpack6(in, inpos, out, outpos); + break; + case 7: + fastpack7(in, inpos, out, outpos); + break; + case 8: + fastpack8(in, inpos, out, outpos); + break; + case 9: + fastpack9(in, inpos, out, outpos); + break; + case 10: + fastpack10(in, inpos, out, outpos); + break; + case 11: + fastpack11(in, inpos, out, outpos); + break; + case 12: + fastpack12(in, inpos, out, outpos); + break; + case 13: + fastpack13(in, inpos, out, outpos); + break; + case 14: + fastpack14(in, inpos, out, outpos); + break; + case 15: + fastpack15(in, inpos, out, outpos); + break; + case 16: + fastpack16(in, inpos, out, outpos); + break; + case 17: + fastpack17(in, inpos, out, outpos); + break; + case 18: + fastpack18(in, inpos, out, outpos); + break; + case 19: + fastpack19(in, inpos, out, outpos); + break; + case 20: + fastpack20(in, inpos, out, outpos); + break; + case 21: + fastpack21(in, inpos, out, outpos); + break; + case 22: + fastpack22(in, inpos, out, outpos); + break; + case 23: + fastpack23(in, inpos, out, outpos); + break; + case 24: + fastpack24(in, inpos, out, outpos); + break; + case 25: + fastpack25(in, inpos, out, outpos); + break; + case 26: + fastpack26(in, inpos, out, outpos); + break; + case 27: + fastpack27(in, inpos, out, outpos); + break; + case 28: + fastpack28(in, inpos, out, outpos); + break; + case 29: + fastpack29(in, inpos, out, outpos); + break; + case 30: + fastpack30(in, inpos, out, outpos); + break; + case 31: + fastpack31(in, inpos, out, outpos); + break; + case 32: + System.arraycopy(in, inpos, out, outpos, BLOCK_SIZE); + break; + } + } + + static void fastpackNoMask(final int[] in, int inpos, final int[] out, + int outpos, int b) { + switch (b) { + case 0: + break; + case 1: + fastpackNoMask1(in, inpos, out, outpos); + break; + case 2: + fastpackNoMask2(in, inpos, out, outpos); + break; + case 3: + fastpackNoMask3(in, inpos, out, outpos); + break; + case 4: + fastpackNoMask4(in, inpos, out, outpos); + break; + case 5: + fastpackNoMask5(in, inpos, out, outpos); + break; + case 6: + fastpackNoMask6(in, inpos, out, outpos); + break; + case 7: + fastpackNoMask7(in, inpos, out, outpos); + break; + case 8: + fastpackNoMask8(in, inpos, out, outpos); + break; + case 9: + fastpackNoMask9(in, inpos, out, outpos); + break; + case 10: + fastpackNoMask10(in, inpos, out, outpos); + break; + case 11: + fastpackNoMask11(in, inpos, out, outpos); + break; + case 12: + fastpackNoMask12(in, inpos, out, outpos); + break; + case 13: + fastpackNoMask13(in, inpos, out, outpos); + break; + case 14: + fastpackNoMask14(in, inpos, out, outpos); + break; + case 15: + fastpackNoMask15(in, inpos, out, outpos); + break; + case 16: + fastpackNoMask16(in, inpos, out, outpos); + break; + case 17: + fastpackNoMask17(in, inpos, out, outpos); + break; + case 18: + fastpackNoMask18(in, inpos, out, outpos); + break; + case 19: + fastpackNoMask19(in, inpos, out, outpos); + break; + case 20: + fastpackNoMask20(in, inpos, out, outpos); + break; + case 21: + fastpackNoMask21(in, inpos, out, outpos); + break; + case 22: + fastpackNoMask22(in, inpos, out, outpos); + break; + case 23: + fastpackNoMask23(in, inpos, out, outpos); + break; + case 24: + fastpackNoMask24(in, inpos, out, outpos); + break; + case 25: + fastpackNoMask25(in, inpos, out, outpos); + break; + case 26: + fastpackNoMask26(in, inpos, out, outpos); + break; + case 27: + fastpackNoMask27(in, inpos, out, outpos); + break; + case 28: + fastpackNoMask28(in, inpos, out, outpos); + break; + case 29: + fastpackNoMask29(in, inpos, out, outpos); + break; + case 30: + fastpackNoMask30(in, inpos, out, outpos); + break; + case 31: + fastpackNoMask31(in, inpos, out, outpos); + break; + case 32: + System.arraycopy(in, inpos, out, outpos, BLOCK_SIZE); + break; + } + } + + /** + * Unpack 32 integers + * + * @param in + * source array + * @param inpos + * position in source array + * @param out + * output array + * @param outpos + * position in output array + * @param b + * number of bits to use per integer + */ + public static void fastunpack(final int[] in, int inpos, final int[] out, + int outpos, int b) { + switch (b) { + case 0: + Arrays.fill(out, outpos, outpos + 256, 0); + break; + case 1: + fastunpack1(in, inpos, out, outpos); + break; + case 2: + fastunpack2(in, inpos, out, outpos); + break; + case 3: + fastunpack3(in, inpos, out, outpos); + break; + case 4: + fastunpack4(in, inpos, out, outpos); + break; + case 5: + fastunpack5(in, inpos, out, outpos); + break; + case 6: + fastunpack6(in, inpos, out, outpos); + break; + case 7: + fastunpack7(in, inpos, out, outpos); + break; + case 8: + fastunpack8(in, inpos, out, outpos); + break; + case 9: + fastunpack9(in, inpos, out, outpos); + break; + case 10: + fastunpack10(in, inpos, out, outpos); + break; + case 11: + fastunpack11(in, inpos, out, outpos); + break; + case 12: + fastunpack12(in, inpos, out, outpos); + break; + case 13: + fastunpack13(in, inpos, out, outpos); + break; + case 14: + fastunpack14(in, inpos, out, outpos); + break; + case 15: + fastunpack15(in, inpos, out, outpos); + break; + case 16: + fastunpack16(in, inpos, out, outpos); + break; + case 17: + fastunpack17(in, inpos, out, outpos); + break; + case 18: + fastunpack18(in, inpos, out, outpos); + break; + case 19: + fastunpack19(in, inpos, out, outpos); + break; + case 20: + fastunpack20(in, inpos, out, outpos); + break; + case 21: + fastunpack21(in, inpos, out, outpos); + break; + case 22: + fastunpack22(in, inpos, out, outpos); + break; + case 23: + fastunpack23(in, inpos, out, outpos); + break; + case 24: + fastunpack24(in, inpos, out, outpos); + break; + case 25: + fastunpack25(in, inpos, out, outpos); + break; + case 26: + fastunpack26(in, inpos, out, outpos); + break; + case 27: + fastunpack27(in, inpos, out, outpos); + break; + case 28: + fastunpack28(in, inpos, out, outpos); + break; + case 29: + fastunpack29(in, inpos, out, outpos); + break; + case 30: + fastunpack30(in, inpos, out, outpos); + break; + case 31: + fastunpack31(in, inpos, out, outpos); + break; + case 32: + System.arraycopy(in, inpos, out, outpos, BLOCK_SIZE); + break; + } + } + + public static int slowpack(final int[] in, int inpos, int inlen, + final int[] out, int outpos, int b) { + if (inlen == 0) + return outpos; + if (b == 32) { + System.arraycopy(in, inpos, out, outpos, inlen); + return outpos + inlen; + } + int mask = (1 << b) - 1; + int c = 0; + int l = 0; + int r = 0; + int val = 0; + for (int i = 0; i < inlen; i++) { + val = in[inpos + i] & mask; + out[outpos] |= val << (c + r); + c += b; + l = (32 - r) % b; + if (c + r >= 32) { + if (i < inlen - 1 || l != 0) + outpos++; + r = l == 0 ? 0 : b - l; + if (l != 0) + out[outpos] = val >> (b - r); + c = 0; + } + } + return outpos; + } + + public static int slowunpack(final int[] in, int inpos, final int[] out, + int outpos, int outlen, int b) { + if (outlen == 0) { + return inpos; + } + if (b == 32) { + System.arraycopy(in, inpos, out, outpos, outlen); + return inpos + outlen; + } + int mask = (1 << b) - 1; + int limit = outpos + outlen; + int r = 0; + int val = 0; + int i = 0; + for (; outpos < limit; i++) { + if (r > 0) + out[outpos++] = + (val >>> (32 - (b - r))) | ((in[inpos + i] << (b - r)) & mask); + val = in[inpos + i]; + int j = 0; + int l = 32 - r; + int ll = l % b == 0 ? l : l - b; + while (j < ll && outpos < limit) { + out[outpos++] = (val >> (j + r)) & mask; + j += b; + } + r = l % b == 0 ? 0 : b - (l % b); + } + return inpos + i; + } + + public static int numCompressedInts(int n, int b) { + int width = b % 2 == 0 ? VLEN_512 : VLEN_256; + if (n <= width) + return n; + int intsPerVec = (32 / b) * width; + int q = (n + intsPerVec - 1) / intsPerVec; + return q * width; + } + + private static void fastpack1(final int[] in, int inpos, final int[] out, + int outpos) { + var iV = IntVector.fromArray(SPECIES_256, in, inpos); + var oV = iV.and(MASK_1); + iV = IntVector.fromArray(SPECIES_256, in, inpos + 8); + oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 1).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 16); + oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 2).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 24); + oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 3).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 32); + oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 4).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 40); + oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 5).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 48); + oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 6).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 56); + oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 7).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 64); + oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 8).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 72); + oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 9).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 80); + oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 10).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 88); + oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 11).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 96); + oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 12).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 104); + oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 13).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 112); + oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 14).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 120); + oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 15).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 128); + oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 16).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 136); + oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 17).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 144); + oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 18).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 152); + oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 19).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 160); + oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 20).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 168); + oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 21).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 176); + oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 22).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 184); + oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 23).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 192); + oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 24).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 200); + oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 25).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 208); + oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 26).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 216); + oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 27).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 224); + oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 28).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 232); + oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 29).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 240); + oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 30).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 248); + oV = iV.and(MASK_1).lanewise(VectorOperators.LSHL, 31).or(oV); + + oV.intoArray(out, outpos); + } + + private static void fastpack2(final int[] in, int inpos, final int[] out, + int outpos) { + var iV = IntVector.fromArray(SPECIES_512, in, inpos); + var oV = iV.and(MASK_2); + iV = IntVector.fromArray(SPECIES_512, in, inpos + 16); + oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 2).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 32); + oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 4).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 48); + oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 6).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 64); + oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 8).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 80); + oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 10).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 96); + oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 12).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 112); + oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 14).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 128); + oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 16).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 144); + oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 18).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 160); + oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 20).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 176); + oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 22).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 192); + oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 24).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 208); + oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 26).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 224); + oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 28).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 240); + oV = iV.and(MASK_2).lanewise(VectorOperators.LSHL, 30).or(oV); + + oV.intoArray(out, outpos); + } + + private static void fastpack3(final int[] in, int inpos, final int[] out, + int outpos) { + var iV = IntVector.fromArray(SPECIES_256, in, inpos); + var oV = iV.and(MASK_3); + iV = IntVector.fromArray(SPECIES_256, in, inpos + 8); + oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 3).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 16); + oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 6).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 24); + oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 9).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 32); + oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 12).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 40); + oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 15).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 48); + oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 18).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 56); + oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 21).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 64); + oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 24).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 72); + oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 27).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 80); + oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 30).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_3).lanewise(VectorOperators.LSHR, 2); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 88); + oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 1).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 96); + oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 4).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 104); + oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 7).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 112); + oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 10).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 120); + oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 13).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 128); + oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 16).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 136); + oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 19).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 144); + oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 22).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 152); + oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 25).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 160); + oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 28).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 168); + oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 31).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_3).lanewise(VectorOperators.LSHR, 1); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 176); + oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 2).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 184); + oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 5).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 192); + oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 8).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 200); + oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 11).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 208); + oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 14).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 216); + oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 17).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 224); + oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 20).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 232); + oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 23).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 240); + oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 26).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 248); + oV = iV.and(MASK_3).lanewise(VectorOperators.LSHL, 29).or(oV); + + oV.intoArray(out, outpos); + } + + private static void fastpack4(final int[] in, int inpos, final int[] out, + int outpos) { + var iV = IntVector.fromArray(SPECIES_512, in, inpos); + var oV = iV.and(MASK_4); + iV = IntVector.fromArray(SPECIES_512, in, inpos + 16); + oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 4).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 32); + oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 8).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 48); + oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 12).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 64); + oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 16).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 80); + oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 20).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 96); + oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 24).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 112); + oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 28).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + oV = oV.zero(SPECIES_512); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 128); + oV = iV.and(MASK_4).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 144); + oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 4).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 160); + oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 8).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 176); + oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 12).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 192); + oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 16).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 208); + oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 20).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 224); + oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 24).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 240); + oV = iV.and(MASK_4).lanewise(VectorOperators.LSHL, 28).or(oV); + + oV.intoArray(out, outpos); + } + + private static void fastpack5(final int[] in, int inpos, final int[] out, + int outpos) { + var iV = IntVector.fromArray(SPECIES_256, in, inpos); + var oV = iV.and(MASK_5); + iV = IntVector.fromArray(SPECIES_256, in, inpos + 8); + oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 5).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 16); + oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 10).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 24); + oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 15).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 32); + oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 20).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 40); + oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 25).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 48); + oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 30).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_5).lanewise(VectorOperators.LSHR, 2); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 56); + oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 3).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 64); + oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 8).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 72); + oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 13).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 80); + oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 18).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 88); + oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 23).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 96); + oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 28).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_5).lanewise(VectorOperators.LSHR, 4); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 104); + oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 1).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 112); + oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 6).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 120); + oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 11).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 128); + oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 16).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 136); + oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 21).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 144); + oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 26).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 152); + oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 31).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_5).lanewise(VectorOperators.LSHR, 1); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 160); + oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 4).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 168); + oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 9).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 176); + oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 14).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 184); + oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 19).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 192); + oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 24).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 200); + oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 29).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_5).lanewise(VectorOperators.LSHR, 3); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 208); + oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 2).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 216); + oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 7).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 224); + oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 12).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 232); + oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 17).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 240); + oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 22).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 248); + oV = iV.and(MASK_5).lanewise(VectorOperators.LSHL, 27).or(oV); + + oV.intoArray(out, outpos); + } + + private static void fastpack6(final int[] in, int inpos, final int[] out, + int outpos) { + var iV = IntVector.fromArray(SPECIES_512, in, inpos); + var oV = iV.and(MASK_6); + iV = IntVector.fromArray(SPECIES_512, in, inpos + 16); + oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 6).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 32); + oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 12).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 48); + oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 18).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 64); + oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 24).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 80); + oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 30).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + oV = iV.and(MASK_6).lanewise(VectorOperators.LSHR, 2); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 96); + oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 4).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 112); + oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 10).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 128); + oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 16).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 144); + oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 22).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 160); + oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 28).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_6).lanewise(VectorOperators.LSHR, 4); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 176); + oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 2).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 192); + oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 8).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 208); + oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 14).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 224); + oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 20).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 240); + oV = iV.and(MASK_6).lanewise(VectorOperators.LSHL, 26).or(oV); + + oV.intoArray(out, outpos); + } + + private static void fastpack7(final int[] in, int inpos, final int[] out, + int outpos) { + var iV = IntVector.fromArray(SPECIES_256, in, inpos); + var oV = iV.and(MASK_7); + iV = IntVector.fromArray(SPECIES_256, in, inpos + 8); + oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 7).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 16); + oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 14).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 24); + oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 21).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 32); + oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 28).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_7).lanewise(VectorOperators.LSHR, 4); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 40); + oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 3).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 48); + oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 10).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 56); + oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 17).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 64); + oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 24).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 72); + oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 31).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_7).lanewise(VectorOperators.LSHR, 1); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 80); + oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 6).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 88); + oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 13).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 96); + oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 20).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 104); + oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 27).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_7).lanewise(VectorOperators.LSHR, 5); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 112); + oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 2).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 120); + oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 9).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 128); + oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 16).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 136); + oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 23).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 144); + oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 30).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_7).lanewise(VectorOperators.LSHR, 2); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 152); + oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 5).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 160); + oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 12).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 168); + oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 19).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 176); + oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 26).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_7).lanewise(VectorOperators.LSHR, 6); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 184); + oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 1).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 192); + oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 8).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 200); + oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 15).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 208); + oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 22).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 216); + oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 29).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_7).lanewise(VectorOperators.LSHR, 3); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 224); + oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 4).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 232); + oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 11).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 240); + oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 18).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 248); + oV = iV.and(MASK_7).lanewise(VectorOperators.LSHL, 25).or(oV); + + oV.intoArray(out, outpos); + } + + private static void fastpack8(final int[] in, int inpos, final int[] out, + int outpos) { + var iV = IntVector.fromArray(SPECIES_512, in, inpos); + var oV = iV.and(MASK_8); + iV = IntVector.fromArray(SPECIES_512, in, inpos + 16); + oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 8).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 32); + oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 16).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 48); + oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + oV = oV.zero(SPECIES_512); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 64); + oV = iV.and(MASK_8).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 80); + oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 8).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 96); + oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 16).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 112); + oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = oV.zero(SPECIES_512); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 128); + oV = iV.and(MASK_8).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 144); + oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 8).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 160); + oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 16).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 176); + oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = oV.zero(SPECIES_512); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 192); + oV = iV.and(MASK_8).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 208); + oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 8).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 224); + oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 16).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 240); + oV = iV.and(MASK_8).lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + } + + private static void fastpack9(final int[] in, int inpos, final int[] out, + int outpos) { + var iV = IntVector.fromArray(SPECIES_256, in, inpos); + var oV = iV.and(MASK_9); + iV = IntVector.fromArray(SPECIES_256, in, inpos + 8); + oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 9).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 16); + oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 18).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 24); + oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 27).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_9).lanewise(VectorOperators.LSHR, 5); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 32); + oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 4).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 40); + oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 13).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 48); + oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 22).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 56); + oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 31).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_9).lanewise(VectorOperators.LSHR, 1); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 64); + oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 8).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 72); + oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 17).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 80); + oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 26).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_9).lanewise(VectorOperators.LSHR, 6); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 88); + oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 3).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 96); + oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 12).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 104); + oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 21).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 112); + oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 30).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_9).lanewise(VectorOperators.LSHR, 2); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 120); + oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 7).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 128); + oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 16).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 136); + oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 25).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_9).lanewise(VectorOperators.LSHR, 7); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 144); + oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 2).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 152); + oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 11).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 160); + oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 20).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 168); + oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 29).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_9).lanewise(VectorOperators.LSHR, 3); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 176); + oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 6).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 184); + oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 15).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 192); + oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_9).lanewise(VectorOperators.LSHR, 8); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 200); + oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 1).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 208); + oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 10).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 216); + oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 19).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 224); + oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 28).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_9).lanewise(VectorOperators.LSHR, 4); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 232); + oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 5).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 240); + oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 14).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 248); + oV = iV.and(MASK_9).lanewise(VectorOperators.LSHL, 23).or(oV); + + oV.intoArray(out, outpos); + } + + private static void fastpack10(final int[] in, int inpos, final int[] out, + int outpos) { + var iV = IntVector.fromArray(SPECIES_512, in, inpos); + var oV = iV.and(MASK_10); + iV = IntVector.fromArray(SPECIES_512, in, inpos + 16); + oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 10).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 32); + oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 20).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 48); + oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 30).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + oV = iV.and(MASK_10).lanewise(VectorOperators.LSHR, 2); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 64); + oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 8).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 80); + oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 18).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 96); + oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 28).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_10).lanewise(VectorOperators.LSHR, 4); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 112); + oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 6).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 128); + oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 16).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 144); + oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 26).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_10).lanewise(VectorOperators.LSHR, 6); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 160); + oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 4).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 176); + oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 14).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 192); + oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_10).lanewise(VectorOperators.LSHR, 8); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 208); + oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 2).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 224); + oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 12).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 240); + oV = iV.and(MASK_10).lanewise(VectorOperators.LSHL, 22).or(oV); + + oV.intoArray(out, outpos); + } + + private static void fastpack11(final int[] in, int inpos, final int[] out, + int outpos) { + var iV = IntVector.fromArray(SPECIES_256, in, inpos); + var oV = iV.and(MASK_11); + iV = IntVector.fromArray(SPECIES_256, in, inpos + 8); + oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 11).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 16); + oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 22).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_11).lanewise(VectorOperators.LSHR, 10); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 24); + oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 1).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 32); + oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 12).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 40); + oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 23).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_11).lanewise(VectorOperators.LSHR, 9); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 48); + oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 2).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 56); + oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 13).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 64); + oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_11).lanewise(VectorOperators.LSHR, 8); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 72); + oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 3).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 80); + oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 14).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 88); + oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 25).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_11).lanewise(VectorOperators.LSHR, 7); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 96); + oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 4).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 104); + oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 15).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 112); + oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 26).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_11).lanewise(VectorOperators.LSHR, 6); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 120); + oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 5).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 128); + oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 16).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 136); + oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 27).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_11).lanewise(VectorOperators.LSHR, 5); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 144); + oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 6).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 152); + oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 17).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 160); + oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 28).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_11).lanewise(VectorOperators.LSHR, 4); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 168); + oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 7).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 176); + oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 18).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 184); + oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 29).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_11).lanewise(VectorOperators.LSHR, 3); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 192); + oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 8).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 200); + oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 19).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 208); + oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 30).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_11).lanewise(VectorOperators.LSHR, 2); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 216); + oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 9).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 224); + oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 20).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 232); + oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 31).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_11).lanewise(VectorOperators.LSHR, 1); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 240); + oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 10).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 248); + oV = iV.and(MASK_11).lanewise(VectorOperators.LSHL, 21).or(oV); + + oV.intoArray(out, outpos); + } + + private static void fastpack12(final int[] in, int inpos, final int[] out, + int outpos) { + var iV = IntVector.fromArray(SPECIES_512, in, inpos); + var oV = iV.and(MASK_12); + iV = IntVector.fromArray(SPECIES_512, in, inpos + 16); + oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 12).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 32); + oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + oV = iV.and(MASK_12).lanewise(VectorOperators.LSHR, 8); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 48); + oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 4).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 64); + oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 16).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 80); + oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 28).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_12).lanewise(VectorOperators.LSHR, 4); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 96); + oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 8).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 112); + oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 20).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = oV.zero(SPECIES_512); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 128); + oV = iV.and(MASK_12).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 144); + oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 12).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 160); + oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_12).lanewise(VectorOperators.LSHR, 8); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 176); + oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 4).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 192); + oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 16).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 208); + oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 28).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_12).lanewise(VectorOperators.LSHR, 4); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 224); + oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 8).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 240); + oV = iV.and(MASK_12).lanewise(VectorOperators.LSHL, 20).or(oV); + + oV.intoArray(out, outpos); + } + + private static void fastpack13(final int[] in, int inpos, final int[] out, + int outpos) { + var iV = IntVector.fromArray(SPECIES_256, in, inpos); + var oV = iV.and(MASK_13); + iV = IntVector.fromArray(SPECIES_256, in, inpos + 8); + oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 13).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 16); + oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 26).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_13).lanewise(VectorOperators.LSHR, 6); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 24); + oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 7).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 32); + oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 20).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_13).lanewise(VectorOperators.LSHR, 12); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 40); + oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 1).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 48); + oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 14).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 56); + oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 27).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_13).lanewise(VectorOperators.LSHR, 5); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 64); + oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 8).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 72); + oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 21).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_13).lanewise(VectorOperators.LSHR, 11); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 80); + oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 2).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 88); + oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 15).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 96); + oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 28).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_13).lanewise(VectorOperators.LSHR, 4); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 104); + oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 9).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 112); + oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 22).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_13).lanewise(VectorOperators.LSHR, 10); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 120); + oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 3).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 128); + oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 16).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 136); + oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 29).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_13).lanewise(VectorOperators.LSHR, 3); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 144); + oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 10).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 152); + oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 23).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_13).lanewise(VectorOperators.LSHR, 9); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 160); + oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 4).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 168); + oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 17).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 176); + oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 30).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_13).lanewise(VectorOperators.LSHR, 2); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 184); + oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 11).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 192); + oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_13).lanewise(VectorOperators.LSHR, 8); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 200); + oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 5).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 208); + oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 18).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 216); + oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 31).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_13).lanewise(VectorOperators.LSHR, 1); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 224); + oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 12).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 232); + oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 25).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_13).lanewise(VectorOperators.LSHR, 7); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 240); + oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 6).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 248); + oV = iV.and(MASK_13).lanewise(VectorOperators.LSHL, 19).or(oV); + + oV.intoArray(out, outpos); + } + + private static void fastpack14(final int[] in, int inpos, final int[] out, + int outpos) { + var iV = IntVector.fromArray(SPECIES_512, in, inpos); + var oV = iV.and(MASK_14); + iV = IntVector.fromArray(SPECIES_512, in, inpos + 16); + oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 14).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 32); + oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 28).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + oV = iV.and(MASK_14).lanewise(VectorOperators.LSHR, 4); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 48); + oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 10).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 64); + oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_14).lanewise(VectorOperators.LSHR, 8); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 80); + oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 6).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 96); + oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 20).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_14).lanewise(VectorOperators.LSHR, 12); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 112); + oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 2).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 128); + oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 16).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 144); + oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 30).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_14).lanewise(VectorOperators.LSHR, 2); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 160); + oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 12).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 176); + oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 26).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_14).lanewise(VectorOperators.LSHR, 6); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 192); + oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 8).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 208); + oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 22).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_14).lanewise(VectorOperators.LSHR, 10); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 224); + oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 4).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 240); + oV = iV.and(MASK_14).lanewise(VectorOperators.LSHL, 18).or(oV); + + oV.intoArray(out, outpos); + } + + private static void fastpack15(final int[] in, int inpos, final int[] out, + int outpos) { + var iV = IntVector.fromArray(SPECIES_256, in, inpos); + var oV = iV.and(MASK_15); + iV = IntVector.fromArray(SPECIES_256, in, inpos + 8); + oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 15).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 16); + oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 30).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_15).lanewise(VectorOperators.LSHR, 2); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 24); + oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 13).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 32); + oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 28).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_15).lanewise(VectorOperators.LSHR, 4); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 40); + oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 11).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 48); + oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 26).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_15).lanewise(VectorOperators.LSHR, 6); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 56); + oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 9).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 64); + oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_15).lanewise(VectorOperators.LSHR, 8); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 72); + oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 7).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 80); + oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 22).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_15).lanewise(VectorOperators.LSHR, 10); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 88); + oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 5).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 96); + oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 20).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_15).lanewise(VectorOperators.LSHR, 12); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 104); + oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 3).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 112); + oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 18).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_15).lanewise(VectorOperators.LSHR, 14); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 120); + oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 1).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 128); + oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 16).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 136); + oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 31).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_15).lanewise(VectorOperators.LSHR, 1); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 144); + oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 14).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 152); + oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 29).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_15).lanewise(VectorOperators.LSHR, 3); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 160); + oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 12).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 168); + oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 27).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_15).lanewise(VectorOperators.LSHR, 5); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 176); + oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 10).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 184); + oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 25).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_15).lanewise(VectorOperators.LSHR, 7); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 192); + oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 8).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 200); + oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 23).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_15).lanewise(VectorOperators.LSHR, 9); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 208); + oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 6).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 216); + oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 21).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_15).lanewise(VectorOperators.LSHR, 11); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 224); + oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 4).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 232); + oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 19).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_15).lanewise(VectorOperators.LSHR, 13); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 240); + oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 2).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 248); + oV = iV.and(MASK_15).lanewise(VectorOperators.LSHL, 17).or(oV); + + oV.intoArray(out, outpos); + } + + private static void fastpack16(final int[] in, int inpos, final int[] out, + int outpos) { + var iV = IntVector.fromArray(SPECIES_512, in, inpos); + var oV = iV.and(MASK_16); + iV = IntVector.fromArray(SPECIES_512, in, inpos + 16); + oV = iV.and(MASK_16).lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + oV = oV.zero(SPECIES_512); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 32); + oV = iV.and(MASK_16).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 48); + oV = iV.and(MASK_16).lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = oV.zero(SPECIES_512); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 64); + oV = iV.and(MASK_16).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 80); + oV = iV.and(MASK_16).lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = oV.zero(SPECIES_512); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 96); + oV = iV.and(MASK_16).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 112); + oV = iV.and(MASK_16).lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = oV.zero(SPECIES_512); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 128); + oV = iV.and(MASK_16).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 144); + oV = iV.and(MASK_16).lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = oV.zero(SPECIES_512); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 160); + oV = iV.and(MASK_16).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 176); + oV = iV.and(MASK_16).lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = oV.zero(SPECIES_512); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 192); + oV = iV.and(MASK_16).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 208); + oV = iV.and(MASK_16).lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = oV.zero(SPECIES_512); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 224); + oV = iV.and(MASK_16).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 240); + oV = iV.and(MASK_16).lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + } + + private static void fastpack17(final int[] in, int inpos, final int[] out, + int outpos) { + var iV = IntVector.fromArray(SPECIES_256, in, inpos); + var oV = iV.and(MASK_17); + iV = IntVector.fromArray(SPECIES_256, in, inpos + 8); + oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 17).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_17).lanewise(VectorOperators.LSHR, 15); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 16); + oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 2).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 24); + oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 19).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_17).lanewise(VectorOperators.LSHR, 13); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 32); + oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 4).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 40); + oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 21).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_17).lanewise(VectorOperators.LSHR, 11); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 48); + oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 6).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 56); + oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 23).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_17).lanewise(VectorOperators.LSHR, 9); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 64); + oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 8).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 72); + oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 25).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_17).lanewise(VectorOperators.LSHR, 7); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 80); + oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 10).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 88); + oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 27).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_17).lanewise(VectorOperators.LSHR, 5); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 96); + oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 12).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 104); + oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 29).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_17).lanewise(VectorOperators.LSHR, 3); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 112); + oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 14).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 120); + oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 31).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_17).lanewise(VectorOperators.LSHR, 1); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 128); + oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_17).lanewise(VectorOperators.LSHR, 16); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 136); + oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 1).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 144); + oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 18).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_17).lanewise(VectorOperators.LSHR, 14); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 152); + oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 3).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 160); + oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 20).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_17).lanewise(VectorOperators.LSHR, 12); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 168); + oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 5).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 176); + oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 22).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_17).lanewise(VectorOperators.LSHR, 10); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 184); + oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 7).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 192); + oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_17).lanewise(VectorOperators.LSHR, 8); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 200); + oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 9).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 208); + oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 26).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_17).lanewise(VectorOperators.LSHR, 6); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 216); + oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 11).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 224); + oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 28).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_17).lanewise(VectorOperators.LSHR, 4); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 232); + oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 13).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 240); + oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 30).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_17).lanewise(VectorOperators.LSHR, 2); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 248); + oV = iV.and(MASK_17).lanewise(VectorOperators.LSHL, 15).or(oV); + + oV.intoArray(out, outpos); + } + + private static void fastpack18(final int[] in, int inpos, final int[] out, + int outpos) { + var iV = IntVector.fromArray(SPECIES_512, in, inpos); + var oV = iV.and(MASK_18); + iV = IntVector.fromArray(SPECIES_512, in, inpos + 16); + oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 18).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + oV = iV.and(MASK_18).lanewise(VectorOperators.LSHR, 14); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 32); + oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 4).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 48); + oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 22).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_18).lanewise(VectorOperators.LSHR, 10); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 64); + oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 8).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 80); + oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 26).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_18).lanewise(VectorOperators.LSHR, 6); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 96); + oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 12).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 112); + oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 30).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_18).lanewise(VectorOperators.LSHR, 2); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 128); + oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_18).lanewise(VectorOperators.LSHR, 16); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 144); + oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 2).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 160); + oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 20).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_18).lanewise(VectorOperators.LSHR, 12); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 176); + oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 6).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 192); + oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_18).lanewise(VectorOperators.LSHR, 8); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 208); + oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 10).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 224); + oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 28).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_18).lanewise(VectorOperators.LSHR, 4); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 240); + oV = iV.and(MASK_18).lanewise(VectorOperators.LSHL, 14).or(oV); + + oV.intoArray(out, outpos); + } + + private static void fastpack19(final int[] in, int inpos, final int[] out, + int outpos) { + var iV = IntVector.fromArray(SPECIES_256, in, inpos); + var oV = iV.and(MASK_19); + iV = IntVector.fromArray(SPECIES_256, in, inpos + 8); + oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 19).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 13); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 16); + oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 6).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 24); + oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 25).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 7); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 32); + oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 12).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 40); + oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 31).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 1); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 48); + oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 18).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 14); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 56); + oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 5).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 64); + oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 8); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 72); + oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 11).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 80); + oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 30).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 2); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 88); + oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 17).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 15); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 96); + oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 4).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 104); + oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 23).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 9); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 112); + oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 10).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 120); + oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 29).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 3); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 128); + oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 16); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 136); + oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 3).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 144); + oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 22).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 10); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 152); + oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 9).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 160); + oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 28).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 4); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 168); + oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 15).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 17); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 176); + oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 2).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 184); + oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 21).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 11); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 192); + oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 8).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 200); + oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 27).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 5); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 208); + oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 14).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 18); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 216); + oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 1).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 224); + oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 20).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 12); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 232); + oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 7).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 240); + oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 26).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_19).lanewise(VectorOperators.LSHR, 6); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 248); + oV = iV.and(MASK_19).lanewise(VectorOperators.LSHL, 13).or(oV); + + oV.intoArray(out, outpos); + } + + private static void fastpack20(final int[] in, int inpos, final int[] out, + int outpos) { + var iV = IntVector.fromArray(SPECIES_512, in, inpos); + var oV = iV.and(MASK_20); + iV = IntVector.fromArray(SPECIES_512, in, inpos + 16); + oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 20).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + oV = iV.and(MASK_20).lanewise(VectorOperators.LSHR, 12); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 32); + oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 8).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 48); + oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 28).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_20).lanewise(VectorOperators.LSHR, 4); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 64); + oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_20).lanewise(VectorOperators.LSHR, 16); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 80); + oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 4).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 96); + oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_20).lanewise(VectorOperators.LSHR, 8); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 112); + oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 12).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = oV.zero(SPECIES_512); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 128); + oV = iV.and(MASK_20).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 144); + oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 20).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_20).lanewise(VectorOperators.LSHR, 12); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 160); + oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 8).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 176); + oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 28).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_20).lanewise(VectorOperators.LSHR, 4); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 192); + oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_20).lanewise(VectorOperators.LSHR, 16); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 208); + oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 4).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 224); + oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_20).lanewise(VectorOperators.LSHR, 8); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 240); + oV = iV.and(MASK_20).lanewise(VectorOperators.LSHL, 12).or(oV); + + oV.intoArray(out, outpos); + } + + private static void fastpack21(final int[] in, int inpos, final int[] out, + int outpos) { + var iV = IntVector.fromArray(SPECIES_256, in, inpos); + var oV = iV.and(MASK_21); + iV = IntVector.fromArray(SPECIES_256, in, inpos + 8); + oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 21).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 11); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 16); + oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 10).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 24); + oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 31).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 1); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 32); + oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 20).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 12); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 40); + oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 9).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 48); + oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 30).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 2); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 56); + oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 19).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 13); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 64); + oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 8).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 72); + oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 29).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 3); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 80); + oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 18).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 14); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 88); + oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 7).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 96); + oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 28).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 4); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 104); + oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 17).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 15); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 112); + oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 6).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 120); + oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 27).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 5); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 128); + oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 16); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 136); + oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 5).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 144); + oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 26).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 6); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 152); + oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 15).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 17); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 160); + oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 4).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 168); + oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 25).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 7); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 176); + oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 14).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 18); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 184); + oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 3).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 192); + oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 8); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 200); + oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 13).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 19); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 208); + oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 2).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 216); + oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 23).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 9); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 224); + oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 12).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 20); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 232); + oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 1).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 240); + oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 22).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_21).lanewise(VectorOperators.LSHR, 10); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 248); + oV = iV.and(MASK_21).lanewise(VectorOperators.LSHL, 11).or(oV); + + oV.intoArray(out, outpos); + } + + private static void fastpack22(final int[] in, int inpos, final int[] out, + int outpos) { + var iV = IntVector.fromArray(SPECIES_512, in, inpos); + var oV = iV.and(MASK_22); + iV = IntVector.fromArray(SPECIES_512, in, inpos + 16); + oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 22).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 10); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 32); + oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 12).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 20); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 48); + oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 2).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 64); + oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 8); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 80); + oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 14).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 18); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 96); + oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 4).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 112); + oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 26).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 6); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 128); + oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 16); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 144); + oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 6).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 160); + oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 28).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 4); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 176); + oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 18).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 14); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 192); + oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 8).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 208); + oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 30).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 2); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 224); + oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 20).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_22).lanewise(VectorOperators.LSHR, 12); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 240); + oV = iV.and(MASK_22).lanewise(VectorOperators.LSHL, 10).or(oV); + + oV.intoArray(out, outpos); + } + + private static void fastpack23(final int[] in, int inpos, final int[] out, + int outpos) { + var iV = IntVector.fromArray(SPECIES_256, in, inpos); + var oV = iV.and(MASK_23); + iV = IntVector.fromArray(SPECIES_256, in, inpos + 8); + oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 23).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 9); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 16); + oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 14).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 18); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 24); + oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 5).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 32); + oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 28).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 4); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 40); + oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 19).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 13); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 48); + oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 10).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 22); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 56); + oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 1).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 64); + oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 8); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 72); + oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 15).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 17); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 80); + oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 6).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 88); + oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 29).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 3); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 96); + oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 20).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 12); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 104); + oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 11).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 21); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 112); + oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 2).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 120); + oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 25).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 7); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 128); + oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 16); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 136); + oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 7).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 144); + oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 30).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 2); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 152); + oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 21).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 11); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 160); + oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 12).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 20); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 168); + oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 3).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 176); + oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 26).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 6); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 184); + oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 17).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 15); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 192); + oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 8).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 200); + oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 31).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 1); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 208); + oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 22).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 10); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 216); + oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 13).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 19); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 224); + oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 4).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 232); + oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 27).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 5); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 240); + oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 18).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_23).lanewise(VectorOperators.LSHR, 14); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 248); + oV = iV.and(MASK_23).lanewise(VectorOperators.LSHL, 9).or(oV); + + oV.intoArray(out, outpos); + } + + private static void fastpack24(final int[] in, int inpos, final int[] out, + int outpos) { + var iV = IntVector.fromArray(SPECIES_512, in, inpos); + var oV = iV.and(MASK_24); + iV = IntVector.fromArray(SPECIES_512, in, inpos + 16); + oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + oV = iV.and(MASK_24).lanewise(VectorOperators.LSHR, 8); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 32); + oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_24).lanewise(VectorOperators.LSHR, 16); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 48); + oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 8).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = oV.zero(SPECIES_512); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 64); + oV = iV.and(MASK_24).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 80); + oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_24).lanewise(VectorOperators.LSHR, 8); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 96); + oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_24).lanewise(VectorOperators.LSHR, 16); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 112); + oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 8).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = oV.zero(SPECIES_512); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 128); + oV = iV.and(MASK_24).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 144); + oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_24).lanewise(VectorOperators.LSHR, 8); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 160); + oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_24).lanewise(VectorOperators.LSHR, 16); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 176); + oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 8).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = oV.zero(SPECIES_512); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 192); + oV = iV.and(MASK_24).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 208); + oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_24).lanewise(VectorOperators.LSHR, 8); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 224); + oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_24).lanewise(VectorOperators.LSHR, 16); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 240); + oV = iV.and(MASK_24).lanewise(VectorOperators.LSHL, 8).or(oV); + + oV.intoArray(out, outpos); + } + + private static void fastpack25(final int[] in, int inpos, final int[] out, + int outpos) { + var iV = IntVector.fromArray(SPECIES_256, in, inpos); + var oV = iV.and(MASK_25); + iV = IntVector.fromArray(SPECIES_256, in, inpos + 8); + oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 25).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 7); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 16); + oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 18).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 14); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 24); + oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 11).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 21); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 32); + oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 4).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 40); + oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 29).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 3); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 48); + oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 22).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 10); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 56); + oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 15).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 17); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 64); + oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 8).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 24); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 72); + oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 1).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 80); + oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 26).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 6); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 88); + oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 19).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 13); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 96); + oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 12).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 20); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 104); + oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 5).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 112); + oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 30).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 2); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 120); + oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 23).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 9); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 128); + oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 16); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 136); + oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 9).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 23); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 144); + oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 2).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 152); + oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 27).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 5); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 160); + oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 20).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 12); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 168); + oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 13).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 19); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 176); + oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 6).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 184); + oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 31).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 1); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 192); + oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 8); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 200); + oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 17).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 15); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 208); + oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 10).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 22); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 216); + oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 3).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 224); + oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 28).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 4); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 232); + oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 21).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 11); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 240); + oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 14).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_25).lanewise(VectorOperators.LSHR, 18); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 248); + oV = iV.and(MASK_25).lanewise(VectorOperators.LSHL, 7).or(oV); + + oV.intoArray(out, outpos); + } + + private static void fastpack26(final int[] in, int inpos, final int[] out, + int outpos) { + var iV = IntVector.fromArray(SPECIES_512, in, inpos); + var oV = iV.and(MASK_26); + iV = IntVector.fromArray(SPECIES_512, in, inpos + 16); + oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 26).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 6); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 32); + oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 20).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 12); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 48); + oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 14).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 18); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 64); + oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 8).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 24); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 80); + oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 2).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 96); + oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 28).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 4); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 112); + oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 22).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 10); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 128); + oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 16); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 144); + oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 10).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 22); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 160); + oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 4).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 176); + oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 30).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 2); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 192); + oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 8); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 208); + oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 18).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 14); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 224); + oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 12).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_26).lanewise(VectorOperators.LSHR, 20); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 240); + oV = iV.and(MASK_26).lanewise(VectorOperators.LSHL, 6).or(oV); + + oV.intoArray(out, outpos); + } + + private static void fastpack27(final int[] in, int inpos, final int[] out, + int outpos) { + var iV = IntVector.fromArray(SPECIES_256, in, inpos); + var oV = iV.and(MASK_27); + iV = IntVector.fromArray(SPECIES_256, in, inpos + 8); + oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 27).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 5); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 16); + oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 22).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 10); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 24); + oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 17).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 15); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 32); + oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 12).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 20); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 40); + oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 7).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 25); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 48); + oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 2).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 56); + oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 29).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 3); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 64); + oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 8); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 72); + oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 19).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 13); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 80); + oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 14).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 18); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 88); + oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 9).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 23); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 96); + oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 4).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 104); + oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 31).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 1); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 112); + oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 26).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 6); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 120); + oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 21).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 11); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 128); + oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 16); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 136); + oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 11).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 21); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 144); + oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 6).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 26); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 152); + oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 1).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 160); + oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 28).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 4); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 168); + oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 23).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 9); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 176); + oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 18).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 14); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 184); + oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 13).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 19); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 192); + oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 8).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 24); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 200); + oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 3).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 208); + oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 30).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 2); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 216); + oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 25).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 7); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 224); + oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 20).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 12); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 232); + oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 15).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 17); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 240); + oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 10).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_27).lanewise(VectorOperators.LSHR, 22); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 248); + oV = iV.and(MASK_27).lanewise(VectorOperators.LSHL, 5).or(oV); + + oV.intoArray(out, outpos); + } + + private static void fastpack28(final int[] in, int inpos, final int[] out, + int outpos) { + var iV = IntVector.fromArray(SPECIES_512, in, inpos); + var oV = iV.and(MASK_28); + iV = IntVector.fromArray(SPECIES_512, in, inpos + 16); + oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 28).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 4); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 32); + oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 8); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 48); + oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 20).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 12); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 64); + oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 16); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 80); + oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 12).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 20); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 96); + oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 8).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 24); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 112); + oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 4).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = oV.zero(SPECIES_512); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 128); + oV = iV.and(MASK_28).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 144); + oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 28).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 4); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 160); + oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 8); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 176); + oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 20).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 12); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 192); + oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 16); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 208); + oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 12).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 20); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 224); + oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 8).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_28).lanewise(VectorOperators.LSHR, 24); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 240); + oV = iV.and(MASK_28).lanewise(VectorOperators.LSHL, 4).or(oV); + + oV.intoArray(out, outpos); + } + + private static void fastpack29(final int[] in, int inpos, final int[] out, + int outpos) { + var iV = IntVector.fromArray(SPECIES_256, in, inpos); + var oV = iV.and(MASK_29); + iV = IntVector.fromArray(SPECIES_256, in, inpos + 8); + oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 29).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 3); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 16); + oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 26).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 6); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 24); + oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 23).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 9); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 32); + oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 20).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 12); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 40); + oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 17).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 15); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 48); + oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 14).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 18); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 56); + oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 11).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 21); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 64); + oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 8).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 24); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 72); + oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 5).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 27); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 80); + oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 2).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 88); + oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 31).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 1); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 96); + oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 28).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 4); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 104); + oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 25).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 7); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 112); + oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 22).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 10); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 120); + oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 19).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 13); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 128); + oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 16); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 136); + oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 13).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 19); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 144); + oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 10).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 22); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 152); + oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 7).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 25); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 160); + oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 4).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 28); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 168); + oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 1).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 176); + oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 30).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 2); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 184); + oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 27).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 5); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 192); + oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 8); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 200); + oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 21).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 11); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 208); + oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 18).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 14); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 216); + oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 15).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 17); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 224); + oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 12).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 20); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 232); + oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 9).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 23); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 240); + oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 6).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_29).lanewise(VectorOperators.LSHR, 26); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 248); + oV = iV.and(MASK_29).lanewise(VectorOperators.LSHL, 3).or(oV); + + oV.intoArray(out, outpos); + } + + private static void fastpack30(final int[] in, int inpos, final int[] out, + int outpos) { + var iV = IntVector.fromArray(SPECIES_512, in, inpos); + var oV = iV.and(MASK_30); + iV = IntVector.fromArray(SPECIES_512, in, inpos + 16); + oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 30).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 2); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 32); + oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 28).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 4); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 48); + oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 26).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 6); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 64); + oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 8); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 80); + oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 22).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 10); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 96); + oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 20).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 12); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 112); + oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 18).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 14); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 128); + oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 16); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 144); + oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 14).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 18); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 160); + oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 12).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 20); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 176); + oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 10).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 22); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 192); + oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 8).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 24); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 208); + oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 6).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 26); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 224); + oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 4).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.and(MASK_30).lanewise(VectorOperators.LSHR, 28); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 240); + oV = iV.and(MASK_30).lanewise(VectorOperators.LSHL, 2).or(oV); + + oV.intoArray(out, outpos); + } + + private static void fastpack31(final int[] in, int inpos, final int[] out, + int outpos) { + var iV = IntVector.fromArray(SPECIES_256, in, inpos); + var oV = iV.and(MASK_31); + iV = IntVector.fromArray(SPECIES_256, in, inpos + 8); + oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 31).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 1); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 16); + oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 30).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 2); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 24); + oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 29).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 3); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 32); + oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 28).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 4); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 40); + oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 27).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 5); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 48); + oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 26).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 6); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 56); + oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 25).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 7); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 64); + oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 8); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 72); + oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 23).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 9); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 80); + oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 22).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 10); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 88); + oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 21).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 11); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 96); + oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 20).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 12); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 104); + oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 19).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 13); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 112); + oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 18).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 14); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 120); + oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 17).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 15); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 128); + oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 16); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 136); + oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 15).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 17); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 144); + oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 14).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 18); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 152); + oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 13).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 19); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 160); + oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 12).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 20); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 168); + oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 11).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 21); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 176); + oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 10).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 22); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 184); + oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 9).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 23); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 192); + oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 8).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 24); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 200); + oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 7).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 25); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 208); + oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 6).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 26); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 216); + oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 5).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 27); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 224); + oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 4).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 28); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 232); + oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 3).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 29); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 240); + oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 2).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.and(MASK_31).lanewise(VectorOperators.LSHR, 30); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 248); + oV = iV.and(MASK_31).lanewise(VectorOperators.LSHL, 1).or(oV); + + oV.intoArray(out, outpos); + } + + private static void fastpackNoMask1(final int[] in, int inpos, + final int[] out, int outpos) { + var iV = IntVector.fromArray(SPECIES_256, in, inpos); + var oV = iV; + iV = IntVector.fromArray(SPECIES_256, in, inpos + 8); + oV = iV.lanewise(VectorOperators.LSHL, 1).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 16); + oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 24); + oV = iV.lanewise(VectorOperators.LSHL, 3).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 32); + oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 40); + oV = iV.lanewise(VectorOperators.LSHL, 5).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 48); + oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 56); + oV = iV.lanewise(VectorOperators.LSHL, 7).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 64); + oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 72); + oV = iV.lanewise(VectorOperators.LSHL, 9).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 80); + oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 88); + oV = iV.lanewise(VectorOperators.LSHL, 11).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 96); + oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 104); + oV = iV.lanewise(VectorOperators.LSHL, 13).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 112); + oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 120); + oV = iV.lanewise(VectorOperators.LSHL, 15).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 128); + oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 136); + oV = iV.lanewise(VectorOperators.LSHL, 17).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 144); + oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 152); + oV = iV.lanewise(VectorOperators.LSHL, 19).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 160); + oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 168); + oV = iV.lanewise(VectorOperators.LSHL, 21).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 176); + oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 184); + oV = iV.lanewise(VectorOperators.LSHL, 23).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 192); + oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 200); + oV = iV.lanewise(VectorOperators.LSHL, 25).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 208); + oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 216); + oV = iV.lanewise(VectorOperators.LSHL, 27).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 224); + oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 232); + oV = iV.lanewise(VectorOperators.LSHL, 29).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 240); + oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 248); + oV = iV.lanewise(VectorOperators.LSHL, 31).or(oV); + + oV.intoArray(out, outpos); + } + + private static void fastpackNoMask2(final int[] in, int inpos, + final int[] out, int outpos) { + var iV = IntVector.fromArray(SPECIES_512, in, inpos); + var oV = iV; + iV = IntVector.fromArray(SPECIES_512, in, inpos + 16); + oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 32); + oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 48); + oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 64); + oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 80); + oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 96); + oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 112); + oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 128); + oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 144); + oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 160); + oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 176); + oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 192); + oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 208); + oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 224); + oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 240); + oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV); + + oV.intoArray(out, outpos); + } + + private static void fastpackNoMask3(final int[] in, int inpos, + final int[] out, int outpos) { + var iV = IntVector.fromArray(SPECIES_256, in, inpos); + var oV = iV; + iV = IntVector.fromArray(SPECIES_256, in, inpos + 8); + oV = iV.lanewise(VectorOperators.LSHL, 3).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 16); + oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 24); + oV = iV.lanewise(VectorOperators.LSHL, 9).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 32); + oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 40); + oV = iV.lanewise(VectorOperators.LSHL, 15).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 48); + oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 56); + oV = iV.lanewise(VectorOperators.LSHL, 21).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 64); + oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 72); + oV = iV.lanewise(VectorOperators.LSHL, 27).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 80); + oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 2); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 88); + oV = iV.lanewise(VectorOperators.LSHL, 1).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 96); + oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 104); + oV = iV.lanewise(VectorOperators.LSHL, 7).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 112); + oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 120); + oV = iV.lanewise(VectorOperators.LSHL, 13).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 128); + oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 136); + oV = iV.lanewise(VectorOperators.LSHL, 19).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 144); + oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 152); + oV = iV.lanewise(VectorOperators.LSHL, 25).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 160); + oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 168); + oV = iV.lanewise(VectorOperators.LSHL, 31).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 1); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 176); + oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 184); + oV = iV.lanewise(VectorOperators.LSHL, 5).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 192); + oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 200); + oV = iV.lanewise(VectorOperators.LSHL, 11).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 208); + oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 216); + oV = iV.lanewise(VectorOperators.LSHL, 17).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 224); + oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 232); + oV = iV.lanewise(VectorOperators.LSHL, 23).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 240); + oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 248); + oV = iV.lanewise(VectorOperators.LSHL, 29).or(oV); + + oV.intoArray(out, outpos); + } + + private static void fastpackNoMask4(final int[] in, int inpos, + final int[] out, int outpos) { + var iV = IntVector.fromArray(SPECIES_512, in, inpos); + var oV = iV; + iV = IntVector.fromArray(SPECIES_512, in, inpos + 16); + oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 32); + oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 48); + oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 64); + oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 80); + oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 96); + oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 112); + oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + oV = oV.zero(SPECIES_512); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 128); + oV = iV.or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 144); + oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 160); + oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 176); + oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 192); + oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 208); + oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 224); + oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 240); + oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV); + + oV.intoArray(out, outpos); + } + + private static void fastpackNoMask5(final int[] in, int inpos, + final int[] out, int outpos) { + var iV = IntVector.fromArray(SPECIES_256, in, inpos); + var oV = iV; + iV = IntVector.fromArray(SPECIES_256, in, inpos + 8); + oV = iV.lanewise(VectorOperators.LSHL, 5).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 16); + oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 24); + oV = iV.lanewise(VectorOperators.LSHL, 15).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 32); + oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 40); + oV = iV.lanewise(VectorOperators.LSHL, 25).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 48); + oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 2); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 56); + oV = iV.lanewise(VectorOperators.LSHL, 3).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 64); + oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 72); + oV = iV.lanewise(VectorOperators.LSHL, 13).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 80); + oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 88); + oV = iV.lanewise(VectorOperators.LSHL, 23).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 96); + oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 4); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 104); + oV = iV.lanewise(VectorOperators.LSHL, 1).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 112); + oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 120); + oV = iV.lanewise(VectorOperators.LSHL, 11).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 128); + oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 136); + oV = iV.lanewise(VectorOperators.LSHL, 21).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 144); + oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 152); + oV = iV.lanewise(VectorOperators.LSHL, 31).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 1); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 160); + oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 168); + oV = iV.lanewise(VectorOperators.LSHL, 9).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 176); + oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 184); + oV = iV.lanewise(VectorOperators.LSHL, 19).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 192); + oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 200); + oV = iV.lanewise(VectorOperators.LSHL, 29).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 3); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 208); + oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 216); + oV = iV.lanewise(VectorOperators.LSHL, 7).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 224); + oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 232); + oV = iV.lanewise(VectorOperators.LSHL, 17).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 240); + oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 248); + oV = iV.lanewise(VectorOperators.LSHL, 27).or(oV); + + oV.intoArray(out, outpos); + } + + private static void fastpackNoMask6(final int[] in, int inpos, + final int[] out, int outpos) { + var iV = IntVector.fromArray(SPECIES_512, in, inpos); + var oV = iV; + iV = IntVector.fromArray(SPECIES_512, in, inpos + 16); + oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 32); + oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 48); + oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 64); + oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 80); + oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + oV = iV.lanewise(VectorOperators.LSHR, 2); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 96); + oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 112); + oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 128); + oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 144); + oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 160); + oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 4); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 176); + oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 192); + oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 208); + oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 224); + oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 240); + oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV); + + oV.intoArray(out, outpos); + } + + private static void fastpackNoMask7(final int[] in, int inpos, + final int[] out, int outpos) { + var iV = IntVector.fromArray(SPECIES_256, in, inpos); + var oV = iV; + iV = IntVector.fromArray(SPECIES_256, in, inpos + 8); + oV = iV.lanewise(VectorOperators.LSHL, 7).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 16); + oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 24); + oV = iV.lanewise(VectorOperators.LSHL, 21).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 32); + oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 4); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 40); + oV = iV.lanewise(VectorOperators.LSHL, 3).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 48); + oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 56); + oV = iV.lanewise(VectorOperators.LSHL, 17).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 64); + oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 72); + oV = iV.lanewise(VectorOperators.LSHL, 31).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 1); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 80); + oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 88); + oV = iV.lanewise(VectorOperators.LSHL, 13).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 96); + oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 104); + oV = iV.lanewise(VectorOperators.LSHL, 27).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 5); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 112); + oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 120); + oV = iV.lanewise(VectorOperators.LSHL, 9).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 128); + oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 136); + oV = iV.lanewise(VectorOperators.LSHL, 23).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 144); + oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 2); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 152); + oV = iV.lanewise(VectorOperators.LSHL, 5).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 160); + oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 168); + oV = iV.lanewise(VectorOperators.LSHL, 19).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 176); + oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 6); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 184); + oV = iV.lanewise(VectorOperators.LSHL, 1).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 192); + oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 200); + oV = iV.lanewise(VectorOperators.LSHL, 15).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 208); + oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 216); + oV = iV.lanewise(VectorOperators.LSHL, 29).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 3); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 224); + oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 232); + oV = iV.lanewise(VectorOperators.LSHL, 11).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 240); + oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 248); + oV = iV.lanewise(VectorOperators.LSHL, 25).or(oV); + + oV.intoArray(out, outpos); + } + + private static void fastpackNoMask8(final int[] in, int inpos, + final int[] out, int outpos) { + var iV = IntVector.fromArray(SPECIES_512, in, inpos); + var oV = iV; + iV = IntVector.fromArray(SPECIES_512, in, inpos + 16); + oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 32); + oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 48); + oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + oV = oV.zero(SPECIES_512); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 64); + oV = iV.or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 80); + oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 96); + oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 112); + oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = oV.zero(SPECIES_512); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 128); + oV = iV.or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 144); + oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 160); + oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 176); + oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = oV.zero(SPECIES_512); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 192); + oV = iV.or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 208); + oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 224); + oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 240); + oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + } + + private static void fastpackNoMask9(final int[] in, int inpos, + final int[] out, int outpos) { + var iV = IntVector.fromArray(SPECIES_256, in, inpos); + var oV = iV; + iV = IntVector.fromArray(SPECIES_256, in, inpos + 8); + oV = iV.lanewise(VectorOperators.LSHL, 9).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 16); + oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 24); + oV = iV.lanewise(VectorOperators.LSHL, 27).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 5); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 32); + oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 40); + oV = iV.lanewise(VectorOperators.LSHL, 13).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 48); + oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 56); + oV = iV.lanewise(VectorOperators.LSHL, 31).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 1); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 64); + oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 72); + oV = iV.lanewise(VectorOperators.LSHL, 17).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 80); + oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 6); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 88); + oV = iV.lanewise(VectorOperators.LSHL, 3).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 96); + oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 104); + oV = iV.lanewise(VectorOperators.LSHL, 21).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 112); + oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 2); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 120); + oV = iV.lanewise(VectorOperators.LSHL, 7).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 128); + oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 136); + oV = iV.lanewise(VectorOperators.LSHL, 25).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 7); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 144); + oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 152); + oV = iV.lanewise(VectorOperators.LSHL, 11).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 160); + oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 168); + oV = iV.lanewise(VectorOperators.LSHL, 29).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 3); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 176); + oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 184); + oV = iV.lanewise(VectorOperators.LSHL, 15).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 192); + oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 8); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 200); + oV = iV.lanewise(VectorOperators.LSHL, 1).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 208); + oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 216); + oV = iV.lanewise(VectorOperators.LSHL, 19).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 224); + oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 4); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 232); + oV = iV.lanewise(VectorOperators.LSHL, 5).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 240); + oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 248); + oV = iV.lanewise(VectorOperators.LSHL, 23).or(oV); + + oV.intoArray(out, outpos); + } + + private static void fastpackNoMask10(final int[] in, int inpos, + final int[] out, int outpos) { + var iV = IntVector.fromArray(SPECIES_512, in, inpos); + var oV = iV; + iV = IntVector.fromArray(SPECIES_512, in, inpos + 16); + oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 32); + oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 48); + oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + oV = iV.lanewise(VectorOperators.LSHR, 2); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 64); + oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 80); + oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 96); + oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 4); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 112); + oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 128); + oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 144); + oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 6); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 160); + oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 176); + oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 192); + oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 8); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 208); + oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 224); + oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 240); + oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV); + + oV.intoArray(out, outpos); + } + + private static void fastpackNoMask11(final int[] in, int inpos, + final int[] out, int outpos) { + var iV = IntVector.fromArray(SPECIES_256, in, inpos); + var oV = iV; + iV = IntVector.fromArray(SPECIES_256, in, inpos + 8); + oV = iV.lanewise(VectorOperators.LSHL, 11).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 16); + oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 10); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 24); + oV = iV.lanewise(VectorOperators.LSHL, 1).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 32); + oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 40); + oV = iV.lanewise(VectorOperators.LSHL, 23).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 9); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 48); + oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 56); + oV = iV.lanewise(VectorOperators.LSHL, 13).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 64); + oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 8); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 72); + oV = iV.lanewise(VectorOperators.LSHL, 3).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 80); + oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 88); + oV = iV.lanewise(VectorOperators.LSHL, 25).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 7); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 96); + oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 104); + oV = iV.lanewise(VectorOperators.LSHL, 15).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 112); + oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 6); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 120); + oV = iV.lanewise(VectorOperators.LSHL, 5).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 128); + oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 136); + oV = iV.lanewise(VectorOperators.LSHL, 27).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 5); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 144); + oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 152); + oV = iV.lanewise(VectorOperators.LSHL, 17).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 160); + oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 4); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 168); + oV = iV.lanewise(VectorOperators.LSHL, 7).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 176); + oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 184); + oV = iV.lanewise(VectorOperators.LSHL, 29).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 3); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 192); + oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 200); + oV = iV.lanewise(VectorOperators.LSHL, 19).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 208); + oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 2); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 216); + oV = iV.lanewise(VectorOperators.LSHL, 9).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 224); + oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 232); + oV = iV.lanewise(VectorOperators.LSHL, 31).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 1); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 240); + oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 248); + oV = iV.lanewise(VectorOperators.LSHL, 21).or(oV); + + oV.intoArray(out, outpos); + } + + private static void fastpackNoMask12(final int[] in, int inpos, + final int[] out, int outpos) { + var iV = IntVector.fromArray(SPECIES_512, in, inpos); + var oV = iV; + iV = IntVector.fromArray(SPECIES_512, in, inpos + 16); + oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 32); + oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + oV = iV.lanewise(VectorOperators.LSHR, 8); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 48); + oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 64); + oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 80); + oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 4); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 96); + oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 112); + oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = oV.zero(SPECIES_512); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 128); + oV = iV.or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 144); + oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 160); + oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 8); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 176); + oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 192); + oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 208); + oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 4); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 224); + oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 240); + oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV); + + oV.intoArray(out, outpos); + } + + private static void fastpackNoMask13(final int[] in, int inpos, + final int[] out, int outpos) { + var iV = IntVector.fromArray(SPECIES_256, in, inpos); + var oV = iV; + iV = IntVector.fromArray(SPECIES_256, in, inpos + 8); + oV = iV.lanewise(VectorOperators.LSHL, 13).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 16); + oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 6); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 24); + oV = iV.lanewise(VectorOperators.LSHL, 7).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 32); + oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 12); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 40); + oV = iV.lanewise(VectorOperators.LSHL, 1).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 48); + oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 56); + oV = iV.lanewise(VectorOperators.LSHL, 27).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 5); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 64); + oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 72); + oV = iV.lanewise(VectorOperators.LSHL, 21).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 11); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 80); + oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 88); + oV = iV.lanewise(VectorOperators.LSHL, 15).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 96); + oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 4); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 104); + oV = iV.lanewise(VectorOperators.LSHL, 9).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 112); + oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 10); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 120); + oV = iV.lanewise(VectorOperators.LSHL, 3).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 128); + oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 136); + oV = iV.lanewise(VectorOperators.LSHL, 29).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 3); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 144); + oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 152); + oV = iV.lanewise(VectorOperators.LSHL, 23).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 9); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 160); + oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 168); + oV = iV.lanewise(VectorOperators.LSHL, 17).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 176); + oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 2); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 184); + oV = iV.lanewise(VectorOperators.LSHL, 11).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 192); + oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 8); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 200); + oV = iV.lanewise(VectorOperators.LSHL, 5).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 208); + oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 216); + oV = iV.lanewise(VectorOperators.LSHL, 31).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 1); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 224); + oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 232); + oV = iV.lanewise(VectorOperators.LSHL, 25).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 7); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 240); + oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 248); + oV = iV.lanewise(VectorOperators.LSHL, 19).or(oV); + + oV.intoArray(out, outpos); + } + + private static void fastpackNoMask14(final int[] in, int inpos, + final int[] out, int outpos) { + var iV = IntVector.fromArray(SPECIES_512, in, inpos); + var oV = iV; + iV = IntVector.fromArray(SPECIES_512, in, inpos + 16); + oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 32); + oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + oV = iV.lanewise(VectorOperators.LSHR, 4); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 48); + oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 64); + oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 8); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 80); + oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 96); + oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 12); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 112); + oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 128); + oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 144); + oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 2); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 160); + oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 176); + oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 6); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 192); + oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 208); + oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 10); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 224); + oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 240); + oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV); + + oV.intoArray(out, outpos); + } + + private static void fastpackNoMask15(final int[] in, int inpos, + final int[] out, int outpos) { + var iV = IntVector.fromArray(SPECIES_256, in, inpos); + var oV = iV; + iV = IntVector.fromArray(SPECIES_256, in, inpos + 8); + oV = iV.lanewise(VectorOperators.LSHL, 15).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 16); + oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 2); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 24); + oV = iV.lanewise(VectorOperators.LSHL, 13).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 32); + oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 4); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 40); + oV = iV.lanewise(VectorOperators.LSHL, 11).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 48); + oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 6); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 56); + oV = iV.lanewise(VectorOperators.LSHL, 9).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 64); + oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 8); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 72); + oV = iV.lanewise(VectorOperators.LSHL, 7).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 80); + oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 10); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 88); + oV = iV.lanewise(VectorOperators.LSHL, 5).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 96); + oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 12); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 104); + oV = iV.lanewise(VectorOperators.LSHL, 3).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 112); + oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 14); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 120); + oV = iV.lanewise(VectorOperators.LSHL, 1).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 128); + oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 136); + oV = iV.lanewise(VectorOperators.LSHL, 31).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 1); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 144); + oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 152); + oV = iV.lanewise(VectorOperators.LSHL, 29).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 3); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 160); + oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 168); + oV = iV.lanewise(VectorOperators.LSHL, 27).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 5); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 176); + oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 184); + oV = iV.lanewise(VectorOperators.LSHL, 25).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 7); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 192); + oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 200); + oV = iV.lanewise(VectorOperators.LSHL, 23).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 9); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 208); + oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 216); + oV = iV.lanewise(VectorOperators.LSHL, 21).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 11); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 224); + oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 232); + oV = iV.lanewise(VectorOperators.LSHL, 19).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 13); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 240); + oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 248); + oV = iV.lanewise(VectorOperators.LSHL, 17).or(oV); + + oV.intoArray(out, outpos); + } + + private static void fastpackNoMask16(final int[] in, int inpos, + final int[] out, int outpos) { + var iV = IntVector.fromArray(SPECIES_512, in, inpos); + var oV = iV; + iV = IntVector.fromArray(SPECIES_512, in, inpos + 16); + oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + oV = oV.zero(SPECIES_512); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 32); + oV = iV.or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 48); + oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = oV.zero(SPECIES_512); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 64); + oV = iV.or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 80); + oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = oV.zero(SPECIES_512); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 96); + oV = iV.or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 112); + oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = oV.zero(SPECIES_512); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 128); + oV = iV.or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 144); + oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = oV.zero(SPECIES_512); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 160); + oV = iV.or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 176); + oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = oV.zero(SPECIES_512); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 192); + oV = iV.or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 208); + oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = oV.zero(SPECIES_512); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 224); + oV = iV.or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 240); + oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + } + + private static void fastpackNoMask17(final int[] in, int inpos, + final int[] out, int outpos) { + var iV = IntVector.fromArray(SPECIES_256, in, inpos); + var oV = iV; + iV = IntVector.fromArray(SPECIES_256, in, inpos + 8); + oV = iV.lanewise(VectorOperators.LSHL, 17).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 15); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 16); + oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 24); + oV = iV.lanewise(VectorOperators.LSHL, 19).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 13); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 32); + oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 40); + oV = iV.lanewise(VectorOperators.LSHL, 21).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 11); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 48); + oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 56); + oV = iV.lanewise(VectorOperators.LSHL, 23).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 9); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 64); + oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 72); + oV = iV.lanewise(VectorOperators.LSHL, 25).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 7); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 80); + oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 88); + oV = iV.lanewise(VectorOperators.LSHL, 27).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 5); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 96); + oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 104); + oV = iV.lanewise(VectorOperators.LSHL, 29).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 3); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 112); + oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 120); + oV = iV.lanewise(VectorOperators.LSHL, 31).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 1); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 128); + oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 16); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 136); + oV = iV.lanewise(VectorOperators.LSHL, 1).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 144); + oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 14); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 152); + oV = iV.lanewise(VectorOperators.LSHL, 3).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 160); + oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 12); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 168); + oV = iV.lanewise(VectorOperators.LSHL, 5).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 176); + oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 10); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 184); + oV = iV.lanewise(VectorOperators.LSHL, 7).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 192); + oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 8); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 200); + oV = iV.lanewise(VectorOperators.LSHL, 9).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 208); + oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 6); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 216); + oV = iV.lanewise(VectorOperators.LSHL, 11).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 224); + oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 4); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 232); + oV = iV.lanewise(VectorOperators.LSHL, 13).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 240); + oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 2); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 248); + oV = iV.lanewise(VectorOperators.LSHL, 15).or(oV); + + oV.intoArray(out, outpos); + } + + private static void fastpackNoMask18(final int[] in, int inpos, + final int[] out, int outpos) { + var iV = IntVector.fromArray(SPECIES_512, in, inpos); + var oV = iV; + iV = IntVector.fromArray(SPECIES_512, in, inpos + 16); + oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + oV = iV.lanewise(VectorOperators.LSHR, 14); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 32); + oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 48); + oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 10); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 64); + oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 80); + oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 6); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 96); + oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 112); + oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 2); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 128); + oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 16); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 144); + oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 160); + oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 12); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 176); + oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 192); + oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 8); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 208); + oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 224); + oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 4); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 240); + oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV); + + oV.intoArray(out, outpos); + } + + private static void fastpackNoMask19(final int[] in, int inpos, + final int[] out, int outpos) { + var iV = IntVector.fromArray(SPECIES_256, in, inpos); + var oV = iV; + iV = IntVector.fromArray(SPECIES_256, in, inpos + 8); + oV = iV.lanewise(VectorOperators.LSHL, 19).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 13); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 16); + oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 24); + oV = iV.lanewise(VectorOperators.LSHL, 25).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 7); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 32); + oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 40); + oV = iV.lanewise(VectorOperators.LSHL, 31).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 1); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 48); + oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 14); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 56); + oV = iV.lanewise(VectorOperators.LSHL, 5).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 64); + oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 8); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 72); + oV = iV.lanewise(VectorOperators.LSHL, 11).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 80); + oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 2); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 88); + oV = iV.lanewise(VectorOperators.LSHL, 17).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 15); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 96); + oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 104); + oV = iV.lanewise(VectorOperators.LSHL, 23).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 9); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 112); + oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 120); + oV = iV.lanewise(VectorOperators.LSHL, 29).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 3); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 128); + oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 16); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 136); + oV = iV.lanewise(VectorOperators.LSHL, 3).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 144); + oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 10); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 152); + oV = iV.lanewise(VectorOperators.LSHL, 9).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 160); + oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 4); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 168); + oV = iV.lanewise(VectorOperators.LSHL, 15).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 17); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 176); + oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 184); + oV = iV.lanewise(VectorOperators.LSHL, 21).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 11); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 192); + oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 200); + oV = iV.lanewise(VectorOperators.LSHL, 27).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 5); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 208); + oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 18); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 216); + oV = iV.lanewise(VectorOperators.LSHL, 1).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 224); + oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 12); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 232); + oV = iV.lanewise(VectorOperators.LSHL, 7).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 240); + oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 6); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 248); + oV = iV.lanewise(VectorOperators.LSHL, 13).or(oV); + + oV.intoArray(out, outpos); + } + + private static void fastpackNoMask20(final int[] in, int inpos, + final int[] out, int outpos) { + var iV = IntVector.fromArray(SPECIES_512, in, inpos); + var oV = iV; + iV = IntVector.fromArray(SPECIES_512, in, inpos + 16); + oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + oV = iV.lanewise(VectorOperators.LSHR, 12); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 32); + oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 48); + oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 4); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 64); + oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 16); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 80); + oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 96); + oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 8); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 112); + oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = oV.zero(SPECIES_512); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 128); + oV = iV.or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 144); + oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 12); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 160); + oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 176); + oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 4); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 192); + oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 16); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 208); + oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 224); + oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 8); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 240); + oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV); + + oV.intoArray(out, outpos); + } + + private static void fastpackNoMask21(final int[] in, int inpos, + final int[] out, int outpos) { + var iV = IntVector.fromArray(SPECIES_256, in, inpos); + var oV = iV; + iV = IntVector.fromArray(SPECIES_256, in, inpos + 8); + oV = iV.lanewise(VectorOperators.LSHL, 21).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 11); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 16); + oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 24); + oV = iV.lanewise(VectorOperators.LSHL, 31).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 1); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 32); + oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 12); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 40); + oV = iV.lanewise(VectorOperators.LSHL, 9).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 48); + oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 2); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 56); + oV = iV.lanewise(VectorOperators.LSHL, 19).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 13); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 64); + oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 72); + oV = iV.lanewise(VectorOperators.LSHL, 29).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 3); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 80); + oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 14); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 88); + oV = iV.lanewise(VectorOperators.LSHL, 7).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 96); + oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 4); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 104); + oV = iV.lanewise(VectorOperators.LSHL, 17).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 15); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 112); + oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 120); + oV = iV.lanewise(VectorOperators.LSHL, 27).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 5); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 128); + oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 16); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 136); + oV = iV.lanewise(VectorOperators.LSHL, 5).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 144); + oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 6); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 152); + oV = iV.lanewise(VectorOperators.LSHL, 15).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 17); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 160); + oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 168); + oV = iV.lanewise(VectorOperators.LSHL, 25).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 7); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 176); + oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 18); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 184); + oV = iV.lanewise(VectorOperators.LSHL, 3).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 192); + oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 8); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 200); + oV = iV.lanewise(VectorOperators.LSHL, 13).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 19); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 208); + oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 216); + oV = iV.lanewise(VectorOperators.LSHL, 23).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 9); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 224); + oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 20); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 232); + oV = iV.lanewise(VectorOperators.LSHL, 1).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 240); + oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 10); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 248); + oV = iV.lanewise(VectorOperators.LSHL, 11).or(oV); + + oV.intoArray(out, outpos); + } + + private static void fastpackNoMask22(final int[] in, int inpos, + final int[] out, int outpos) { + var iV = IntVector.fromArray(SPECIES_512, in, inpos); + var oV = iV; + iV = IntVector.fromArray(SPECIES_512, in, inpos + 16); + oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + oV = iV.lanewise(VectorOperators.LSHR, 10); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 32); + oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 20); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 48); + oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 64); + oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 8); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 80); + oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 18); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 96); + oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 112); + oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 6); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 128); + oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 16); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 144); + oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 160); + oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 4); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 176); + oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 14); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 192); + oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 208); + oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 2); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 224); + oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 12); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 240); + oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV); + + oV.intoArray(out, outpos); + } + + private static void fastpackNoMask23(final int[] in, int inpos, + final int[] out, int outpos) { + var iV = IntVector.fromArray(SPECIES_256, in, inpos); + var oV = iV; + iV = IntVector.fromArray(SPECIES_256, in, inpos + 8); + oV = iV.lanewise(VectorOperators.LSHL, 23).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 9); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 16); + oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 18); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 24); + oV = iV.lanewise(VectorOperators.LSHL, 5).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 32); + oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 4); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 40); + oV = iV.lanewise(VectorOperators.LSHL, 19).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 13); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 48); + oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 22); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 56); + oV = iV.lanewise(VectorOperators.LSHL, 1).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 64); + oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 8); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 72); + oV = iV.lanewise(VectorOperators.LSHL, 15).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 17); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 80); + oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 88); + oV = iV.lanewise(VectorOperators.LSHL, 29).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 3); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 96); + oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 12); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 104); + oV = iV.lanewise(VectorOperators.LSHL, 11).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 21); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 112); + oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 120); + oV = iV.lanewise(VectorOperators.LSHL, 25).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 7); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 128); + oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 16); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 136); + oV = iV.lanewise(VectorOperators.LSHL, 7).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 144); + oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 2); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 152); + oV = iV.lanewise(VectorOperators.LSHL, 21).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 11); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 160); + oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 20); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 168); + oV = iV.lanewise(VectorOperators.LSHL, 3).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 176); + oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 6); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 184); + oV = iV.lanewise(VectorOperators.LSHL, 17).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 15); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 192); + oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 200); + oV = iV.lanewise(VectorOperators.LSHL, 31).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 1); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 208); + oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 10); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 216); + oV = iV.lanewise(VectorOperators.LSHL, 13).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 19); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 224); + oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 232); + oV = iV.lanewise(VectorOperators.LSHL, 27).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 5); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 240); + oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 14); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 248); + oV = iV.lanewise(VectorOperators.LSHL, 9).or(oV); + + oV.intoArray(out, outpos); + } + + private static void fastpackNoMask24(final int[] in, int inpos, + final int[] out, int outpos) { + var iV = IntVector.fromArray(SPECIES_512, in, inpos); + var oV = iV; + iV = IntVector.fromArray(SPECIES_512, in, inpos + 16); + oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + oV = iV.lanewise(VectorOperators.LSHR, 8); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 32); + oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 16); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 48); + oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = oV.zero(SPECIES_512); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 64); + oV = iV.or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 80); + oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 8); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 96); + oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 16); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 112); + oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = oV.zero(SPECIES_512); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 128); + oV = iV.or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 144); + oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 8); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 160); + oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 16); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 176); + oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = oV.zero(SPECIES_512); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 192); + oV = iV.or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 208); + oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 8); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 224); + oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 16); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 240); + oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV); + + oV.intoArray(out, outpos); + } + + private static void fastpackNoMask25(final int[] in, int inpos, + final int[] out, int outpos) { + var iV = IntVector.fromArray(SPECIES_256, in, inpos); + var oV = iV; + iV = IntVector.fromArray(SPECIES_256, in, inpos + 8); + oV = iV.lanewise(VectorOperators.LSHL, 25).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 7); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 16); + oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 14); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 24); + oV = iV.lanewise(VectorOperators.LSHL, 11).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 21); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 32); + oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 40); + oV = iV.lanewise(VectorOperators.LSHL, 29).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 3); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 48); + oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 10); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 56); + oV = iV.lanewise(VectorOperators.LSHL, 15).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 17); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 64); + oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 24); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 72); + oV = iV.lanewise(VectorOperators.LSHL, 1).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 80); + oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 6); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 88); + oV = iV.lanewise(VectorOperators.LSHL, 19).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 13); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 96); + oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 20); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 104); + oV = iV.lanewise(VectorOperators.LSHL, 5).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 112); + oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 2); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 120); + oV = iV.lanewise(VectorOperators.LSHL, 23).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 9); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 128); + oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 16); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 136); + oV = iV.lanewise(VectorOperators.LSHL, 9).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 23); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 144); + oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 152); + oV = iV.lanewise(VectorOperators.LSHL, 27).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 5); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 160); + oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 12); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 168); + oV = iV.lanewise(VectorOperators.LSHL, 13).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 19); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 176); + oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 184); + oV = iV.lanewise(VectorOperators.LSHL, 31).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 1); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 192); + oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 8); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 200); + oV = iV.lanewise(VectorOperators.LSHL, 17).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 15); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 208); + oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 22); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 216); + oV = iV.lanewise(VectorOperators.LSHL, 3).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 224); + oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 4); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 232); + oV = iV.lanewise(VectorOperators.LSHL, 21).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 11); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 240); + oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 18); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 248); + oV = iV.lanewise(VectorOperators.LSHL, 7).or(oV); + + oV.intoArray(out, outpos); + } + + private static void fastpackNoMask26(final int[] in, int inpos, + final int[] out, int outpos) { + var iV = IntVector.fromArray(SPECIES_512, in, inpos); + var oV = iV; + iV = IntVector.fromArray(SPECIES_512, in, inpos + 16); + oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + oV = iV.lanewise(VectorOperators.LSHR, 6); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 32); + oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 12); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 48); + oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 18); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 64); + oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 24); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 80); + oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 96); + oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 4); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 112); + oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 10); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 128); + oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 16); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 144); + oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 22); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 160); + oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 176); + oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 2); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 192); + oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 8); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 208); + oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 14); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 224); + oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 20); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 240); + oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV); + + oV.intoArray(out, outpos); + } + + private static void fastpackNoMask27(final int[] in, int inpos, + final int[] out, int outpos) { + var iV = IntVector.fromArray(SPECIES_256, in, inpos); + var oV = iV; + iV = IntVector.fromArray(SPECIES_256, in, inpos + 8); + oV = iV.lanewise(VectorOperators.LSHL, 27).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 5); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 16); + oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 10); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 24); + oV = iV.lanewise(VectorOperators.LSHL, 17).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 15); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 32); + oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 20); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 40); + oV = iV.lanewise(VectorOperators.LSHL, 7).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 25); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 48); + oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 56); + oV = iV.lanewise(VectorOperators.LSHL, 29).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 3); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 64); + oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 8); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 72); + oV = iV.lanewise(VectorOperators.LSHL, 19).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 13); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 80); + oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 18); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 88); + oV = iV.lanewise(VectorOperators.LSHL, 9).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 23); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 96); + oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 104); + oV = iV.lanewise(VectorOperators.LSHL, 31).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 1); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 112); + oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 6); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 120); + oV = iV.lanewise(VectorOperators.LSHL, 21).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 11); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 128); + oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 16); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 136); + oV = iV.lanewise(VectorOperators.LSHL, 11).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 21); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 144); + oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 26); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 152); + oV = iV.lanewise(VectorOperators.LSHL, 1).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 160); + oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 4); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 168); + oV = iV.lanewise(VectorOperators.LSHL, 23).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 9); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 176); + oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 14); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 184); + oV = iV.lanewise(VectorOperators.LSHL, 13).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 19); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 192); + oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 24); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 200); + oV = iV.lanewise(VectorOperators.LSHL, 3).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 208); + oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 2); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 216); + oV = iV.lanewise(VectorOperators.LSHL, 25).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 7); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 224); + oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 12); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 232); + oV = iV.lanewise(VectorOperators.LSHL, 15).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 17); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 240); + oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 22); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 248); + oV = iV.lanewise(VectorOperators.LSHL, 5).or(oV); + + oV.intoArray(out, outpos); + } + + private static void fastpackNoMask28(final int[] in, int inpos, + final int[] out, int outpos) { + var iV = IntVector.fromArray(SPECIES_512, in, inpos); + var oV = iV; + iV = IntVector.fromArray(SPECIES_512, in, inpos + 16); + oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + oV = iV.lanewise(VectorOperators.LSHR, 4); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 32); + oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 8); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 48); + oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 12); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 64); + oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 16); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 80); + oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 20); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 96); + oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 24); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 112); + oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = oV.zero(SPECIES_512); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 128); + oV = iV.or(oV); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 144); + oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 4); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 160); + oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 8); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 176); + oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 12); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 192); + oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 16); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 208); + oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 20); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 224); + oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 24); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 240); + oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV); + + oV.intoArray(out, outpos); + } + + private static void fastpackNoMask29(final int[] in, int inpos, + final int[] out, int outpos) { + var iV = IntVector.fromArray(SPECIES_256, in, inpos); + var oV = iV; + iV = IntVector.fromArray(SPECIES_256, in, inpos + 8); + oV = iV.lanewise(VectorOperators.LSHL, 29).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 3); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 16); + oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 6); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 24); + oV = iV.lanewise(VectorOperators.LSHL, 23).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 9); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 32); + oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 12); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 40); + oV = iV.lanewise(VectorOperators.LSHL, 17).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 15); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 48); + oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 18); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 56); + oV = iV.lanewise(VectorOperators.LSHL, 11).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 21); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 64); + oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 24); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 72); + oV = iV.lanewise(VectorOperators.LSHL, 5).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 27); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 80); + oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 88); + oV = iV.lanewise(VectorOperators.LSHL, 31).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 1); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 96); + oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 4); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 104); + oV = iV.lanewise(VectorOperators.LSHL, 25).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 7); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 112); + oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 10); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 120); + oV = iV.lanewise(VectorOperators.LSHL, 19).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 13); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 128); + oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 16); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 136); + oV = iV.lanewise(VectorOperators.LSHL, 13).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 19); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 144); + oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 22); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 152); + oV = iV.lanewise(VectorOperators.LSHL, 7).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 25); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 160); + oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 28); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 168); + oV = iV.lanewise(VectorOperators.LSHL, 1).or(oV); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 176); + oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 2); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 184); + oV = iV.lanewise(VectorOperators.LSHL, 27).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 5); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 192); + oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 8); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 200); + oV = iV.lanewise(VectorOperators.LSHL, 21).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 11); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 208); + oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 14); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 216); + oV = iV.lanewise(VectorOperators.LSHL, 15).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 17); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 224); + oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 20); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 232); + oV = iV.lanewise(VectorOperators.LSHL, 9).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 23); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 240); + oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 26); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 248); + oV = iV.lanewise(VectorOperators.LSHL, 3).or(oV); + + oV.intoArray(out, outpos); + } + + private static void fastpackNoMask30(final int[] in, int inpos, + final int[] out, int outpos) { + var iV = IntVector.fromArray(SPECIES_512, in, inpos); + var oV = iV; + iV = IntVector.fromArray(SPECIES_512, in, inpos + 16); + oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + oV = iV.lanewise(VectorOperators.LSHR, 2); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 32); + oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 4); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 48); + oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 6); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 64); + oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 8); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 80); + oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 10); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 96); + oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 12); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 112); + oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 14); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 128); + oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 16); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 144); + oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 18); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 160); + oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 20); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 176); + oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 22); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 192); + oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 24); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 208); + oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 26); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 224); + oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 28); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 240); + oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV); + + oV.intoArray(out, outpos); + } + + private static void fastpackNoMask31(final int[] in, int inpos, + final int[] out, int outpos) { + var iV = IntVector.fromArray(SPECIES_256, in, inpos); + var oV = iV; + iV = IntVector.fromArray(SPECIES_256, in, inpos + 8); + oV = iV.lanewise(VectorOperators.LSHL, 31).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 1); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 16); + oV = iV.lanewise(VectorOperators.LSHL, 30).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 2); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 24); + oV = iV.lanewise(VectorOperators.LSHL, 29).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 3); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 32); + oV = iV.lanewise(VectorOperators.LSHL, 28).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 4); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 40); + oV = iV.lanewise(VectorOperators.LSHL, 27).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 5); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 48); + oV = iV.lanewise(VectorOperators.LSHL, 26).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 6); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 56); + oV = iV.lanewise(VectorOperators.LSHL, 25).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 7); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 64); + oV = iV.lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 8); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 72); + oV = iV.lanewise(VectorOperators.LSHL, 23).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 9); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 80); + oV = iV.lanewise(VectorOperators.LSHL, 22).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 10); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 88); + oV = iV.lanewise(VectorOperators.LSHL, 21).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 11); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 96); + oV = iV.lanewise(VectorOperators.LSHL, 20).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 12); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 104); + oV = iV.lanewise(VectorOperators.LSHL, 19).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 13); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 112); + oV = iV.lanewise(VectorOperators.LSHL, 18).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 14); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 120); + oV = iV.lanewise(VectorOperators.LSHL, 17).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 15); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 128); + oV = iV.lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 16); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 136); + oV = iV.lanewise(VectorOperators.LSHL, 15).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 17); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 144); + oV = iV.lanewise(VectorOperators.LSHL, 14).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 18); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 152); + oV = iV.lanewise(VectorOperators.LSHL, 13).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 19); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 160); + oV = iV.lanewise(VectorOperators.LSHL, 12).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 20); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 168); + oV = iV.lanewise(VectorOperators.LSHL, 11).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 21); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 176); + oV = iV.lanewise(VectorOperators.LSHL, 10).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 22); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 184); + oV = iV.lanewise(VectorOperators.LSHL, 9).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 23); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 192); + oV = iV.lanewise(VectorOperators.LSHL, 8).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 24); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 200); + oV = iV.lanewise(VectorOperators.LSHL, 7).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 25); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 208); + oV = iV.lanewise(VectorOperators.LSHL, 6).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 26); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 216); + oV = iV.lanewise(VectorOperators.LSHL, 5).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 27); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 224); + oV = iV.lanewise(VectorOperators.LSHL, 4).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 28); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 232); + oV = iV.lanewise(VectorOperators.LSHL, 3).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 29); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 240); + oV = iV.lanewise(VectorOperators.LSHL, 2).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 30); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 248); + oV = iV.lanewise(VectorOperators.LSHL, 1).or(oV); + + oV.intoArray(out, outpos); + } + + private static void fastunpack1(final int[] in, int inpos, final int[] out, + int outpos) { + var iV = IntVector.fromArray(SPECIES_256, in, inpos); + iV.and(MASK_1).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 1).and(MASK_1).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 2).and(MASK_1).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 3).and(MASK_1).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 4).and(MASK_1).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 5).and(MASK_1).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 6).and(MASK_1).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 7).and(MASK_1).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 8).and(MASK_1).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 9).and(MASK_1).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 10).and(MASK_1).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 11).and(MASK_1).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 12).and(MASK_1).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 13).and(MASK_1).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 14).and(MASK_1).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 15).and(MASK_1).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 16).and(MASK_1).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 17).and(MASK_1).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 18).and(MASK_1).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 19).and(MASK_1).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 20).and(MASK_1).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 21).and(MASK_1).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 22).and(MASK_1).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 23).and(MASK_1).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 24).and(MASK_1).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 25).and(MASK_1).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 26).and(MASK_1).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 27).and(MASK_1).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 28).and(MASK_1).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 29).and(MASK_1).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 30).and(MASK_1).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 31).and(MASK_1).intoArray(out, outpos); + outpos += VLEN_256; + } + + private static void fastunpack2(final int[] in, int inpos, final int[] out, + int outpos) { + var iV = IntVector.fromArray(SPECIES_512, in, inpos); + iV.and(MASK_2).intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 2).and(MASK_2).intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 4).and(MASK_2).intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 6).and(MASK_2).intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 8).and(MASK_2).intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 10).and(MASK_2).intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 12).and(MASK_2).intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 14).and(MASK_2).intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 16).and(MASK_2).intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 18).and(MASK_2).intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 20).and(MASK_2).intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 22).and(MASK_2).intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 24).and(MASK_2).intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 26).and(MASK_2).intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 28).and(MASK_2).intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 30).and(MASK_2).intoArray(out, outpos); + outpos += VLEN_512; + } + + private static void fastunpack3(final int[] in, int inpos, final int[] out, + int outpos) { + var iV = IntVector.fromArray(SPECIES_256, in, inpos); + iV.and(MASK_3).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 3).and(MASK_3).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 6).and(MASK_3).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 9).and(MASK_3).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 12).and(MASK_3).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 15).and(MASK_3).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 18).and(MASK_3).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 21).and(MASK_3).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 24).and(MASK_3).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 27).and(MASK_3).intoArray(out, outpos); + outpos += VLEN_256; + + var oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_3); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 8); + oV = iV.and(1).lanewise(VectorOperators.LSHL, 2).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 1).and(MASK_3).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 4).and(MASK_3).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 7).and(MASK_3).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 10).and(MASK_3).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 13).and(MASK_3).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 16).and(MASK_3).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 19).and(MASK_3).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 22).and(MASK_3).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 25).and(MASK_3).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 28).and(MASK_3).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 31).and(MASK_3); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 16); + oV = iV.and(3).lanewise(VectorOperators.LSHL, 1).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 2).and(MASK_3).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 5).and(MASK_3).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 8).and(MASK_3).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 11).and(MASK_3).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 14).and(MASK_3).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 17).and(MASK_3).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 20).and(MASK_3).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 23).and(MASK_3).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 26).and(MASK_3).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 29).and(MASK_3).intoArray(out, outpos); + outpos += VLEN_256; + } + + private static void fastunpack4(final int[] in, int inpos, final int[] out, + int outpos) { + var iV = IntVector.fromArray(SPECIES_512, in, inpos); + iV.and(MASK_4).intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 4).and(MASK_4).intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 8).and(MASK_4).intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 12).and(MASK_4).intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 16).and(MASK_4).intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 20).and(MASK_4).intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 24).and(MASK_4).intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 28).and(MASK_4).intoArray(out, outpos); + outpos += VLEN_512; + + var oV = iV.and(MASK_4); + oV = oV.zero(SPECIES_512); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 16); + oV = iV.and(0xf).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 4).and(MASK_4).intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 8).and(MASK_4).intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 12).and(MASK_4).intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 16).and(MASK_4).intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 20).and(MASK_4).intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 24).and(MASK_4).intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 28).and(MASK_4).intoArray(out, outpos); + outpos += VLEN_512; + } + + private static void fastunpack5(final int[] in, int inpos, final int[] out, + int outpos) { + var iV = IntVector.fromArray(SPECIES_256, in, inpos); + iV.and(MASK_5).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 5).and(MASK_5).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 10).and(MASK_5).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 15).and(MASK_5).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 20).and(MASK_5).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 25).and(MASK_5).intoArray(out, outpos); + outpos += VLEN_256; + + var oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_5); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 8); + oV = iV.and(7).lanewise(VectorOperators.LSHL, 2).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 3).and(MASK_5).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 8).and(MASK_5).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 13).and(MASK_5).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 18).and(MASK_5).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 23).and(MASK_5).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_5); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 16); + oV = iV.and(1).lanewise(VectorOperators.LSHL, 4).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 1).and(MASK_5).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 6).and(MASK_5).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 11).and(MASK_5).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 16).and(MASK_5).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 21).and(MASK_5).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 26).and(MASK_5).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 31).and(MASK_5); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 24); + oV = iV.and(0xf).lanewise(VectorOperators.LSHL, 1).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 4).and(MASK_5).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 9).and(MASK_5).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 14).and(MASK_5).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 19).and(MASK_5).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 24).and(MASK_5).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 29).and(MASK_5); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 32); + oV = iV.and(3).lanewise(VectorOperators.LSHL, 3).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 2).and(MASK_5).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 7).and(MASK_5).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 12).and(MASK_5).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 17).and(MASK_5).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 22).and(MASK_5).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 27).and(MASK_5).intoArray(out, outpos); + outpos += VLEN_256; + } + + private static void fastunpack6(final int[] in, int inpos, final int[] out, + int outpos) { + var iV = IntVector.fromArray(SPECIES_512, in, inpos); + iV.and(MASK_6).intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 6).and(MASK_6).intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 12).and(MASK_6).intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 18).and(MASK_6).intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 24).and(MASK_6).intoArray(out, outpos); + outpos += VLEN_512; + + var oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_6); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 16); + oV = iV.and(0xf).lanewise(VectorOperators.LSHL, 2).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 4).and(MASK_6).intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 10).and(MASK_6).intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 16).and(MASK_6).intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 22).and(MASK_6).intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_6); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 32); + oV = iV.and(3).lanewise(VectorOperators.LSHL, 4).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 2).and(MASK_6).intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 8).and(MASK_6).intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 14).and(MASK_6).intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 20).and(MASK_6).intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 26).and(MASK_6).intoArray(out, outpos); + outpos += VLEN_512; + } + + private static void fastunpack7(final int[] in, int inpos, final int[] out, + int outpos) { + var iV = IntVector.fromArray(SPECIES_256, in, inpos); + iV.and(MASK_7).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 7).and(MASK_7).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 14).and(MASK_7).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 21).and(MASK_7).intoArray(out, outpos); + outpos += VLEN_256; + + var oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_7); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 8); + oV = iV.and(7).lanewise(VectorOperators.LSHL, 4).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 3).and(MASK_7).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 10).and(MASK_7).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 17).and(MASK_7).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 24).and(MASK_7).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 31).and(MASK_7); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 16); + oV = iV.and(0x3f).lanewise(VectorOperators.LSHL, 1).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 6).and(MASK_7).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 13).and(MASK_7).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 20).and(MASK_7).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 27).and(MASK_7); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 24); + oV = iV.and(3).lanewise(VectorOperators.LSHL, 5).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 2).and(MASK_7).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 9).and(MASK_7).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 16).and(MASK_7).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 23).and(MASK_7).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_7); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 32); + oV = iV.and(0x1f).lanewise(VectorOperators.LSHL, 2).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 5).and(MASK_7).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 12).and(MASK_7).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 19).and(MASK_7).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_7); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 40); + oV = iV.and(1).lanewise(VectorOperators.LSHL, 6).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 1).and(MASK_7).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 8).and(MASK_7).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 15).and(MASK_7).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 22).and(MASK_7).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 29).and(MASK_7); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 48); + oV = iV.and(0xf).lanewise(VectorOperators.LSHL, 3).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 4).and(MASK_7).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 11).and(MASK_7).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 18).and(MASK_7).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 25).and(MASK_7).intoArray(out, outpos); + outpos += VLEN_256; + } + + private static void fastunpack8(final int[] in, int inpos, final int[] out, + int outpos) { + var iV = IntVector.fromArray(SPECIES_512, in, inpos); + iV.and(MASK_8).intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 8).and(MASK_8).intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 16).and(MASK_8).intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 24).and(MASK_8).intoArray(out, outpos); + outpos += VLEN_512; + + var oV = iV.and(MASK_8); + oV = oV.zero(SPECIES_512); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 16); + oV = iV.and(0xff).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 8).and(MASK_8).intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 16).and(MASK_8).intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 24).and(MASK_8).intoArray(out, outpos); + outpos += VLEN_512; + + oV = oV.zero(SPECIES_512); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 32); + oV = iV.and(0xff).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 8).and(MASK_8).intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 16).and(MASK_8).intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 24).and(MASK_8).intoArray(out, outpos); + outpos += VLEN_512; + + oV = oV.zero(SPECIES_512); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 48); + oV = iV.and(0xff).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 8).and(MASK_8).intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 16).and(MASK_8).intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 24).and(MASK_8).intoArray(out, outpos); + outpos += VLEN_512; + } + + private static void fastunpack9(final int[] in, int inpos, final int[] out, + int outpos) { + var iV = IntVector.fromArray(SPECIES_256, in, inpos); + iV.and(MASK_9).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 9).and(MASK_9).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 18).and(MASK_9).intoArray(out, outpos); + outpos += VLEN_256; + + var oV = iV.lanewise(VectorOperators.LSHR, 27).and(MASK_9); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 8); + oV = iV.and(0xf).lanewise(VectorOperators.LSHL, 5).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 4).and(MASK_9).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 13).and(MASK_9).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 22).and(MASK_9).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 31).and(MASK_9); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 16); + oV = iV.and(0xff).lanewise(VectorOperators.LSHL, 1).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 8).and(MASK_9).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 17).and(MASK_9).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_9); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 24); + oV = iV.and(7).lanewise(VectorOperators.LSHL, 6).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 3).and(MASK_9).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 12).and(MASK_9).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 21).and(MASK_9).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_9); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 32); + oV = iV.and(0x7f).lanewise(VectorOperators.LSHL, 2).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 7).and(MASK_9).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 16).and(MASK_9).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 25).and(MASK_9); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 40); + oV = iV.and(3).lanewise(VectorOperators.LSHL, 7).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 2).and(MASK_9).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 11).and(MASK_9).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 20).and(MASK_9).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 29).and(MASK_9); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 48); + oV = iV.and(0x3f).lanewise(VectorOperators.LSHL, 3).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 6).and(MASK_9).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 15).and(MASK_9).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_9); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 56); + oV = iV.and(1).lanewise(VectorOperators.LSHL, 8).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 1).and(MASK_9).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 10).and(MASK_9).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 19).and(MASK_9).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_9); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 64); + oV = iV.and(0x1f).lanewise(VectorOperators.LSHL, 4).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 5).and(MASK_9).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 14).and(MASK_9).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 23).and(MASK_9).intoArray(out, outpos); + outpos += VLEN_256; + } + + private static void fastunpack10(final int[] in, int inpos, final int[] out, + int outpos) { + var iV = IntVector.fromArray(SPECIES_512, in, inpos); + iV.and(MASK_10).intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 10).and(MASK_10).intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 20).and(MASK_10).intoArray(out, outpos); + outpos += VLEN_512; + + var oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_10); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 16); + oV = iV.and(0xff).lanewise(VectorOperators.LSHL, 2).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 8).and(MASK_10).intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 18).and(MASK_10).intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_10); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 32); + oV = iV.and(0x3f).lanewise(VectorOperators.LSHL, 4).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 6).and(MASK_10).intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 16).and(MASK_10).intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_10); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 48); + oV = iV.and(0xf).lanewise(VectorOperators.LSHL, 6).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 4).and(MASK_10).intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 14).and(MASK_10).intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_10); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 64); + oV = iV.and(3).lanewise(VectorOperators.LSHL, 8).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 2).and(MASK_10).intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 12).and(MASK_10).intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 22).and(MASK_10).intoArray(out, outpos); + outpos += VLEN_512; + } + + private static void fastunpack11(final int[] in, int inpos, final int[] out, + int outpos) { + var iV = IntVector.fromArray(SPECIES_256, in, inpos); + iV.and(MASK_11).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 11).and(MASK_11).intoArray(out, outpos); + outpos += VLEN_256; + + var oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_11); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 8); + oV = iV.and(1).lanewise(VectorOperators.LSHL, 10).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 1).and(MASK_11).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 12).and(MASK_11).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 23).and(MASK_11); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 16); + oV = iV.and(3).lanewise(VectorOperators.LSHL, 9).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 2).and(MASK_11).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 13).and(MASK_11).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_11); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 24); + oV = iV.and(7).lanewise(VectorOperators.LSHL, 8).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 3).and(MASK_11).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 14).and(MASK_11).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 25).and(MASK_11); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 32); + oV = iV.and(0xf).lanewise(VectorOperators.LSHL, 7).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 4).and(MASK_11).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 15).and(MASK_11).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_11); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 40); + oV = iV.and(0x1f).lanewise(VectorOperators.LSHL, 6).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 5).and(MASK_11).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 16).and(MASK_11).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 27).and(MASK_11); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 48); + oV = iV.and(0x3f).lanewise(VectorOperators.LSHL, 5).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 6).and(MASK_11).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 17).and(MASK_11).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_11); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 56); + oV = iV.and(0x7f).lanewise(VectorOperators.LSHL, 4).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 7).and(MASK_11).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 18).and(MASK_11).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 29).and(MASK_11); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 64); + oV = iV.and(0xff).lanewise(VectorOperators.LSHL, 3).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 8).and(MASK_11).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 19).and(MASK_11).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_11); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 72); + oV = iV.and(0x1ff).lanewise(VectorOperators.LSHL, 2).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 9).and(MASK_11).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 20).and(MASK_11).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 31).and(MASK_11); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 80); + oV = iV.and(0x3ff).lanewise(VectorOperators.LSHL, 1).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 10).and(MASK_11).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 21).and(MASK_11).intoArray(out, outpos); + outpos += VLEN_256; + } + + private static void fastunpack12(final int[] in, int inpos, final int[] out, + int outpos) { + var iV = IntVector.fromArray(SPECIES_512, in, inpos); + iV.and(MASK_12).intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 12).and(MASK_12).intoArray(out, outpos); + outpos += VLEN_512; + + var oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_12); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 16); + oV = iV.and(0xf).lanewise(VectorOperators.LSHL, 8).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 4).and(MASK_12).intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 16).and(MASK_12).intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_12); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 32); + oV = iV.and(0xff).lanewise(VectorOperators.LSHL, 4).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 8).and(MASK_12).intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 20).and(MASK_12).intoArray(out, outpos); + outpos += VLEN_512; + + oV = oV.zero(SPECIES_512); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 48); + oV = iV.and(0xfff).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 12).and(MASK_12).intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_12); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 64); + oV = iV.and(0xf).lanewise(VectorOperators.LSHL, 8).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 4).and(MASK_12).intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 16).and(MASK_12).intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_12); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 80); + oV = iV.and(0xff).lanewise(VectorOperators.LSHL, 4).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 8).and(MASK_12).intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 20).and(MASK_12).intoArray(out, outpos); + outpos += VLEN_512; + } + + private static void fastunpack13(final int[] in, int inpos, final int[] out, + int outpos) { + var iV = IntVector.fromArray(SPECIES_256, in, inpos); + iV.and(MASK_13).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 13).and(MASK_13).intoArray(out, outpos); + outpos += VLEN_256; + + var oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_13); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 8); + oV = iV.and(0x7f).lanewise(VectorOperators.LSHL, 6).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 7).and(MASK_13).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_13); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 16); + oV = iV.and(1).lanewise(VectorOperators.LSHL, 12).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 1).and(MASK_13).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 14).and(MASK_13).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 27).and(MASK_13); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 24); + oV = iV.and(0xff).lanewise(VectorOperators.LSHL, 5).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 8).and(MASK_13).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 21).and(MASK_13); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 32); + oV = iV.and(3).lanewise(VectorOperators.LSHL, 11).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 2).and(MASK_13).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 15).and(MASK_13).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_13); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 40); + oV = iV.and(0x1ff).lanewise(VectorOperators.LSHL, 4).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 9).and(MASK_13).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_13); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 48); + oV = iV.and(7).lanewise(VectorOperators.LSHL, 10).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 3).and(MASK_13).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 16).and(MASK_13).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 29).and(MASK_13); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 56); + oV = iV.and(0x3ff).lanewise(VectorOperators.LSHL, 3).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 10).and(MASK_13).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 23).and(MASK_13); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 64); + oV = iV.and(0xf).lanewise(VectorOperators.LSHL, 9).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 4).and(MASK_13).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 17).and(MASK_13).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_13); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 72); + oV = iV.and(0x7ff).lanewise(VectorOperators.LSHL, 2).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 11).and(MASK_13).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_13); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 80); + oV = iV.and(0x1f).lanewise(VectorOperators.LSHL, 8).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 5).and(MASK_13).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 18).and(MASK_13).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 31).and(MASK_13); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 88); + oV = iV.and(0xfff).lanewise(VectorOperators.LSHL, 1).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 12).and(MASK_13).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 25).and(MASK_13); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 96); + oV = iV.and(0x3f).lanewise(VectorOperators.LSHL, 7).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 6).and(MASK_13).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 19).and(MASK_13).intoArray(out, outpos); + outpos += VLEN_256; + } + + private static void fastunpack14(final int[] in, int inpos, final int[] out, + int outpos) { + var iV = IntVector.fromArray(SPECIES_512, in, inpos); + iV.and(MASK_14).intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 14).and(MASK_14).intoArray(out, outpos); + outpos += VLEN_512; + + var oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_14); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 16); + oV = iV.and(0x3ff).lanewise(VectorOperators.LSHL, 4).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 10).and(MASK_14).intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_14); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 32); + oV = iV.and(0x3f).lanewise(VectorOperators.LSHL, 8).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 6).and(MASK_14).intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_14); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 48); + oV = iV.and(3).lanewise(VectorOperators.LSHL, 12).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 2).and(MASK_14).intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 16).and(MASK_14).intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_14); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 64); + oV = iV.and(0xfff).lanewise(VectorOperators.LSHL, 2).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 12).and(MASK_14).intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_14); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 80); + oV = iV.and(0xff).lanewise(VectorOperators.LSHL, 6).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 8).and(MASK_14).intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_14); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 96); + oV = iV.and(0xf).lanewise(VectorOperators.LSHL, 10).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 4).and(MASK_14).intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 18).and(MASK_14).intoArray(out, outpos); + outpos += VLEN_512; + } + + private static void fastunpack15(final int[] in, int inpos, final int[] out, + int outpos) { + var iV = IntVector.fromArray(SPECIES_256, in, inpos); + iV.and(MASK_15).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 15).and(MASK_15).intoArray(out, outpos); + outpos += VLEN_256; + + var oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_15); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 8); + oV = iV.and(0x1fff).lanewise(VectorOperators.LSHL, 2).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 13).and(MASK_15).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_15); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 16); + oV = iV.and(0x7ff).lanewise(VectorOperators.LSHL, 4).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 11).and(MASK_15).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_15); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 24); + oV = iV.and(0x1ff).lanewise(VectorOperators.LSHL, 6).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 9).and(MASK_15).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_15); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 32); + oV = iV.and(0x7f).lanewise(VectorOperators.LSHL, 8).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 7).and(MASK_15).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_15); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 40); + oV = iV.and(0x1f).lanewise(VectorOperators.LSHL, 10).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 5).and(MASK_15).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_15); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 48); + oV = iV.and(7).lanewise(VectorOperators.LSHL, 12).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 3).and(MASK_15).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_15); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 56); + oV = iV.and(1).lanewise(VectorOperators.LSHL, 14).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 1).and(MASK_15).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 16).and(MASK_15).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 31).and(MASK_15); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 64); + oV = iV.and(0x3fff).lanewise(VectorOperators.LSHL, 1).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 14).and(MASK_15).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 29).and(MASK_15); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 72); + oV = iV.and(0xfff).lanewise(VectorOperators.LSHL, 3).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 12).and(MASK_15).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 27).and(MASK_15); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 80); + oV = iV.and(0x3ff).lanewise(VectorOperators.LSHL, 5).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 10).and(MASK_15).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 25).and(MASK_15); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 88); + oV = iV.and(0xff).lanewise(VectorOperators.LSHL, 7).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 8).and(MASK_15).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 23).and(MASK_15); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 96); + oV = iV.and(0x3f).lanewise(VectorOperators.LSHL, 9).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 6).and(MASK_15).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 21).and(MASK_15); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 104); + oV = iV.and(0xf).lanewise(VectorOperators.LSHL, 11).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 4).and(MASK_15).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 19).and(MASK_15); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 112); + oV = iV.and(3).lanewise(VectorOperators.LSHL, 13).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 2).and(MASK_15).intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 17).and(MASK_15).intoArray(out, outpos); + outpos += VLEN_256; + } + + private static void fastunpack16(final int[] in, int inpos, final int[] out, + int outpos) { + var iV = IntVector.fromArray(SPECIES_512, in, inpos); + iV.and(MASK_16).intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 16).and(MASK_16).intoArray(out, outpos); + outpos += VLEN_512; + + var oV = iV.and(MASK_16); + oV = oV.zero(SPECIES_512); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 16); + oV = iV.and(0xffff).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 16).and(MASK_16).intoArray(out, outpos); + outpos += VLEN_512; + + oV = oV.zero(SPECIES_512); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 32); + oV = iV.and(0xffff).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 16).and(MASK_16).intoArray(out, outpos); + outpos += VLEN_512; + + oV = oV.zero(SPECIES_512); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 48); + oV = iV.and(0xffff).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 16).and(MASK_16).intoArray(out, outpos); + outpos += VLEN_512; + + oV = oV.zero(SPECIES_512); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 64); + oV = iV.and(0xffff).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 16).and(MASK_16).intoArray(out, outpos); + outpos += VLEN_512; + + oV = oV.zero(SPECIES_512); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 80); + oV = iV.and(0xffff).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 16).and(MASK_16).intoArray(out, outpos); + outpos += VLEN_512; + + oV = oV.zero(SPECIES_512); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 96); + oV = iV.and(0xffff).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 16).and(MASK_16).intoArray(out, outpos); + outpos += VLEN_512; + + oV = oV.zero(SPECIES_512); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 112); + oV = iV.and(0xffff).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 16).and(MASK_16).intoArray(out, outpos); + outpos += VLEN_512; + } + + private static void fastunpack17(final int[] in, int inpos, final int[] out, + int outpos) { + var iV = IntVector.fromArray(SPECIES_256, in, inpos); + iV.and(MASK_17).intoArray(out, outpos); + outpos += VLEN_256; + + var oV = iV.lanewise(VectorOperators.LSHR, 17).and(MASK_17); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 8); + oV = iV.and(3).lanewise(VectorOperators.LSHL, 15).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 2).and(MASK_17).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 19).and(MASK_17); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 16); + oV = iV.and(0xf).lanewise(VectorOperators.LSHL, 13).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 4).and(MASK_17).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 21).and(MASK_17); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 24); + oV = iV.and(0x3f).lanewise(VectorOperators.LSHL, 11).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 6).and(MASK_17).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 23).and(MASK_17); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 32); + oV = iV.and(0xff).lanewise(VectorOperators.LSHL, 9).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 8).and(MASK_17).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 25).and(MASK_17); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 40); + oV = iV.and(0x3ff).lanewise(VectorOperators.LSHL, 7).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 10).and(MASK_17).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 27).and(MASK_17); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 48); + oV = iV.and(0xfff).lanewise(VectorOperators.LSHL, 5).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 12).and(MASK_17).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 29).and(MASK_17); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 56); + oV = iV.and(0x3fff).lanewise(VectorOperators.LSHL, 3).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 14).and(MASK_17).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 31).and(MASK_17); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 64); + oV = iV.and(0xffff).lanewise(VectorOperators.LSHL, 1).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_17); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 72); + oV = iV.and(1).lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 1).and(MASK_17).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_17); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 80); + oV = iV.and(7).lanewise(VectorOperators.LSHL, 14).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 3).and(MASK_17).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_17); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 88); + oV = iV.and(0x1f).lanewise(VectorOperators.LSHL, 12).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 5).and(MASK_17).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_17); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 96); + oV = iV.and(0x7f).lanewise(VectorOperators.LSHL, 10).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 7).and(MASK_17).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_17); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 104); + oV = iV.and(0x1ff).lanewise(VectorOperators.LSHL, 8).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 9).and(MASK_17).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_17); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 112); + oV = iV.and(0x7ff).lanewise(VectorOperators.LSHL, 6).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 11).and(MASK_17).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_17); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 120); + oV = iV.and(0x1fff).lanewise(VectorOperators.LSHL, 4).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 13).and(MASK_17).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_17); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 128); + oV = iV.and(0x7fff).lanewise(VectorOperators.LSHL, 2).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 15).and(MASK_17).intoArray(out, outpos); + outpos += VLEN_256; + } + + private static void fastunpack18(final int[] in, int inpos, final int[] out, + int outpos) { + var iV = IntVector.fromArray(SPECIES_512, in, inpos); + iV.and(MASK_18).intoArray(out, outpos); + outpos += VLEN_512; + + var oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_18); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 16); + oV = iV.and(0xf).lanewise(VectorOperators.LSHL, 14).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 4).and(MASK_18).intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_18); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 32); + oV = iV.and(0xff).lanewise(VectorOperators.LSHL, 10).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 8).and(MASK_18).intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_18); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 48); + oV = iV.and(0xfff).lanewise(VectorOperators.LSHL, 6).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 12).and(MASK_18).intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_18); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 64); + oV = iV.and(0xffff).lanewise(VectorOperators.LSHL, 2).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_18); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 80); + oV = iV.and(3).lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 2).and(MASK_18).intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_18); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 96); + oV = iV.and(0x3f).lanewise(VectorOperators.LSHL, 12).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 6).and(MASK_18).intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_18); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 112); + oV = iV.and(0x3ff).lanewise(VectorOperators.LSHL, 8).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 10).and(MASK_18).intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_18); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 128); + oV = iV.and(0x3fff).lanewise(VectorOperators.LSHL, 4).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 14).and(MASK_18).intoArray(out, outpos); + outpos += VLEN_512; + } + + private static void fastunpack19(final int[] in, int inpos, final int[] out, + int outpos) { + var iV = IntVector.fromArray(SPECIES_256, in, inpos); + iV.and(MASK_19).intoArray(out, outpos); + outpos += VLEN_256; + + var oV = iV.lanewise(VectorOperators.LSHR, 19).and(MASK_19); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 8); + oV = iV.and(0x3f).lanewise(VectorOperators.LSHL, 13).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 6).and(MASK_19).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 25).and(MASK_19); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 16); + oV = iV.and(0xfff).lanewise(VectorOperators.LSHL, 7).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 12).and(MASK_19).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 31).and(MASK_19); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 24); + oV = iV.and(0x3ffff).lanewise(VectorOperators.LSHL, 1).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_19); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 32); + oV = iV.and(0x1f).lanewise(VectorOperators.LSHL, 14).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 5).and(MASK_19).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_19); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 40); + oV = iV.and(0x7ff).lanewise(VectorOperators.LSHL, 8).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 11).and(MASK_19).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_19); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 48); + oV = iV.and(0x1ffff).lanewise(VectorOperators.LSHL, 2).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 17).and(MASK_19); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 56); + oV = iV.and(0xf).lanewise(VectorOperators.LSHL, 15).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 4).and(MASK_19).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 23).and(MASK_19); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 64); + oV = iV.and(0x3ff).lanewise(VectorOperators.LSHL, 9).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 10).and(MASK_19).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 29).and(MASK_19); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 72); + oV = iV.and(0xffff).lanewise(VectorOperators.LSHL, 3).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_19); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 80); + oV = iV.and(7).lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 3).and(MASK_19).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_19); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 88); + oV = iV.and(0x1ff).lanewise(VectorOperators.LSHL, 10).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 9).and(MASK_19).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_19); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 96); + oV = iV.and(0x7fff).lanewise(VectorOperators.LSHL, 4).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 15).and(MASK_19); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 104); + oV = iV.and(3).lanewise(VectorOperators.LSHL, 17).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 2).and(MASK_19).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 21).and(MASK_19); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 112); + oV = iV.and(0xff).lanewise(VectorOperators.LSHL, 11).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 8).and(MASK_19).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 27).and(MASK_19); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 120); + oV = iV.and(0x3fff).lanewise(VectorOperators.LSHL, 5).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 14).and(MASK_19); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 128); + oV = iV.and(1).lanewise(VectorOperators.LSHL, 18).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 1).and(MASK_19).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_19); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 136); + oV = iV.and(0x7f).lanewise(VectorOperators.LSHL, 12).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 7).and(MASK_19).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_19); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 144); + oV = iV.and(0x1fff).lanewise(VectorOperators.LSHL, 6).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 13).and(MASK_19).intoArray(out, outpos); + outpos += VLEN_256; + } + + private static void fastunpack20(final int[] in, int inpos, final int[] out, + int outpos) { + var iV = IntVector.fromArray(SPECIES_512, in, inpos); + iV.and(MASK_20).intoArray(out, outpos); + outpos += VLEN_512; + + var oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_20); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 16); + oV = iV.and(0xff).lanewise(VectorOperators.LSHL, 12).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 8).and(MASK_20).intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_20); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 32); + oV = iV.and(0xffff).lanewise(VectorOperators.LSHL, 4).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_20); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 48); + oV = iV.and(0xf).lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 4).and(MASK_20).intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_20); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 64); + oV = iV.and(0xfff).lanewise(VectorOperators.LSHL, 8).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 12).and(MASK_20).intoArray(out, outpos); + outpos += VLEN_512; + + oV = oV.zero(SPECIES_512); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 80); + oV = iV.and(0xfffff).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_20); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 96); + oV = iV.and(0xff).lanewise(VectorOperators.LSHL, 12).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 8).and(MASK_20).intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_20); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 112); + oV = iV.and(0xffff).lanewise(VectorOperators.LSHL, 4).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_20); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 128); + oV = iV.and(0xf).lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 4).and(MASK_20).intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_20); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 144); + oV = iV.and(0xfff).lanewise(VectorOperators.LSHL, 8).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 12).and(MASK_20).intoArray(out, outpos); + outpos += VLEN_512; + } + + private static void fastunpack21(final int[] in, int inpos, final int[] out, + int outpos) { + var iV = IntVector.fromArray(SPECIES_256, in, inpos); + iV.and(MASK_21).intoArray(out, outpos); + outpos += VLEN_256; + + var oV = iV.lanewise(VectorOperators.LSHR, 21).and(MASK_21); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 8); + oV = iV.and(0x3ff).lanewise(VectorOperators.LSHL, 11).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 10).and(MASK_21).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 31).and(MASK_21); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 16); + oV = iV.and(0xfffff).lanewise(VectorOperators.LSHL, 1).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_21); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 24); + oV = iV.and(0x1ff).lanewise(VectorOperators.LSHL, 12).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 9).and(MASK_21).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_21); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 32); + oV = iV.and(0x7ffff).lanewise(VectorOperators.LSHL, 2).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 19).and(MASK_21); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 40); + oV = iV.and(0xff).lanewise(VectorOperators.LSHL, 13).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 8).and(MASK_21).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 29).and(MASK_21); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 48); + oV = iV.and(0x3ffff).lanewise(VectorOperators.LSHL, 3).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_21); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 56); + oV = iV.and(0x7f).lanewise(VectorOperators.LSHL, 14).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 7).and(MASK_21).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_21); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 64); + oV = iV.and(0x1ffff).lanewise(VectorOperators.LSHL, 4).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 17).and(MASK_21); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 72); + oV = iV.and(0x3f).lanewise(VectorOperators.LSHL, 15).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 6).and(MASK_21).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 27).and(MASK_21); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 80); + oV = iV.and(0xffff).lanewise(VectorOperators.LSHL, 5).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_21); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 88); + oV = iV.and(0x1f).lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 5).and(MASK_21).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_21); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 96); + oV = iV.and(0x7fff).lanewise(VectorOperators.LSHL, 6).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 15).and(MASK_21); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 104); + oV = iV.and(0xf).lanewise(VectorOperators.LSHL, 17).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 4).and(MASK_21).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 25).and(MASK_21); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 112); + oV = iV.and(0x3fff).lanewise(VectorOperators.LSHL, 7).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 14).and(MASK_21); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 120); + oV = iV.and(7).lanewise(VectorOperators.LSHL, 18).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 3).and(MASK_21).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_21); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 128); + oV = iV.and(0x1fff).lanewise(VectorOperators.LSHL, 8).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 13).and(MASK_21); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 136); + oV = iV.and(3).lanewise(VectorOperators.LSHL, 19).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 2).and(MASK_21).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 23).and(MASK_21); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 144); + oV = iV.and(0xfff).lanewise(VectorOperators.LSHL, 9).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 12).and(MASK_21); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 152); + oV = iV.and(1).lanewise(VectorOperators.LSHL, 20).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 1).and(MASK_21).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_21); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 160); + oV = iV.and(0x7ff).lanewise(VectorOperators.LSHL, 10).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 11).and(MASK_21).intoArray(out, outpos); + outpos += VLEN_256; + } + + private static void fastunpack22(final int[] in, int inpos, final int[] out, + int outpos) { + var iV = IntVector.fromArray(SPECIES_512, in, inpos); + iV.and(MASK_22).intoArray(out, outpos); + outpos += VLEN_512; + + var oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_22); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 16); + oV = iV.and(0xfff).lanewise(VectorOperators.LSHL, 10).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 12).and(MASK_22); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 32); + oV = iV.and(3).lanewise(VectorOperators.LSHL, 20).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 2).and(MASK_22).intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_22); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 48); + oV = iV.and(0x3fff).lanewise(VectorOperators.LSHL, 8).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 14).and(MASK_22); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 64); + oV = iV.and(0xf).lanewise(VectorOperators.LSHL, 18).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 4).and(MASK_22).intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_22); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 80); + oV = iV.and(0xffff).lanewise(VectorOperators.LSHL, 6).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_22); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 96); + oV = iV.and(0x3f).lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 6).and(MASK_22).intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_22); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 112); + oV = iV.and(0x3ffff).lanewise(VectorOperators.LSHL, 4).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_22); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 128); + oV = iV.and(0xff).lanewise(VectorOperators.LSHL, 14).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 8).and(MASK_22).intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_22); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 144); + oV = iV.and(0xfffff).lanewise(VectorOperators.LSHL, 2).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_22); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 160); + oV = iV.and(0x3ff).lanewise(VectorOperators.LSHL, 12).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 10).and(MASK_22).intoArray(out, outpos); + outpos += VLEN_512; + } + + private static void fastunpack23(final int[] in, int inpos, final int[] out, + int outpos) { + var iV = IntVector.fromArray(SPECIES_256, in, inpos); + iV.and(MASK_23).intoArray(out, outpos); + outpos += VLEN_256; + + var oV = iV.lanewise(VectorOperators.LSHR, 23).and(MASK_23); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 8); + oV = iV.and(0x3fff).lanewise(VectorOperators.LSHL, 9).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 14).and(MASK_23); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 16); + oV = iV.and(0x1f).lanewise(VectorOperators.LSHL, 18).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 5).and(MASK_23).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_23); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 24); + oV = iV.and(0x7ffff).lanewise(VectorOperators.LSHL, 4).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 19).and(MASK_23); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 32); + oV = iV.and(0x3ff).lanewise(VectorOperators.LSHL, 13).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 10).and(MASK_23); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 40); + oV = iV.and(1).lanewise(VectorOperators.LSHL, 22).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 1).and(MASK_23).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_23); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 48); + oV = iV.and(0x7fff).lanewise(VectorOperators.LSHL, 8).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 15).and(MASK_23); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 56); + oV = iV.and(0x3f).lanewise(VectorOperators.LSHL, 17).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 6).and(MASK_23).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 29).and(MASK_23); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 64); + oV = iV.and(0xfffff).lanewise(VectorOperators.LSHL, 3).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_23); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 72); + oV = iV.and(0x7ff).lanewise(VectorOperators.LSHL, 12).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 11).and(MASK_23); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 80); + oV = iV.and(3).lanewise(VectorOperators.LSHL, 21).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 2).and(MASK_23).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 25).and(MASK_23); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 88); + oV = iV.and(0xffff).lanewise(VectorOperators.LSHL, 7).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_23); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 96); + oV = iV.and(0x7f).lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 7).and(MASK_23).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_23); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 104); + oV = iV.and(0x1fffff).lanewise(VectorOperators.LSHL, 2).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 21).and(MASK_23); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 112); + oV = iV.and(0xfff).lanewise(VectorOperators.LSHL, 11).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 12).and(MASK_23); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 120); + oV = iV.and(7).lanewise(VectorOperators.LSHL, 20).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 3).and(MASK_23).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_23); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 128); + oV = iV.and(0x1ffff).lanewise(VectorOperators.LSHL, 6).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 17).and(MASK_23); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 136); + oV = iV.and(0xff).lanewise(VectorOperators.LSHL, 15).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 8).and(MASK_23).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 31).and(MASK_23); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 144); + oV = iV.and(0x3fffff).lanewise(VectorOperators.LSHL, 1).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_23); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 152); + oV = iV.and(0x1fff).lanewise(VectorOperators.LSHL, 10).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 13).and(MASK_23); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 160); + oV = iV.and(0xf).lanewise(VectorOperators.LSHL, 19).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 4).and(MASK_23).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 27).and(MASK_23); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 168); + oV = iV.and(0x3ffff).lanewise(VectorOperators.LSHL, 5).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_23); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 176); + oV = iV.and(0x1ff).lanewise(VectorOperators.LSHL, 14).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 9).and(MASK_23).intoArray(out, outpos); + outpos += VLEN_256; + } + + private static void fastunpack24(final int[] in, int inpos, final int[] out, + int outpos) { + var iV = IntVector.fromArray(SPECIES_512, in, inpos); + iV.and(MASK_24).intoArray(out, outpos); + outpos += VLEN_512; + + var oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_24); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 16); + oV = iV.and(0xffff).lanewise(VectorOperators.LSHL, 8).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_24); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 32); + oV = iV.and(0xff).lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 8).and(MASK_24).intoArray(out, outpos); + outpos += VLEN_512; + + oV = oV.zero(SPECIES_512); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 48); + oV = iV.and(0xffffff).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_24); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 64); + oV = iV.and(0xffff).lanewise(VectorOperators.LSHL, 8).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_24); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 80); + oV = iV.and(0xff).lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 8).and(MASK_24).intoArray(out, outpos); + outpos += VLEN_512; + + oV = oV.zero(SPECIES_512); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 96); + oV = iV.and(0xffffff).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_24); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 112); + oV = iV.and(0xffff).lanewise(VectorOperators.LSHL, 8).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_24); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 128); + oV = iV.and(0xff).lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 8).and(MASK_24).intoArray(out, outpos); + outpos += VLEN_512; + + oV = oV.zero(SPECIES_512); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 144); + oV = iV.and(0xffffff).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_24); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 160); + oV = iV.and(0xffff).lanewise(VectorOperators.LSHL, 8).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_24); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 176); + oV = iV.and(0xff).lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 8).and(MASK_24).intoArray(out, outpos); + outpos += VLEN_512; + } + + private static void fastunpack25(final int[] in, int inpos, final int[] out, + int outpos) { + var iV = IntVector.fromArray(SPECIES_256, in, inpos); + iV.and(MASK_25).intoArray(out, outpos); + outpos += VLEN_256; + + var oV = iV.lanewise(VectorOperators.LSHR, 25).and(MASK_25); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 8); + oV = iV.and(0x3ffff).lanewise(VectorOperators.LSHL, 7).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_25); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 16); + oV = iV.and(0x7ff).lanewise(VectorOperators.LSHL, 14).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 11).and(MASK_25); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 24); + oV = iV.and(0xf).lanewise(VectorOperators.LSHL, 21).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 4).and(MASK_25).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 29).and(MASK_25); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 32); + oV = iV.and(0x3fffff).lanewise(VectorOperators.LSHL, 3).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_25); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 40); + oV = iV.and(0x7fff).lanewise(VectorOperators.LSHL, 10).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 15).and(MASK_25); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 48); + oV = iV.and(0xff).lanewise(VectorOperators.LSHL, 17).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 8).and(MASK_25); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 56); + oV = iV.and(1).lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 1).and(MASK_25).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_25); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 64); + oV = iV.and(0x7ffff).lanewise(VectorOperators.LSHL, 6).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 19).and(MASK_25); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 72); + oV = iV.and(0xfff).lanewise(VectorOperators.LSHL, 13).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 12).and(MASK_25); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 80); + oV = iV.and(0x1f).lanewise(VectorOperators.LSHL, 20).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 5).and(MASK_25).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_25); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 88); + oV = iV.and(0x7fffff).lanewise(VectorOperators.LSHL, 2).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 23).and(MASK_25); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 96); + oV = iV.and(0xffff).lanewise(VectorOperators.LSHL, 9).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_25); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 104); + oV = iV.and(0x1ff).lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 9).and(MASK_25); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 112); + oV = iV.and(3).lanewise(VectorOperators.LSHL, 23).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 2).and(MASK_25).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 27).and(MASK_25); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 120); + oV = iV.and(0xfffff).lanewise(VectorOperators.LSHL, 5).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_25); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 128); + oV = iV.and(0x1fff).lanewise(VectorOperators.LSHL, 12).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 13).and(MASK_25); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 136); + oV = iV.and(0x3f).lanewise(VectorOperators.LSHL, 19).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 6).and(MASK_25).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 31).and(MASK_25); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 144); + oV = iV.and(0xffffff).lanewise(VectorOperators.LSHL, 1).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_25); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 152); + oV = iV.and(0x1ffff).lanewise(VectorOperators.LSHL, 8).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 17).and(MASK_25); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 160); + oV = iV.and(0x3ff).lanewise(VectorOperators.LSHL, 15).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 10).and(MASK_25); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 168); + oV = iV.and(7).lanewise(VectorOperators.LSHL, 22).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 3).and(MASK_25).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_25); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 176); + oV = iV.and(0x1fffff).lanewise(VectorOperators.LSHL, 4).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 21).and(MASK_25); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 184); + oV = iV.and(0x3fff).lanewise(VectorOperators.LSHL, 11).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 14).and(MASK_25); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 192); + oV = iV.and(0x7f).lanewise(VectorOperators.LSHL, 18).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 7).and(MASK_25).intoArray(out, outpos); + outpos += VLEN_256; + } + + private static void fastunpack26(final int[] in, int inpos, final int[] out, + int outpos) { + var iV = IntVector.fromArray(SPECIES_512, in, inpos); + iV.and(MASK_26).intoArray(out, outpos); + outpos += VLEN_512; + + var oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_26); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 16); + oV = iV.and(0xfffff).lanewise(VectorOperators.LSHL, 6).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_26); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 32); + oV = iV.and(0x3fff).lanewise(VectorOperators.LSHL, 12).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 14).and(MASK_26); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 48); + oV = iV.and(0xff).lanewise(VectorOperators.LSHL, 18).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 8).and(MASK_26); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 64); + oV = iV.and(3).lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 2).and(MASK_26).intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_26); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 80); + oV = iV.and(0x3fffff).lanewise(VectorOperators.LSHL, 4).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_26); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 96); + oV = iV.and(0xffff).lanewise(VectorOperators.LSHL, 10).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_26); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 112); + oV = iV.and(0x3ff).lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 10).and(MASK_26); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 128); + oV = iV.and(0xf).lanewise(VectorOperators.LSHL, 22).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 4).and(MASK_26).intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_26); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 144); + oV = iV.and(0xffffff).lanewise(VectorOperators.LSHL, 2).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_26); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 160); + oV = iV.and(0x3ffff).lanewise(VectorOperators.LSHL, 8).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_26); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 176); + oV = iV.and(0xfff).lanewise(VectorOperators.LSHL, 14).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 12).and(MASK_26); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 192); + oV = iV.and(0x3f).lanewise(VectorOperators.LSHL, 20).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 6).and(MASK_26).intoArray(out, outpos); + outpos += VLEN_512; + } + + private static void fastunpack27(final int[] in, int inpos, final int[] out, + int outpos) { + var iV = IntVector.fromArray(SPECIES_256, in, inpos); + iV.and(MASK_27).intoArray(out, outpos); + outpos += VLEN_256; + + var oV = iV.lanewise(VectorOperators.LSHR, 27).and(MASK_27); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 8); + oV = iV.and(0x3fffff).lanewise(VectorOperators.LSHL, 5).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_27); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 16); + oV = iV.and(0x1ffff).lanewise(VectorOperators.LSHL, 10).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 17).and(MASK_27); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 24); + oV = iV.and(0xfff).lanewise(VectorOperators.LSHL, 15).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 12).and(MASK_27); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 32); + oV = iV.and(0x7f).lanewise(VectorOperators.LSHL, 20).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 7).and(MASK_27); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 40); + oV = iV.and(3).lanewise(VectorOperators.LSHL, 25).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 2).and(MASK_27).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 29).and(MASK_27); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 48); + oV = iV.and(0xffffff).lanewise(VectorOperators.LSHL, 3).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_27); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 56); + oV = iV.and(0x7ffff).lanewise(VectorOperators.LSHL, 8).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 19).and(MASK_27); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 64); + oV = iV.and(0x3fff).lanewise(VectorOperators.LSHL, 13).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 14).and(MASK_27); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 72); + oV = iV.and(0x1ff).lanewise(VectorOperators.LSHL, 18).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 9).and(MASK_27); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 80); + oV = iV.and(0xf).lanewise(VectorOperators.LSHL, 23).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 4).and(MASK_27).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 31).and(MASK_27); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 88); + oV = iV.and(0x3ffffff).lanewise(VectorOperators.LSHL, 1).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_27); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 96); + oV = iV.and(0x1fffff).lanewise(VectorOperators.LSHL, 6).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 21).and(MASK_27); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 104); + oV = iV.and(0xffff).lanewise(VectorOperators.LSHL, 11).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_27); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 112); + oV = iV.and(0x7ff).lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 11).and(MASK_27); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 120); + oV = iV.and(0x3f).lanewise(VectorOperators.LSHL, 21).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 6).and(MASK_27); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 128); + oV = iV.and(1).lanewise(VectorOperators.LSHL, 26).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 1).and(MASK_27).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_27); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 136); + oV = iV.and(0x7fffff).lanewise(VectorOperators.LSHL, 4).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 23).and(MASK_27); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 144); + oV = iV.and(0x3ffff).lanewise(VectorOperators.LSHL, 9).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_27); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 152); + oV = iV.and(0x1fff).lanewise(VectorOperators.LSHL, 14).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 13).and(MASK_27); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 160); + oV = iV.and(0xff).lanewise(VectorOperators.LSHL, 19).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 8).and(MASK_27); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 168); + oV = iV.and(7).lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 3).and(MASK_27).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_27); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 176); + oV = iV.and(0x1ffffff).lanewise(VectorOperators.LSHL, 2).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 25).and(MASK_27); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 184); + oV = iV.and(0xfffff).lanewise(VectorOperators.LSHL, 7).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_27); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 192); + oV = iV.and(0x7fff).lanewise(VectorOperators.LSHL, 12).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 15).and(MASK_27); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 200); + oV = iV.and(0x3ff).lanewise(VectorOperators.LSHL, 17).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 10).and(MASK_27); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 208); + oV = iV.and(0x1f).lanewise(VectorOperators.LSHL, 22).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 5).and(MASK_27).intoArray(out, outpos); + outpos += VLEN_256; + } + + private static void fastunpack28(final int[] in, int inpos, final int[] out, + int outpos) { + var iV = IntVector.fromArray(SPECIES_512, in, inpos); + iV.and(MASK_28).intoArray(out, outpos); + outpos += VLEN_512; + + var oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_28); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 16); + oV = iV.and(0xffffff).lanewise(VectorOperators.LSHL, 4).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_28); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 32); + oV = iV.and(0xfffff).lanewise(VectorOperators.LSHL, 8).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_28); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 48); + oV = iV.and(0xffff).lanewise(VectorOperators.LSHL, 12).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_28); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 64); + oV = iV.and(0xfff).lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 12).and(MASK_28); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 80); + oV = iV.and(0xff).lanewise(VectorOperators.LSHL, 20).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 8).and(MASK_28); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 96); + oV = iV.and(0xf).lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 4).and(MASK_28).intoArray(out, outpos); + outpos += VLEN_512; + + oV = oV.zero(SPECIES_512); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 112); + oV = iV.and(0xfffffff).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_28); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 128); + oV = iV.and(0xffffff).lanewise(VectorOperators.LSHL, 4).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_28); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 144); + oV = iV.and(0xfffff).lanewise(VectorOperators.LSHL, 8).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_28); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 160); + oV = iV.and(0xffff).lanewise(VectorOperators.LSHL, 12).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_28); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 176); + oV = iV.and(0xfff).lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 12).and(MASK_28); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 192); + oV = iV.and(0xff).lanewise(VectorOperators.LSHL, 20).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 8).and(MASK_28); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 208); + oV = iV.and(0xf).lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 4).and(MASK_28).intoArray(out, outpos); + outpos += VLEN_512; + } + + private static void fastunpack29(final int[] in, int inpos, final int[] out, + int outpos) { + var iV = IntVector.fromArray(SPECIES_256, in, inpos); + iV.and(MASK_29).intoArray(out, outpos); + outpos += VLEN_256; + + var oV = iV.lanewise(VectorOperators.LSHR, 29).and(MASK_29); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 8); + oV = iV.and(0x3ffffff).lanewise(VectorOperators.LSHL, 3).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_29); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 16); + oV = iV.and(0x7fffff).lanewise(VectorOperators.LSHL, 6).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 23).and(MASK_29); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 24); + oV = iV.and(0xfffff).lanewise(VectorOperators.LSHL, 9).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_29); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 32); + oV = iV.and(0x1ffff).lanewise(VectorOperators.LSHL, 12).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 17).and(MASK_29); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 40); + oV = iV.and(0x3fff).lanewise(VectorOperators.LSHL, 15).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 14).and(MASK_29); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 48); + oV = iV.and(0x7ff).lanewise(VectorOperators.LSHL, 18).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 11).and(MASK_29); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 56); + oV = iV.and(0xff).lanewise(VectorOperators.LSHL, 21).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 8).and(MASK_29); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 64); + oV = iV.and(0x1f).lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 5).and(MASK_29); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 72); + oV = iV.and(3).lanewise(VectorOperators.LSHL, 27).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 2).and(MASK_29).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 31).and(MASK_29); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 80); + oV = iV.and(0xfffffff).lanewise(VectorOperators.LSHL, 1).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_29); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 88); + oV = iV.and(0x1ffffff).lanewise(VectorOperators.LSHL, 4).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 25).and(MASK_29); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 96); + oV = iV.and(0x3fffff).lanewise(VectorOperators.LSHL, 7).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_29); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 104); + oV = iV.and(0x7ffff).lanewise(VectorOperators.LSHL, 10).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 19).and(MASK_29); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 112); + oV = iV.and(0xffff).lanewise(VectorOperators.LSHL, 13).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_29); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 120); + oV = iV.and(0x1fff).lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 13).and(MASK_29); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 128); + oV = iV.and(0x3ff).lanewise(VectorOperators.LSHL, 19).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 10).and(MASK_29); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 136); + oV = iV.and(0x7f).lanewise(VectorOperators.LSHL, 22).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 7).and(MASK_29); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 144); + oV = iV.and(0xf).lanewise(VectorOperators.LSHL, 25).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 4).and(MASK_29); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 152); + oV = iV.and(1).lanewise(VectorOperators.LSHL, 28).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 1).and(MASK_29).intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_29); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 160); + oV = iV.and(0x7ffffff).lanewise(VectorOperators.LSHL, 2).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 27).and(MASK_29); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 168); + oV = iV.and(0xffffff).lanewise(VectorOperators.LSHL, 5).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_29); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 176); + oV = iV.and(0x1fffff).lanewise(VectorOperators.LSHL, 8).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 21).and(MASK_29); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 184); + oV = iV.and(0x3ffff).lanewise(VectorOperators.LSHL, 11).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_29); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 192); + oV = iV.and(0x7fff).lanewise(VectorOperators.LSHL, 14).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 15).and(MASK_29); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 200); + oV = iV.and(0xfff).lanewise(VectorOperators.LSHL, 17).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 12).and(MASK_29); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 208); + oV = iV.and(0x1ff).lanewise(VectorOperators.LSHL, 20).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 9).and(MASK_29); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 216); + oV = iV.and(0x3f).lanewise(VectorOperators.LSHL, 23).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 6).and(MASK_29); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 224); + oV = iV.and(7).lanewise(VectorOperators.LSHL, 26).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 3).and(MASK_29).intoArray(out, outpos); + outpos += VLEN_256; + } + + private static void fastunpack30(final int[] in, int inpos, final int[] out, + int outpos) { + var iV = IntVector.fromArray(SPECIES_512, in, inpos); + iV.and(MASK_30).intoArray(out, outpos); + outpos += VLEN_512; + + var oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_30); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 16); + oV = iV.and(0xfffffff).lanewise(VectorOperators.LSHL, 2).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_30); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 32); + oV = iV.and(0x3ffffff).lanewise(VectorOperators.LSHL, 4).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_30); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 48); + oV = iV.and(0xffffff).lanewise(VectorOperators.LSHL, 6).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_30); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 64); + oV = iV.and(0x3fffff).lanewise(VectorOperators.LSHL, 8).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_30); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 80); + oV = iV.and(0xfffff).lanewise(VectorOperators.LSHL, 10).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_30); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 96); + oV = iV.and(0x3ffff).lanewise(VectorOperators.LSHL, 12).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_30); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 112); + oV = iV.and(0xffff).lanewise(VectorOperators.LSHL, 14).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_30); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 128); + oV = iV.and(0x3fff).lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 14).and(MASK_30); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 144); + oV = iV.and(0xfff).lanewise(VectorOperators.LSHL, 18).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 12).and(MASK_30); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 160); + oV = iV.and(0x3ff).lanewise(VectorOperators.LSHL, 20).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 10).and(MASK_30); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 176); + oV = iV.and(0xff).lanewise(VectorOperators.LSHL, 22).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 8).and(MASK_30); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 192); + oV = iV.and(0x3f).lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 6).and(MASK_30); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 208); + oV = iV.and(0xf).lanewise(VectorOperators.LSHL, 26).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + oV = iV.lanewise(VectorOperators.LSHR, 4).and(MASK_30); + + iV = IntVector.fromArray(SPECIES_512, in, inpos + 224); + oV = iV.and(3).lanewise(VectorOperators.LSHL, 28).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_512; + + iV.lanewise(VectorOperators.LSHR, 2).and(MASK_30).intoArray(out, outpos); + outpos += VLEN_512; + } + + private static void fastunpack31(final int[] in, int inpos, final int[] out, + int outpos) { + var iV = IntVector.fromArray(SPECIES_256, in, inpos); + iV.and(MASK_31).intoArray(out, outpos); + outpos += VLEN_256; + + var oV = iV.lanewise(VectorOperators.LSHR, 31).and(MASK_31); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 8); + oV = iV.and(0x3fffffff).lanewise(VectorOperators.LSHL, 1).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 30).and(MASK_31); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 16); + oV = iV.and(0x1fffffff).lanewise(VectorOperators.LSHL, 2).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 29).and(MASK_31); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 24); + oV = iV.and(0xfffffff).lanewise(VectorOperators.LSHL, 3).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 28).and(MASK_31); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 32); + oV = iV.and(0x7ffffff).lanewise(VectorOperators.LSHL, 4).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 27).and(MASK_31); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 40); + oV = iV.and(0x3ffffff).lanewise(VectorOperators.LSHL, 5).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 26).and(MASK_31); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 48); + oV = iV.and(0x1ffffff).lanewise(VectorOperators.LSHL, 6).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 25).and(MASK_31); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 56); + oV = iV.and(0xffffff).lanewise(VectorOperators.LSHL, 7).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 24).and(MASK_31); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 64); + oV = iV.and(0x7fffff).lanewise(VectorOperators.LSHL, 8).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 23).and(MASK_31); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 72); + oV = iV.and(0x3fffff).lanewise(VectorOperators.LSHL, 9).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 22).and(MASK_31); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 80); + oV = iV.and(0x1fffff).lanewise(VectorOperators.LSHL, 10).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 21).and(MASK_31); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 88); + oV = iV.and(0xfffff).lanewise(VectorOperators.LSHL, 11).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 20).and(MASK_31); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 96); + oV = iV.and(0x7ffff).lanewise(VectorOperators.LSHL, 12).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 19).and(MASK_31); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 104); + oV = iV.and(0x3ffff).lanewise(VectorOperators.LSHL, 13).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 18).and(MASK_31); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 112); + oV = iV.and(0x1ffff).lanewise(VectorOperators.LSHL, 14).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 17).and(MASK_31); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 120); + oV = iV.and(0xffff).lanewise(VectorOperators.LSHL, 15).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 16).and(MASK_31); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 128); + oV = iV.and(0x7fff).lanewise(VectorOperators.LSHL, 16).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 15).and(MASK_31); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 136); + oV = iV.and(0x3fff).lanewise(VectorOperators.LSHL, 17).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 14).and(MASK_31); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 144); + oV = iV.and(0x1fff).lanewise(VectorOperators.LSHL, 18).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 13).and(MASK_31); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 152); + oV = iV.and(0xfff).lanewise(VectorOperators.LSHL, 19).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 12).and(MASK_31); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 160); + oV = iV.and(0x7ff).lanewise(VectorOperators.LSHL, 20).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 11).and(MASK_31); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 168); + oV = iV.and(0x3ff).lanewise(VectorOperators.LSHL, 21).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 10).and(MASK_31); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 176); + oV = iV.and(0x1ff).lanewise(VectorOperators.LSHL, 22).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 9).and(MASK_31); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 184); + oV = iV.and(0xff).lanewise(VectorOperators.LSHL, 23).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 8).and(MASK_31); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 192); + oV = iV.and(0x7f).lanewise(VectorOperators.LSHL, 24).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 7).and(MASK_31); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 200); + oV = iV.and(0x3f).lanewise(VectorOperators.LSHL, 25).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 6).and(MASK_31); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 208); + oV = iV.and(0x1f).lanewise(VectorOperators.LSHL, 26).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 5).and(MASK_31); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 216); + oV = iV.and(0xf).lanewise(VectorOperators.LSHL, 27).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 4).and(MASK_31); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 224); + oV = iV.and(7).lanewise(VectorOperators.LSHL, 28).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 3).and(MASK_31); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 232); + oV = iV.and(3).lanewise(VectorOperators.LSHL, 29).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + oV = iV.lanewise(VectorOperators.LSHR, 2).and(MASK_31); + + iV = IntVector.fromArray(SPECIES_256, in, inpos + 240); + oV = iV.and(1).lanewise(VectorOperators.LSHL, 30).or(oV); + + oV.intoArray(out, outpos); + outpos += VLEN_256; + + iV.lanewise(VectorOperators.LSHR, 1).and(MASK_31).intoArray(out, outpos); + outpos += VLEN_256; + } +} diff --git a/src/main/java/me/lemire/integercompression/vector/VectorBitPackerTerse.java b/src/main/java/me/lemire/integercompression/vector/VectorBitPackerTerse.java new file mode 100644 index 0000000..62a8cc7 --- /dev/null +++ b/src/main/java/me/lemire/integercompression/vector/VectorBitPackerTerse.java @@ -0,0 +1,963 @@ +// Copyright (C) 2022 Intel Corporation + +// SPDX-License-Identifier: Apache-2.0 + +package me.lemire.integercompression.vector; + +import java.util.Arrays; +import jdk.incubator.vector.*; + +/** + * This is a readable but less efficient version of the VectorBitPacker class. + * + */ +public class VectorBitPackerTerse { + static final VectorSpecies SPECIES_512 = IntVector.SPECIES_512; + static final VectorSpecies SPECIES_256 = IntVector.SPECIES_256; + static final int VLEN_512 = 16; + static final int VLEN_256 = 8; + static final int BLOCK_SIZE = 256; + + private static void fastpackOddBit(final int[] in, int inpos, final int[] out, + int outpos, int b, final int[] ho, + final int[] lc) { + final int mask = (1 << b) - 1; + final int N = 31 / b; + var iV = IntVector.fromArray(SPECIES_256, in, inpos); + var oV = iV.and(mask); + int n = 1; + for (; n <= N; n++) { + iV = IntVector.fromArray(SPECIES_256, in, inpos + n * VLEN_256); + oV = iV.and(mask).lanewise(VectorOperators.LSHL, b * n).or(oV); + } + oV.intoArray(out, outpos); + outpos += VLEN_256; + + final int L = b - 1; + for (int i = 0; i < L; i++) { + oV = iV.and(mask).lanewise(VectorOperators.LSHR, ho[i]); + for (int j = 0; j < lc[i]; j++) { + iV = IntVector.fromArray(SPECIES_256, in, inpos + n * VLEN_256); + oV = iV.and(mask) + .lanewise(VectorOperators.LSHL, b * j + (b - ho[i])) + .or(oV); + n++; + } + oV.intoArray(out, outpos); + outpos += VLEN_256; + } + } + + private static void fastpackOddBitNoMask(final int[] in, int inpos, + final int[] out, int outpos, int b, + final int[] ho, final int[] lc) { + final int N = 31 / b; + var iV = IntVector.fromArray(SPECIES_256, in, inpos); + var oV = iV; + int n = 1; + for (; n <= N; n++) { + iV = IntVector.fromArray(SPECIES_256, in, inpos + n * VLEN_256); + oV = iV.lanewise(VectorOperators.LSHL, b * n).or(oV); + } + oV.intoArray(out, outpos); + outpos += VLEN_256; + + final int L = b - 1; + for (int i = 0; i < L; i++) { + oV = iV.lanewise(VectorOperators.LSHR, ho[i]); + for (int j = 0; j < lc[i]; j++) { + iV = IntVector.fromArray(SPECIES_256, in, inpos + n * VLEN_256); + oV = iV.lanewise(VectorOperators.LSHL, b * j + (b - ho[i])).or(oV); + n++; + } + oV.intoArray(out, outpos); + outpos += VLEN_256; + } + } + + private static void fastUnpackOddBit(final int[] in, int inpos, + final int[] out, int outpos, int b, + final int[] lo, int[] masks, int[] lc) { + final int mask = (1 << b) - 1; + final int N = 32 / b; + var iV = IntVector.fromArray(SPECIES_256, in, inpos); + int n = 0; + for (; n < N; n++) { + iV.lanewise(VectorOperators.LSHR, b * n).and(mask).intoArray(out, outpos); + outpos += VLEN_256; + } + var oV = iV.lanewise(VectorOperators.LSHR, b * n).and(mask); + + final int L = b - 1; + for (int i = 0; i < L; i++) { + iV = IntVector.fromArray(SPECIES_256, in, inpos + (i + 1) * VLEN_256); + oV = iV.and(masks[i]).lanewise(VectorOperators.LSHL, b - lo[i]).or(oV); + oV.intoArray(out, outpos); + outpos += VLEN_256; + int j = 0; + for (; j < lc[i]; j++) { + iV.lanewise(VectorOperators.LSHR, b * j + lo[i]) + .and(mask) + .intoArray(out, outpos); + outpos += VLEN_256; + n++; + } + oV = iV.lanewise(VectorOperators.LSHR, b * j + lo[i]).and(mask); + } + } + + private static void fastpackEvenBit(final int[] in, int inpos, + final int[] out, int outpos, int b, + final int[] ho, final int[] lc) { + final int mask = (1 << b) - 1; + final int N = 32 % b == 0 ? (32 / b) - 1 : 32 / b; + var iV = IntVector.fromArray(SPECIES_512, in, inpos); + var oV = iV.and(mask); + int n = 1; + for (; n <= N; n++) { + iV = IntVector.fromArray(SPECIES_512, in, inpos + n * VLEN_512); + oV = iV.and(mask).lanewise(VectorOperators.LSHL, b * n).or(oV); + } + oV.intoArray(out, outpos); + outpos += VLEN_512; + + final int L = (b >>> 1) - 1; + for (int i = 0; i < L; i++) { + if (ho[i] != b) + oV = iV.and(mask).lanewise(VectorOperators.LSHR, ho[i]); + else + oV = oV.zero(SPECIES_512); + for (int j = 0; j < lc[i]; j++) { + iV = IntVector.fromArray(SPECIES_512, in, inpos + n * VLEN_512); + oV = iV.and(mask) + .lanewise(VectorOperators.LSHL, b * j + (b - ho[i])) + .or(oV); + n++; + } + oV.intoArray(out, outpos); + outpos += VLEN_512; + } + } + + private static void fastpackEvenBitNoMask(final int[] in, int inpos, + final int[] out, int outpos, int b, + final int[] ho, final int[] lc) { + final int N = 32 % b == 0 ? (32 / b) - 1 : 32 / b; + var iV = IntVector.fromArray(SPECIES_512, in, inpos); + var oV = iV; + int n = 1; + for (; n <= N; n++) { + iV = IntVector.fromArray(SPECIES_512, in, inpos + n * VLEN_512); + oV = iV.lanewise(VectorOperators.LSHL, b * n).or(oV); + } + oV.intoArray(out, outpos); + outpos += VLEN_512; + + final int L = (b >>> 1) - 1; + for (int i = 0; i < L; i++) { + if (ho[i] != b) + oV = iV.lanewise(VectorOperators.LSHR, ho[i]); + else + oV = oV.zero(SPECIES_512); + for (int j = 0; j < lc[i]; j++) { + iV = IntVector.fromArray(SPECIES_512, in, inpos + n * VLEN_512); + oV = iV.lanewise(VectorOperators.LSHL, b * j + (b - ho[i])).or(oV); + n++; + } + oV.intoArray(out, outpos); + outpos += VLEN_512; + } + } + + private static void fastUnpackEventBit(final int[] in, int inpos, + final int[] out, int outpos, int b, + final int[] lo, int[] masks, + int[] lc) { + final int mask = (1 << b) - 1; + final int N = 32 / b; + var iV = IntVector.fromArray(SPECIES_512, in, inpos); + int n = 0; + for (; n < N; n++) { + iV.lanewise(VectorOperators.LSHR, b * n).and(mask).intoArray(out, outpos); + outpos += VLEN_512; + } + var oV = iV.lanewise(VectorOperators.LSHR, b * n).and(mask); + if ((b & (b - 1)) == 0) + oV = oV.zero(SPECIES_512); + + final int L = (b >>> 1) - 1; + for (int i = 0; i < L; i++) { + iV = IntVector.fromArray(SPECIES_512, in, inpos + (i + 1) * VLEN_512); + oV = iV.and(masks[i]).lanewise(VectorOperators.LSHL, b - lo[i]).or(oV); + oV.intoArray(out, outpos); + outpos += VLEN_512; + int j = 0; + for (; j < lc[i]; j++) { + iV.lanewise(VectorOperators.LSHR, b * j + lo[i]) + .and(mask) + .intoArray(out, outpos); + outpos += VLEN_512; + n++; + } + if ((32 - lo[i]) % b != 0) + oV = iV.lanewise(VectorOperators.LSHR, b * j + lo[i]).and(mask); + else + oV = oV.zero(SPECIES_512); + } + } + + public static int slowpack(final int[] in, int inpos, int inlen, + final int[] out, int outpos, int b) { + if (inlen == 0) + return outpos; + if (b == 32) { + System.arraycopy(in, inpos, out, outpos, inlen); + return outpos + inlen; + } + int mask = (1 << b) - 1; + int c = 0; + int l = 0; + int r = 0; + int val = 0; + for (int i = 0; i < inlen; i++) { + val = in[inpos + i] & mask; + out[outpos] |= val << (c + r); + c += b; + l = (32 - r) % b; + if (c + r >= 32) { + if (i < inlen - 1 || l != 0) + outpos++; + r = l == 0 ? 0 : b - l; + if (l != 0) + out[outpos] = val >> (b - r); + c = 0; + } + } + return outpos; + } + + public static int slowunpack(final int[] in, int inpos, final int[] out, + int outpos, int outlen, int b) { + if (outlen == 0) { + return inpos; + } + if (b == 32) { + System.arraycopy(in, inpos, out, outpos, outlen); + return inpos + outlen; + } + int mask = (1 << b) - 1; + int limit = outpos + outlen; + int r = 0; + int val = 0; + int i = 0; + for (; outpos < limit; i++) { + if (r > 0) + out[outpos++] = + (val >>> (32 - (b - r))) | ((in[inpos + i] << (b - r)) & mask); + val = in[inpos + i]; + int j = 0; + int l = 32 - r; + int ll = l % b == 0 ? l : l - b; + while (j < ll && outpos < limit) { + out[outpos++] = (val >> (j + r)) & mask; + j += b; + } + r = l % b == 0 ? 0 : b - (l % b); + } + return inpos + i; + } + + public static int numCompressedInts(int n, int b) { + int width = b % 2 == 0 ? VLEN_512 : VLEN_256; + if (n <= width) + return n; + int intsPerVec = (32 / b) * width; + int q = (n + intsPerVec - 1) / intsPerVec; + return q * width; + } + + public static void fastpack(final int[] in, int inpos, final int[] out, + int outpos, int b) { + switch (b) { + case 0: + break; + case 1: + fastpackOddBit(in, inpos, out, outpos, 1, new int[] {}, new int[] {}); + break; + case 2: + fastpackEvenBit(in, inpos, out, outpos, 2, new int[] {}, new int[] {}); + break; + case 3: + fastpackOddBit(in, inpos, out, outpos, 3, new int[] {0x2, 0x1}, + new int[] {0xb, 0xa}); + break; + case 4: + fastpackEvenBit(in, inpos, out, outpos, 4, new int[] {0x4}, + new int[] {0x8}); + break; + case 5: + fastpackOddBit(in, inpos, out, outpos, 5, new int[] {0x2, 0x4, 0x1, 0x3}, + new int[] {0x6, 0x7, 0x6, 0x6}); + break; + case 6: + fastpackEvenBit(in, inpos, out, outpos, 6, new int[] {0x2, 0x4}, + new int[] {0x5, 0x5}); + break; + case 7: + fastpackOddBit(in, inpos, out, outpos, 7, + new int[] {0x4, 0x1, 0x5, 0x2, 0x6, 0x3}, + new int[] {0x5, 0x4, 0x5, 0x4, 0x5, 0x4}); + break; + case 8: + fastpackEvenBit(in, inpos, out, outpos, 8, new int[] {0x8, 0x8, 0x8}, + new int[] {0x4, 0x4, 0x4}); + break; + case 9: + fastpackOddBit(in, inpos, out, outpos, 9, + new int[] {0x5, 0x1, 0x6, 0x2, 0x7, 0x3, 0x8, 0x4}, + new int[] {0x4, 0x3, 0x4, 0x3, 0x4, 0x3, 0x4, 0x3}); + break; + case 10: + fastpackEvenBit(in, inpos, out, outpos, 10, + new int[] {0x2, 0x4, 0x6, 0x8}, + new int[] {0x3, 0x3, 0x3, 0x3}); + break; + case 11: + fastpackOddBit( + in, inpos, out, outpos, 11, + new int[] {0xa, 0x9, 0x8, 0x7, 0x6, 0x5, 0x4, 0x3, 0x2, 0x1}, + new int[] {0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x2}); + break; + case 12: + fastpackEvenBit(in, inpos, out, outpos, 12, + new int[] {0x8, 0x4, 0xc, 0x8, 0x4}, + new int[] {0x3, 0x2, 0x3, 0x3, 0x2}); + break; + case 13: + fastpackOddBit(in, inpos, out, outpos, 13, + new int[] {0x6, 0xc, 0x5, 0xb, 0x4, 0xa, 0x3, 0x9, 0x2, + 0x8, 0x1, 0x7}, + new int[] {0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, + 0x3, 0x2, 0x2}); + break; + case 14: + fastpackEvenBit(in, inpos, out, outpos, 14, + new int[] {0x4, 0x8, 0xc, 0x2, 0x6, 0xa}, + new int[] {0x2, 0x2, 0x3, 0x2, 0x2, 0x2}); + break; + case 15: + fastpackOddBit(in, inpos, out, outpos, 15, + new int[] {0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe, 0x1, 0x3, + 0x5, 0x7, 0x9, 0xb, 0xd}, + new int[] {0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x3, 0x2, 0x2, + 0x2, 0x2, 0x2, 0x2, 0x2}); + break; + case 16: + fastpackEvenBit(in, inpos, out, outpos, 16, + new int[] {0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10}, + new int[] {0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2}); + break; + case 17: + fastpackOddBit(in, inpos, out, outpos, 17, + new int[] {0xf, 0xd, 0xb, 0x9, 0x7, 0x5, 0x3, 0x1, 0x10, + 0xe, 0xc, 0xa, 0x8, 0x6, 0x4, 0x2}, + new int[] {0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, 0x2, + 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1}); + break; + case 18: + fastpackEvenBit(in, inpos, out, outpos, 18, + new int[] {0xe, 0xa, 0x6, 0x2, 0x10, 0xc, 0x8, 0x4}, + new int[] {0x2, 0x2, 0x2, 0x1, 0x2, 0x2, 0x2, 0x1}); + break; + case 19: + fastpackOddBit(in, inpos, out, outpos, 19, + new int[] {0xd, 0x7, 0x1, 0xe, 0x8, 0x2, 0xf, 0x9, 0x3, + 0x10, 0xa, 0x4, 0x11, 0xb, 0x5, 0x12, 0xc, 0x6}, + new int[] {0x2, 0x2, 0x1, 0x2, 0x2, 0x1, 0x2, 0x2, 0x1, + 0x2, 0x2, 0x1, 0x2, 0x2, 0x1, 0x2, 0x2, 0x1}); + break; + case 20: + fastpackEvenBit( + in, inpos, out, outpos, 20, + new int[] {0xc, 0x4, 0x10, 0x8, 0x14, 0xc, 0x4, 0x10, 0x8}, + new int[] {0x2, 0x1, 0x2, 0x1, 0x2, 0x2, 0x1, 0x2, 0x1}); + break; + case 21: + fastpackOddBit( + in, inpos, out, outpos, 21, + new int[] {0xb, 0x1, 0xc, 0x2, 0xd, 0x3, 0xe, 0x4, 0xf, 0x5, + 0x10, 0x6, 0x11, 0x7, 0x12, 0x8, 0x13, 0x9, 0x14, 0xa}, + new int[] {0x2, 0x1, 0x2, 0x1, 0x2, 0x1, 0x2, 0x1, 0x2, 0x1, + 0x2, 0x1, 0x2, 0x1, 0x2, 0x1, 0x2, 0x1, 0x2, 0x1}); + break; + case 22: + fastpackEvenBit( + in, inpos, out, outpos, 22, + new int[] {0xa, 0x14, 0x8, 0x12, 0x6, 0x10, 0x4, 0xe, 0x2, 0xc}, + new int[] {0x1, 0x2, 0x1, 0x2, 0x1, 0x2, 0x1, 0x2, 0x1, 0x1}); + break; + case 23: + fastpackOddBit(in, inpos, out, outpos, 23, + new int[] {0x9, 0x12, 0x4, 0xd, 0x16, 0x8, 0x11, 0x3, + 0xc, 0x15, 0x7, 0x10, 0x2, 0xb, 0x14, 0x6, + 0xf, 0x1, 0xa, 0x13, 0x5, 0xe}, + new int[] {0x1, 0x2, 0x1, 0x1, 0x2, 0x1, 0x2, 0x1, + 0x1, 0x2, 0x1, 0x2, 0x1, 0x1, 0x2, 0x1, + 0x2, 0x1, 0x1, 0x2, 0x1, 0x1}); + break; + case 24: + fastpackEvenBit( + in, inpos, out, outpos, 24, + new int[] {0x8, 0x10, 0x18, 0x8, 0x10, 0x18, 0x8, 0x10, 0x18, 0x8, + 0x10}, + new int[] {0x1, 0x1, 0x2, 0x1, 0x1, 0x2, 0x1, 0x1, 0x2, 0x1, 0x1}); + break; + case 25: + fastpackOddBit(in, inpos, out, outpos, 25, + new int[] {0x7, 0xe, 0x15, 0x3, 0xa, 0x11, 0x18, 0x6, + 0xd, 0x14, 0x2, 0x9, 0x10, 0x17, 0x5, 0xc, + 0x13, 0x1, 0x8, 0xf, 0x16, 0x4, 0xb, 0x12}, + new int[] {0x1, 0x1, 0x2, 0x1, 0x1, 0x1, 0x2, 0x1, + 0x1, 0x2, 0x1, 0x1, 0x1, 0x2, 0x1, 0x1, + 0x2, 0x1, 0x1, 0x1, 0x2, 0x1, 0x1, 0x1}); + break; + case 26: + fastpackEvenBit(in, inpos, out, outpos, 26, + new int[] {0x6, 0xc, 0x12, 0x18, 0x4, 0xa, 0x10, 0x16, + 0x2, 0x8, 0xe, 0x14}, + new int[] {0x1, 0x1, 0x1, 0x2, 0x1, 0x1, 0x1, 0x2, 0x1, + 0x1, 0x1, 0x1}); + break; + case 27: + fastpackOddBit(in, inpos, out, outpos, 27, + new int[] {0x5, 0xa, 0xf, 0x14, 0x19, 0x3, 0x8, + 0xd, 0x12, 0x17, 0x1, 0x6, 0xb, 0x10, + 0x15, 0x1a, 0x4, 0x9, 0xe, 0x13, 0x18, + 0x2, 0x7, 0xc, 0x11, 0x16}, + new int[] {0x1, 0x1, 0x1, 0x1, 0x2, 0x1, 0x1, 0x1, 0x1, + 0x2, 0x1, 0x1, 0x1, 0x1, 0x1, 0x2, 0x1, 0x1, + 0x1, 0x1, 0x2, 0x1, 0x1, 0x1, 0x1, 0x1}); + break; + case 28: + fastpackEvenBit(in, inpos, out, outpos, 28, + new int[] {0x4, 0x8, 0xc, 0x10, 0x14, 0x18, 0x1c, 0x4, + 0x8, 0xc, 0x10, 0x14, 0x18}, + new int[] {0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x2, 0x1, 0x1, + 0x1, 0x1, 0x1, 0x1}); + break; + case 29: + fastpackOddBit( + in, inpos, out, outpos, 29, + new int[] {0x3, 0x6, 0x9, 0xc, 0xf, 0x12, 0x15, 0x18, 0x1b, 0x1, + 0x4, 0x7, 0xa, 0xd, 0x10, 0x13, 0x16, 0x19, 0x1c, 0x2, + 0x5, 0x8, 0xb, 0xe, 0x11, 0x14, 0x17, 0x1a}, + new int[] {0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x2, 0x1, + 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x2, 0x1, + 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1}); + break; + case 30: + fastpackEvenBit(in, inpos, out, outpos, 30, + new int[] {0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe, 0x10, 0x12, + 0x14, 0x16, 0x18, 0x1a, 0x1c}, + new int[] {0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, + 0x1, 0x1, 0x1, 0x1, 0x1}); + break; + case 31: + fastpackOddBit(in, inpos, out, outpos, 31, + new int[] {0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, + 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf, 0x10, + 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, + 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e}, + new int[] {0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, + 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, + 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, + 0x1, 0x1, 0x1, 0x1, 0x1, 0x1}); + break; + case 32: + System.arraycopy(in, inpos, out, outpos, 256); + break; + } + } + + public static void fastpackNoMask(final int[] in, int inpos, final int[] out, + int outpos, int b) { + switch (b) { + case 0: + break; + case 1: + fastpackOddBitNoMask(in, inpos, out, outpos, 1, new int[] {}, + new int[] {}); + break; + case 2: + fastpackEvenBitNoMask(in, inpos, out, outpos, 2, new int[] {}, + new int[] {}); + break; + case 3: + fastpackOddBitNoMask(in, inpos, out, outpos, 3, new int[] {0x2, 0x1}, + new int[] {0xb, 0xa}); + break; + case 4: + fastpackEvenBitNoMask(in, inpos, out, outpos, 4, new int[] {0x4}, + new int[] {0x8}); + break; + case 5: + fastpackOddBitNoMask(in, inpos, out, outpos, 5, + new int[] {0x2, 0x4, 0x1, 0x3}, + new int[] {0x6, 0x7, 0x6, 0x6}); + break; + case 6: + fastpackEvenBitNoMask(in, inpos, out, outpos, 6, new int[] {0x2, 0x4}, + new int[] {0x5, 0x5}); + break; + case 7: + fastpackOddBitNoMask(in, inpos, out, outpos, 7, + new int[] {0x4, 0x1, 0x5, 0x2, 0x6, 0x3}, + new int[] {0x5, 0x4, 0x5, 0x4, 0x5, 0x4}); + break; + case 8: + fastpackEvenBitNoMask(in, inpos, out, outpos, 8, + new int[] {0x8, 0x8, 0x8}, + new int[] {0x4, 0x4, 0x4}); + break; + case 9: + fastpackOddBitNoMask(in, inpos, out, outpos, 9, + new int[] {0x5, 0x1, 0x6, 0x2, 0x7, 0x3, 0x8, 0x4}, + new int[] {0x4, 0x3, 0x4, 0x3, 0x4, 0x3, 0x4, 0x3}); + break; + case 10: + fastpackEvenBitNoMask(in, inpos, out, outpos, 10, + new int[] {0x2, 0x4, 0x6, 0x8}, + new int[] {0x3, 0x3, 0x3, 0x3}); + break; + case 11: + fastpackOddBitNoMask( + in, inpos, out, outpos, 11, + new int[] {0xa, 0x9, 0x8, 0x7, 0x6, 0x5, 0x4, 0x3, 0x2, 0x1}, + new int[] {0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x2}); + break; + case 12: + fastpackEvenBitNoMask(in, inpos, out, outpos, 12, + new int[] {0x8, 0x4, 0xc, 0x8, 0x4}, + new int[] {0x3, 0x2, 0x3, 0x3, 0x2}); + break; + case 13: + fastpackOddBitNoMask(in, inpos, out, outpos, 13, + new int[] {0x6, 0xc, 0x5, 0xb, 0x4, 0xa, 0x3, 0x9, + 0x2, 0x8, 0x1, 0x7}, + new int[] {0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, + 0x2, 0x3, 0x2, 0x2}); + break; + case 14: + fastpackEvenBitNoMask(in, inpos, out, outpos, 14, + new int[] {0x4, 0x8, 0xc, 0x2, 0x6, 0xa}, + new int[] {0x2, 0x2, 0x3, 0x2, 0x2, 0x2}); + break; + case 15: + fastpackOddBitNoMask(in, inpos, out, outpos, 15, + new int[] {0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe, 0x1, + 0x3, 0x5, 0x7, 0x9, 0xb, 0xd}, + new int[] {0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x3, 0x2, + 0x2, 0x2, 0x2, 0x2, 0x2, 0x2}); + break; + case 16: + fastpackEvenBitNoMask( + in, inpos, out, outpos, 16, + new int[] {0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10}, + new int[] {0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2}); + break; + case 17: + fastpackOddBitNoMask(in, inpos, out, outpos, 17, + new int[] {0xf, 0xd, 0xb, 0x9, 0x7, 0x5, 0x3, 0x1, + 0x10, 0xe, 0xc, 0xa, 0x8, 0x6, 0x4, 0x2}, + new int[] {0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1, + 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x1}); + break; + case 18: + fastpackEvenBitNoMask(in, inpos, out, outpos, 18, + new int[] {0xe, 0xa, 0x6, 0x2, 0x10, 0xc, 0x8, 0x4}, + new int[] {0x2, 0x2, 0x2, 0x1, 0x2, 0x2, 0x2, 0x1}); + break; + case 19: + fastpackOddBitNoMask( + in, inpos, out, outpos, 19, + new int[] {0xd, 0x7, 0x1, 0xe, 0x8, 0x2, 0xf, 0x9, 0x3, 0x10, 0xa, + 0x4, 0x11, 0xb, 0x5, 0x12, 0xc, 0x6}, + new int[] {0x2, 0x2, 0x1, 0x2, 0x2, 0x1, 0x2, 0x2, 0x1, 0x2, 0x2, 0x1, + 0x2, 0x2, 0x1, 0x2, 0x2, 0x1}); + break; + case 20: + fastpackEvenBitNoMask( + in, inpos, out, outpos, 20, + new int[] {0xc, 0x4, 0x10, 0x8, 0x14, 0xc, 0x4, 0x10, 0x8}, + new int[] {0x2, 0x1, 0x2, 0x1, 0x2, 0x2, 0x1, 0x2, 0x1}); + break; + case 21: + fastpackOddBitNoMask( + in, inpos, out, outpos, 21, + new int[] {0xb, 0x1, 0xc, 0x2, 0xd, 0x3, 0xe, 0x4, 0xf, 0x5, + 0x10, 0x6, 0x11, 0x7, 0x12, 0x8, 0x13, 0x9, 0x14, 0xa}, + new int[] {0x2, 0x1, 0x2, 0x1, 0x2, 0x1, 0x2, 0x1, 0x2, 0x1, + 0x2, 0x1, 0x2, 0x1, 0x2, 0x1, 0x2, 0x1, 0x2, 0x1}); + break; + case 22: + fastpackEvenBitNoMask( + in, inpos, out, outpos, 22, + new int[] {0xa, 0x14, 0x8, 0x12, 0x6, 0x10, 0x4, 0xe, 0x2, 0xc}, + new int[] {0x1, 0x2, 0x1, 0x2, 0x1, 0x2, 0x1, 0x2, 0x1, 0x1}); + break; + case 23: + fastpackOddBitNoMask( + in, inpos, out, outpos, 23, + new int[] {0x9, 0x12, 0x4, 0xd, 0x16, 0x8, 0x11, 0x3, + 0xc, 0x15, 0x7, 0x10, 0x2, 0xb, 0x14, 0x6, + 0xf, 0x1, 0xa, 0x13, 0x5, 0xe}, + new int[] {0x1, 0x2, 0x1, 0x1, 0x2, 0x1, 0x2, 0x1, 0x1, 0x2, 0x1, + 0x2, 0x1, 0x1, 0x2, 0x1, 0x2, 0x1, 0x1, 0x2, 0x1, 0x1}); + break; + case 24: + fastpackEvenBitNoMask( + in, inpos, out, outpos, 24, + new int[] {0x8, 0x10, 0x18, 0x8, 0x10, 0x18, 0x8, 0x10, 0x18, 0x8, + 0x10}, + new int[] {0x1, 0x1, 0x2, 0x1, 0x1, 0x2, 0x1, 0x1, 0x2, 0x1, 0x1}); + break; + case 25: + fastpackOddBitNoMask(in, inpos, out, outpos, 25, + new int[] {0x7, 0xe, 0x15, 0x3, 0xa, 0x11, + 0x18, 0x6, 0xd, 0x14, 0x2, 0x9, + 0x10, 0x17, 0x5, 0xc, 0x13, 0x1, + 0x8, 0xf, 0x16, 0x4, 0xb, 0x12}, + new int[] {0x1, 0x1, 0x2, 0x1, 0x1, 0x1, 0x2, 0x1, + 0x1, 0x2, 0x1, 0x1, 0x1, 0x2, 0x1, 0x1, + 0x2, 0x1, 0x1, 0x1, 0x2, 0x1, 0x1, 0x1}); + break; + case 26: + fastpackEvenBitNoMask(in, inpos, out, outpos, 26, + new int[] {0x6, 0xc, 0x12, 0x18, 0x4, 0xa, 0x10, + 0x16, 0x2, 0x8, 0xe, 0x14}, + new int[] {0x1, 0x1, 0x1, 0x2, 0x1, 0x1, 0x1, 0x2, + 0x1, 0x1, 0x1, 0x1}); + break; + case 27: + fastpackOddBitNoMask( + in, inpos, out, outpos, 27, + new int[] {0x5, 0xa, 0xf, 0x14, 0x19, 0x3, 0x8, 0xd, 0x12, + 0x17, 0x1, 0x6, 0xb, 0x10, 0x15, 0x1a, 0x4, 0x9, + 0xe, 0x13, 0x18, 0x2, 0x7, 0xc, 0x11, 0x16}, + new int[] {0x1, 0x1, 0x1, 0x1, 0x2, 0x1, 0x1, 0x1, 0x1, + 0x2, 0x1, 0x1, 0x1, 0x1, 0x1, 0x2, 0x1, 0x1, + 0x1, 0x1, 0x2, 0x1, 0x1, 0x1, 0x1, 0x1}); + break; + case 28: + fastpackEvenBitNoMask(in, inpos, out, outpos, 28, + new int[] {0x4, 0x8, 0xc, 0x10, 0x14, 0x18, 0x1c, + 0x4, 0x8, 0xc, 0x10, 0x14, 0x18}, + new int[] {0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x2, 0x1, + 0x1, 0x1, 0x1, 0x1, 0x1}); + break; + case 29: + fastpackOddBitNoMask( + in, inpos, out, outpos, 29, + new int[] {0x3, 0x6, 0x9, 0xc, 0xf, 0x12, 0x15, 0x18, 0x1b, 0x1, + 0x4, 0x7, 0xa, 0xd, 0x10, 0x13, 0x16, 0x19, 0x1c, 0x2, + 0x5, 0x8, 0xb, 0xe, 0x11, 0x14, 0x17, 0x1a}, + new int[] {0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x2, 0x1, + 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x2, 0x1, + 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1}); + break; + case 30: + fastpackEvenBitNoMask(in, inpos, out, outpos, 30, + new int[] {0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe, 0x10, + 0x12, 0x14, 0x16, 0x18, 0x1a, 0x1c}, + new int[] {0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, + 0x1, 0x1, 0x1, 0x1, 0x1, 0x1}); + break; + case 31: + fastpackOddBitNoMask( + in, inpos, out, outpos, 31, + new int[] {0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, + 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf, 0x10, + 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, + 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e}, + new int[] {0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, + 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, + 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1}); + break; + case 32: + System.arraycopy(in, inpos, out, outpos, 256); + break; + } + } + + public static void fastunpack(final int[] in, int inpos, final int[] out, + int outpos, int b) { + switch (b) { + case 0: + Arrays.fill(out, outpos, outpos + 256, 0); + break; + case 1: + fastUnpackOddBit(in, inpos, out, outpos, 1, new int[] {}, new int[] {}, + new int[] {}); + break; + case 2: + fastUnpackEventBit(in, inpos, out, outpos, 2, new int[] {}, new int[] {}, + new int[] {}); + break; + case 3: + fastUnpackOddBit(in, inpos, out, outpos, 3, new int[] {0x1, 0x2}, + new int[] {0x1, 0x3}, new int[] {0xa, 0xa}); + break; + case 4: + fastUnpackEventBit(in, inpos, out, outpos, 4, new int[] {0x4}, + new int[] {0xf}, new int[] {0x7}); + break; + case 5: + fastUnpackOddBit( + in, inpos, out, outpos, 5, new int[] {0x3, 0x1, 0x4, 0x2}, + new int[] {0x7, 0x1, 0xf, 0x3}, new int[] {0x5, 0x6, 0x5, 0x6}); + break; + case 6: + fastUnpackEventBit(in, inpos, out, outpos, 6, new int[] {0x4, 0x2}, + new int[] {0xf, 0x3}, new int[] {0x4, 0x5}); + break; + case 7: + fastUnpackOddBit(in, inpos, out, outpos, 7, + new int[] {0x3, 0x6, 0x2, 0x5, 0x1, 0x4}, + new int[] {0x7, 0x3f, 0x3, 0x1f, 0x1, 0xf}, + new int[] {0x4, 0x3, 0x4, 0x3, 0x4, 0x4}); + break; + case 8: + fastUnpackEventBit(in, inpos, out, outpos, 8, new int[] {0x8, 0x8, 0x8}, + new int[] {0xff, 0xff, 0xff}, + new int[] {0x3, 0x3, 0x3}); + break; + case 9: + fastUnpackOddBit(in, inpos, out, outpos, 9, + new int[] {0x4, 0x8, 0x3, 0x7, 0x2, 0x6, 0x1, 0x5}, + new int[] {0xf, 0xff, 0x7, 0x7f, 0x3, 0x3f, 0x1, 0x1f}, + new int[] {0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x3}); + break; + case 10: + fastUnpackEventBit( + in, inpos, out, outpos, 10, new int[] {0x8, 0x6, 0x4, 0x2}, + new int[] {0xff, 0x3f, 0xf, 0x3}, new int[] {0x2, 0x2, 0x2, 0x3}); + break; + case 11: + fastUnpackOddBit( + in, inpos, out, outpos, 11, + new int[] {0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa}, + new int[] {0x1, 0x3, 0x7, 0xf, 0x1f, 0x3f, 0x7f, 0xff, 0x1ff, 0x3ff}, + new int[] {0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2}); + break; + case 12: + fastUnpackEventBit(in, inpos, out, outpos, 12, + new int[] {0x4, 0x8, 0xc, 0x4, 0x8}, + new int[] {0xf, 0xff, 0xfff, 0xf, 0xff}, + new int[] {0x2, 0x2, 0x1, 0x2, 0x2}); + break; + case 13: + fastUnpackOddBit(in, inpos, out, outpos, 13, + new int[] {0x7, 0x1, 0x8, 0x2, 0x9, 0x3, 0xa, 0x4, 0xb, + 0x5, 0xc, 0x6}, + new int[] {0x7f, 0x1, 0xff, 0x3, 0x1ff, 0x7, 0x3ff, 0xf, + 0x7ff, 0x1f, 0xfff, 0x3f}, + new int[] {0x1, 0x2, 0x1, 0x2, 0x1, 0x2, 0x1, 0x2, 0x1, + 0x2, 0x1, 0x2}); + break; + case 14: + fastUnpackEventBit(in, inpos, out, outpos, 14, + new int[] {0xa, 0x6, 0x2, 0xc, 0x8, 0x4}, + new int[] {0x3ff, 0x3f, 0x3, 0xfff, 0xff, 0xf}, + new int[] {0x1, 0x1, 0x2, 0x1, 0x1, 0x2}); + break; + case 15: + fastUnpackOddBit(in, inpos, out, outpos, 15, + new int[] {0xd, 0xb, 0x9, 0x7, 0x5, 0x3, 0x1, 0xe, 0xc, + 0xa, 0x8, 0x6, 0x4, 0x2}, + new int[] {0x1fff, 0x7ff, 0x1ff, 0x7f, 0x1f, 0x7, 0x1, + 0x3fff, 0xfff, 0x3ff, 0xff, 0x3f, 0xf, 0x3}, + new int[] {0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x2, 0x1, 0x1, + 0x1, 0x1, 0x1, 0x1, 0x2}); + break; + case 16: + fastUnpackEventBit( + in, inpos, out, outpos, 16, + new int[] {0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10}, + new int[] {0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff}, + new int[] {0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1}); + break; + case 17: + fastUnpackOddBit(in, inpos, out, outpos, 17, + new int[] {0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe, 0x10, 0x1, + 0x3, 0x5, 0x7, 0x9, 0xb, 0xd, 0xf}, + new int[] {0x3, 0xf, 0x3f, 0xff, 0x3ff, 0xfff, 0x3fff, + 0xffff, 0x1, 0x7, 0x1f, 0x7f, 0x1ff, 0x7ff, + 0x1fff, 0x7fff}, + new int[] {0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x0, 0x1, + 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1}); + break; + case 18: + fastUnpackEventBit( + in, inpos, out, outpos, 18, + new int[] {0x4, 0x8, 0xc, 0x10, 0x2, 0x6, 0xa, 0xe}, + new int[] {0xf, 0xff, 0xfff, 0xffff, 0x3, 0x3f, 0x3ff, 0x3fff}, + new int[] {0x1, 0x1, 0x1, 0x0, 0x1, 0x1, 0x1, 0x1}); + break; + case 19: + fastUnpackOddBit(in, inpos, out, outpos, 19, + new int[] {0x6, 0xc, 0x12, 0x5, 0xb, 0x11, 0x4, 0xa, + 0x10, 0x3, 0x9, 0xf, 0x2, 0x8, 0xe, 0x1, 0x7, + 0xd}, + new int[] {0x3f, 0xfff, 0x3ffff, 0x1f, 0x7ff, 0x1ffff, + 0xf, 0x3ff, 0xffff, 0x7, 0x1ff, 0x7fff, 0x3, + 0xff, 0x3fff, 0x1, 0x7f, 0x1fff}, + new int[] {0x1, 0x1, 0x0, 0x1, 0x1, 0x0, 0x1, 0x1, 0x0, + 0x1, 0x1, 0x0, 0x1, 0x1, 0x0, 0x1, 0x1, 0x1}); + break; + case 20: + fastUnpackEventBit( + in, inpos, out, outpos, 20, + new int[] {0x8, 0x10, 0x4, 0xc, 0x14, 0x8, 0x10, 0x4, 0xc}, + new int[] {0xff, 0xffff, 0xf, 0xfff, 0xfffff, 0xff, 0xffff, 0xf, + 0xfff}, + new int[] {0x1, 0x0, 0x1, 0x1, 0x0, 0x1, 0x0, 0x1, 0x1}); + break; + case 21: + fastUnpackOddBit( + in, inpos, out, outpos, 21, + new int[] {0xa, 0x14, 0x9, 0x13, 0x8, 0x12, 0x7, 0x11, 0x6, 0x10, + 0x5, 0xf, 0x4, 0xe, 0x3, 0xd, 0x2, 0xc, 0x1, 0xb}, + new int[] {0x3ff, 0xfffff, 0x1ff, 0x7ffff, 0xff, 0x3ffff, 0x7f, + 0x1ffff, 0x3f, 0xffff, 0x1f, 0x7fff, 0xf, 0x3fff, + 0x7, 0x1fff, 0x3, 0xfff, 0x1, 0x7ff}, + new int[] {0x1, 0x0, 0x1, 0x0, 0x1, 0x0, 0x1, 0x0, 0x1, 0x0, + 0x1, 0x0, 0x1, 0x0, 0x1, 0x0, 0x1, 0x0, 0x1, 0x1}); + break; + case 22: + fastUnpackEventBit( + in, inpos, out, outpos, 22, + new int[] {0xc, 0x2, 0xe, 0x4, 0x10, 0x6, 0x12, 0x8, 0x14, 0xa}, + new int[] {0xfff, 0x3, 0x3fff, 0xf, 0xffff, 0x3f, 0x3ffff, 0xff, + 0xfffff, 0x3ff}, + new int[] {0x0, 0x1, 0x0, 0x1, 0x0, 0x1, 0x0, 0x1, 0x0, 0x1}); + break; + case 23: + fastUnpackOddBit( + in, inpos, out, outpos, 23, + new int[] {0xe, 0x5, 0x13, 0xa, 0x1, 0xf, 0x6, 0x14, + 0xb, 0x2, 0x10, 0x7, 0x15, 0xc, 0x3, 0x11, + 0x8, 0x16, 0xd, 0x4, 0x12, 0x9}, + new int[] {0x3fff, 0x1f, 0x7ffff, 0x3ff, 0x1, 0x7fff, + 0x3f, 0xfffff, 0x7ff, 0x3, 0xffff, 0x7f, + 0x1fffff, 0xfff, 0x7, 0x1ffff, 0xff, 0x3fffff, + 0x1fff, 0xf, 0x3ffff, 0x1ff}, + new int[] {0x0, 0x1, 0x0, 0x0, 0x1, 0x0, 0x1, 0x0, 0x0, 0x1, 0x0, + 0x1, 0x0, 0x0, 0x1, 0x0, 0x1, 0x0, 0x0, 0x1, 0x0, 0x1}); + break; + case 24: + fastUnpackEventBit( + in, inpos, out, outpos, 24, + new int[] {0x10, 0x8, 0x18, 0x10, 0x8, 0x18, 0x10, 0x8, 0x18, 0x10, + 0x8}, + new int[] {0xffff, 0xff, 0xffffff, 0xffff, 0xff, 0xffffff, 0xffff, + 0xff, 0xffffff, 0xffff, 0xff}, + new int[] {0x0, 0x1, 0x0, 0x0, 0x1, 0x0, 0x0, 0x1, 0x0, 0x0, 0x1}); + break; + case 25: + fastUnpackOddBit( + in, inpos, out, outpos, 25, + new int[] {0x12, 0xb, 0x4, 0x16, 0xf, 0x8, 0x1, 0x13, + 0xc, 0x5, 0x17, 0x10, 0x9, 0x2, 0x14, 0xd, + 0x6, 0x18, 0x11, 0xa, 0x3, 0x15, 0xe, 0x7}, + new int[] {0x3ffff, 0x7ff, 0xf, 0x3fffff, 0x7fff, 0xff, + 0x1, 0x7ffff, 0xfff, 0x1f, 0x7fffff, 0xffff, + 0x1ff, 0x3, 0xfffff, 0x1fff, 0x3f, 0xffffff, + 0x1ffff, 0x3ff, 0x7, 0x1fffff, 0x3fff, 0x7f}, + new int[] {0x0, 0x0, 0x1, 0x0, 0x0, 0x0, 0x1, 0x0, + 0x0, 0x1, 0x0, 0x0, 0x0, 0x1, 0x0, 0x0, + 0x1, 0x0, 0x0, 0x0, 0x1, 0x0, 0x0, 0x1}); + break; + case 26: + fastUnpackEventBit(in, inpos, out, outpos, 26, + new int[] {0x14, 0xe, 0x8, 0x2, 0x16, 0x10, 0xa, 0x4, + 0x18, 0x12, 0xc, 0x6}, + new int[] {0xfffff, 0x3fff, 0xff, 0x3, 0x3fffff, + 0xffff, 0x3ff, 0xf, 0xffffff, 0x3ffff, + 0xfff, 0x3f}, + new int[] {0x0, 0x0, 0x0, 0x1, 0x0, 0x0, 0x0, 0x1, 0x0, + 0x0, 0x0, 0x1}); + break; + case 27: + fastUnpackOddBit( + in, inpos, out, outpos, 27, + new int[] {0x16, 0x11, 0xc, 0x7, 0x2, 0x18, 0x13, 0xe, 0x9, + 0x4, 0x1a, 0x15, 0x10, 0xb, 0x6, 0x1, 0x17, 0x12, + 0xd, 0x8, 0x3, 0x19, 0x14, 0xf, 0xa, 0x5}, + new int[] {0x3fffff, 0x1ffff, 0xfff, 0x7f, 0x3, 0xffffff, + 0x7ffff, 0x3fff, 0x1ff, 0xf, 0x3ffffff, 0x1fffff, + 0xffff, 0x7ff, 0x3f, 0x1, 0x7fffff, 0x3ffff, + 0x1fff, 0xff, 0x7, 0x1ffffff, 0xfffff, 0x7fff, + 0x3ff, 0x1f}, + new int[] {0x0, 0x0, 0x0, 0x0, 0x1, 0x0, 0x0, 0x0, 0x0, + 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0, 0x0, + 0x0, 0x0, 0x1, 0x0, 0x0, 0x0, 0x0, 0x1}); + break; + case 28: + fastUnpackEventBit(in, inpos, out, outpos, 28, + new int[] {0x18, 0x14, 0x10, 0xc, 0x8, 0x4, 0x1c, 0x18, + 0x14, 0x10, 0xc, 0x8, 0x4}, + new int[] {0xffffff, 0xfffff, 0xffff, 0xfff, 0xff, 0xf, + 0xfffffff, 0xffffff, 0xfffff, 0xffff, 0xfff, + 0xff, 0xf}, + new int[] {0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x1}); + break; + case 29: + fastUnpackOddBit( + in, inpos, out, outpos, 29, + new int[] {0x1a, 0x17, 0x14, 0x11, 0xe, 0xb, 0x8, 0x5, 0x2, 0x1c, + 0x19, 0x16, 0x13, 0x10, 0xd, 0xa, 0x7, 0x4, 0x1, 0x1b, + 0x18, 0x15, 0x12, 0xf, 0xc, 0x9, 0x6, 0x3}, + new int[] {0x3ffffff, 0x7fffff, 0xfffff, 0x1ffff, 0x3fff, + 0x7ff, 0xff, 0x1f, 0x3, 0xfffffff, + 0x1ffffff, 0x3fffff, 0x7ffff, 0xffff, 0x1fff, + 0x3ff, 0x7f, 0xf, 0x1, 0x7ffffff, + 0xffffff, 0x1fffff, 0x3ffff, 0x7fff, 0xfff, + 0x1ff, 0x3f, 0x7}, + new int[] {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1}); + break; + case 30: + fastUnpackEventBit(in, inpos, out, outpos, 30, + new int[] {0x1c, 0x1a, 0x18, 0x16, 0x14, 0x12, 0x10, + 0xe, 0xc, 0xa, 0x8, 0x6, 0x4, 0x2}, + new int[] {0xfffffff, 0x3ffffff, 0xffffff, 0x3fffff, + 0xfffff, 0x3ffff, 0xffff, 0x3fff, 0xfff, + 0x3ff, 0xff, 0x3f, 0xf, 0x3}, + new int[] {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x1}); + break; + case 31: + fastUnpackOddBit( + in, inpos, out, outpos, 31, + new int[] {0x1e, 0x1d, 0x1c, 0x1b, 0x1a, 0x19, 0x18, 0x17, 0x16, 0x15, + 0x14, 0x13, 0x12, 0x11, 0x10, 0xf, 0xe, 0xd, 0xc, 0xb, + 0xa, 0x9, 0x8, 0x7, 0x6, 0x5, 0x4, 0x3, 0x2, 0x1}, + new int[] {0x3fffffff, 0x1fffffff, 0xfffffff, 0x7ffffff, 0x3ffffff, + 0x1ffffff, 0xffffff, 0x7fffff, 0x3fffff, 0x1fffff, + 0xfffff, 0x7ffff, 0x3ffff, 0x1ffff, 0xffff, + 0x7fff, 0x3fff, 0x1fff, 0xfff, 0x7ff, + 0x3ff, 0x1ff, 0xff, 0x7f, 0x3f, + 0x1f, 0xf, 0x7, 0x3, 0x1}, + new int[] {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, + 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1}); + break; + + case 32: + System.arraycopy(in, inpos, out, outpos, 256); + break; + } + } +} diff --git a/src/main/java/me/lemire/integercompression/vector/VectorFastPFOR.java b/src/main/java/me/lemire/integercompression/vector/VectorFastPFOR.java new file mode 100644 index 0000000..7374fa5 --- /dev/null +++ b/src/main/java/me/lemire/integercompression/vector/VectorFastPFOR.java @@ -0,0 +1,366 @@ +/** + * This code is released under the + * Apache License Version 2.0 http://www.apache.org/licenses/. + * + * (c) Daniel Lemire, http://lemire.me/en/ + * (c) Intel Corp. (for Vector implementation) + */ +package me.lemire.integercompression.vector; + +import java.nio.ByteBuffer; +import java.util.Arrays; +import me.lemire.integercompression.IntegerCODEC; +import me.lemire.integercompression.SkippableIntegerCODEC; +import me.lemire.integercompression.IntWrapper; + +/** + * This is a patching scheme designed for speed. + * It encodes integers in blocks of integers within pages of + * up to 65536 integers. Note that it is important, to get good + * compression and good performance, to use sizeable arrays (greater than 1024 + * integers). For arrays containing a number of integers that is not divisible + * by BLOCK_SIZE, you should use it in conjunction with another CODEC: + * + * IntegerCODEC ic = new Composition(new VectorFastPFOR(), new VariableByte()). + *

+ * For details, please see: + *

+ * Daniel Lemire and Leonid Boytsov, Decoding billions of integers per second + * through vectorization Software: Practice & Experience + * http://onlinelibrary.wiley.com/doi/10.1002/spe.2203/abstract + * http://arxiv.org/abs/1209.2137 + *

+ *

For sufficiently compressible and long arrays, it is faster and better + * than other PFOR schemes.

+ * + * Note that this does not use differential coding: if you are working on sorted + * lists, you should first compute deltas, @see + * me.lemire.integercompression.differential.Delta#delta. + * + * For multi-threaded applications, each thread should use its own FastPFOR + * object. + * + * @author Daniel Lemire + */ +public class VectorFastPFOR implements IntegerCODEC, SkippableIntegerCODEC { + private final static int OVERHEAD_OF_EACH_EXCEPT = 8; + public final static int DEFAULT_PAGE_SIZE = 64 << 10; + + public final static int BLOCK_SIZE = 256; + private final static int INTS_PER_BLOCK = BLOCK_SIZE >>> 5; + + private final int pageSize; + private final int[][] dataTobePacked = new int[33][]; + private int[] exceptData = null; + + // Working area for compress and uncompress. + private final int[] dataPointers = new int[33]; + private final int[] freqs = new int[33]; + private final byte[] bem; + /** + * Construct the FastPFOR CODEC. + * + * @param pagesize + * the desired page size (recommended value is + * FastPFOR.DEFAULT_PAGE_SIZE) + */ + private VectorFastPFOR(int pagesize) { + pageSize = pagesize; + // Initiate arrrays. + bem = new byte[3 * pageSize / BLOCK_SIZE + pagesize]; + for (int k = 1; k < dataTobePacked.length; ++k) + dataTobePacked[k] = new int[pageSize / 32 * 4]; // heuristic + exceptData = new int[pageSize * 4]; + } + + /** + * Construct the fastPFOR CODEC with default parameters. + */ + public VectorFastPFOR() { this(DEFAULT_PAGE_SIZE); } + + /** + * Compress data in blocks of BLOCK_SIZE integers (if fewer than BLOCK_SIZE + * integers are provided, nothing is done). + * + * @see IntegerCODEC#compress(int[], IntWrapper, int, int[], IntWrapper) + */ + @Override + public void headlessCompress(int[] in, IntWrapper inpos, int inlength, + int[] out, IntWrapper outpos) { + inlength = inlength - inlength % BLOCK_SIZE; + // Allocate memory for working area. + + final int finalinpos = inpos.get() + inlength; + while (inpos.get() != finalinpos) { + int thissize = Math.min(pageSize, finalinpos - inpos.get()); + encodePage(in, inpos, thissize, out, outpos); + } + } + + private void getBestBitSize(int[] in, int pos, int index) { + Arrays.fill(freqs, 0); + for (int i = pos, limit = pos + BLOCK_SIZE; i < limit; i++) { + freqs[32 - Integer.numberOfLeadingZeros(in[i])]++; + } + bem[index] = 32; + while (freqs[bem[index]] == 0) + bem[index]--; + bem[index + 2] = bem[index]; + int maxb = bem[index + 2]; + int bestcost = bem[index] * BLOCK_SIZE; + int cexcept = 0; + bem[index + 1] = 0; + for (int b = bem[index] - 1; b >= 0; --b) { + cexcept += freqs[b + 1]; + if (cexcept == BLOCK_SIZE) + break; + // the extra 8 is the cost of storing maxbits + int thiscost = cexcept * OVERHEAD_OF_EACH_EXCEPT + cexcept * (maxb - b) + + b * BLOCK_SIZE + 8; + if (maxb - b == 1) + thiscost -= cexcept; + if (thiscost < bestcost) { + bestcost = thiscost; + bem[index] = (byte)b; + bem[index + 1] = (byte)cexcept; + } + } + } + + private void encodePage(int[] in, IntWrapper inpos, int thissize, int[] out, + IntWrapper outpos) { + final int headerpos = outpos.get(); + outpos.increment(); + int tmpoutpos = outpos.get(); + + // Clear working area. + Arrays.fill(dataPointers, 0); + Arrays.fill(bem, (byte)0); + + int tmpinpos = inpos.get(); + final int finalinpos = tmpinpos + thissize - BLOCK_SIZE; + int bindex = 0; + for (; tmpinpos <= finalinpos; tmpinpos += BLOCK_SIZE) { + getBestBitSize(in, tmpinpos, bindex); + final int tmpexcept = bem[bindex + 1] & 0xFF; + final int tmpbestb = bem[bindex]; + if (tmpexcept > 0) { + final int index = bem[bindex + 2] - tmpbestb; + if (dataPointers[index] + tmpexcept >= dataTobePacked[index].length) { + int newsize = 2 * (dataPointers[index] + tmpexcept); + int val = newsize + BLOCK_SIZE - 1; + newsize = val - val % BLOCK_SIZE; + dataTobePacked[index] = Arrays.copyOf(dataTobePacked[index], newsize); + } + bindex += 3; + for (int k = 0; k < BLOCK_SIZE; ++k) { + if ((in[k + tmpinpos] >>> tmpbestb) != 0) { + // we have an exception + bem[bindex++] = (byte)k; + dataTobePacked[index][dataPointers[index]++] = + in[k + tmpinpos] >>> tmpbestb; + } + } + } else { + bindex += 2; + } + VectorBitPacker.fastpack(in, tmpinpos, out, tmpoutpos, tmpbestb); + tmpoutpos += INTS_PER_BLOCK * tmpbestb; + } + inpos.set(tmpinpos); + out[headerpos] = tmpoutpos - headerpos; + + int bytesize = bindex; + out[tmpoutpos++] = bytesize; + + bytesize = bytesize % 4 == 0 ? bytesize : (bytesize / 4) * 4 + 4; + for (int i = 0; i <= bytesize - 4; i += 4) { + out[tmpoutpos] = bem[i] & 0xFF; + out[tmpoutpos] |= (bem[i + 1] & 0xFF) << 8; + out[tmpoutpos] |= (bem[i + 2] & 0xFF) << 16; + out[tmpoutpos] |= (bem[i + 3] & 0xFF) << 24; + tmpoutpos++; + } + + int bitmap = 0; + for (int k = 2; k <= 32; ++k) { + if (dataPointers[k] != 0) + bitmap |= (1 << (k - 1)); + } + out[tmpoutpos++] = bitmap; + + for (int k = 2; k <= 32; ++k) { + if (dataPointers[k] != 0) { + out[tmpoutpos++] = dataPointers[k]; // size + int j = 0; + int n = (dataPointers[k] / BLOCK_SIZE) * BLOCK_SIZE; + for (; j < n; j += BLOCK_SIZE) { + VectorBitPacker.fastpackNoMask(dataTobePacked[k], j, out, tmpoutpos, + k); + tmpoutpos += INTS_PER_BLOCK * k; + } + int r = dataPointers[k] % BLOCK_SIZE; + if (r != 0) { + tmpoutpos = VectorBitPacker.slowpack(dataTobePacked[k], j, r, out, + tmpoutpos, k); + tmpoutpos++; + } + } + } + outpos.set(tmpoutpos); + } + + /** + * Uncompress data in blocks of integers. In this particular case, + * the inlength parameter is ignored: it is deduced from the compressed + * data. + * + * @see IntegerCODEC#compress(int[], IntWrapper, int, int[], IntWrapper) + */ + @Override + public void headlessUncompress(int[] in, IntWrapper inpos, int inlength, + int[] out, IntWrapper outpos, int mynvalue) { + mynvalue = mynvalue - mynvalue % BLOCK_SIZE; + int finalout = outpos.get() + mynvalue; + while (outpos.get() != finalout) { + int thissize = Math.min(pageSize, finalout - outpos.get()); + decodePage(in, inpos, out, outpos, thissize); + } + } + + @Override + public int maxHeadlessCompressedLength(IntWrapper compressedPositions, int inlength) { + throw new UnsupportedOperationException("Calculating the max compressed length is not supported yet."); + } + + private void loadMetaData(int[] in, int inexcept, int bytesize) { + // Arrays.fill(bem, (byte)0); + int len = (bytesize + 3) / 4; + int lc = 0; + for (int i = 0; i < len; i++) { + bem[lc++] = (byte)(in[inexcept + i]); + bem[lc++] = (byte)(in[inexcept + i] >>> 8); + bem[lc++] = (byte)(in[inexcept + i] >>> 16); + bem[lc++] = (byte)(in[inexcept + i] >>> 24); + } + } + + private void decodePage(int[] in, IntWrapper inpos, int[] out, + IntWrapper outpos, int thissize) { + final int initpos = inpos.get(); + final int wheremeta = in[inpos.get()]; + inpos.increment(); + int inexcept = initpos + wheremeta; + + final int bytesize = in[inexcept++]; + loadMetaData(in, inexcept, bytesize); + inexcept += (bytesize + 3) / 4; + final int bitmap = in[inexcept++]; + for (int k = 2; k <= 32; ++k) { + if ((bitmap & (1 << (k - 1))) != 0) { + int size = in[inexcept++]; + int val = size + BLOCK_SIZE - 1; + int roundedup = val - val % BLOCK_SIZE; + if (dataTobePacked[k].length < roundedup) + dataTobePacked[k] = new int[roundedup]; + if (inexcept + roundedup / 32 * k <= in.length) { + int j = 0; + int len = (size / BLOCK_SIZE) * BLOCK_SIZE; + for (; j < len; j += BLOCK_SIZE) { + VectorBitPacker.fastunpack(in, inexcept, dataTobePacked[k], j, k); + inexcept += INTS_PER_BLOCK * k; + } + int r = size % BLOCK_SIZE; + inexcept = VectorBitPacker.slowunpack(in, inexcept, dataTobePacked[k], + j, r, k); + } else { + int j = 0; + val = roundedup / 32 * k + BLOCK_SIZE - 1; + int[] buf = new int[val - val % BLOCK_SIZE]; + int initinexcept = inexcept; + System.arraycopy(in, inexcept, buf, 0, in.length - inexcept); + int l = (size / BLOCK_SIZE) * BLOCK_SIZE; + for (; j < l; j += BLOCK_SIZE) { + VectorBitPacker.fastunpack(buf, inexcept - initinexcept, + dataTobePacked[k], j, k); + inexcept += INTS_PER_BLOCK * k; + } + int r = size % BLOCK_SIZE; + inexcept = VectorBitPacker.slowunpack(in, inexcept, dataTobePacked[k], + j, r, k); + } + } + } + Arrays.fill(dataPointers, 0); + int tmpoutpos = outpos.get(); + int tmpinpos = inpos.get(); + int idx = 0; + for (int run = 0, run_end = thissize / BLOCK_SIZE; run < run_end; + ++run, tmpoutpos += BLOCK_SIZE) { + final int b = bem[idx]; // byteContainer.get(); + final int cexcept = bem[idx + 1] & 0xFF; // byteContainer.get() & 0xFF; + VectorBitPacker.fastunpack(in, tmpinpos, out, tmpoutpos, b); + tmpinpos += INTS_PER_BLOCK * b; + if (cexcept > 0) { + final int maxbits = bem[idx + 2]; // byteContainer.get(); + idx += 3; + final int index = maxbits - b; + if (index == 1) { + for (int k = 0; k < cexcept; ++k) { + final int pos = bem[idx++] & 0xFF; // byteContainer.get() & 0xFF; + out[pos + tmpoutpos] |= 1 << b; + } + } else { + for (int k = 0; k < cexcept; ++k) { + final int pos = bem[idx++] & 0xFF; // byteContainer.get() & 0xFF; + final int exceptvalue = + dataTobePacked[index][dataPointers[index]++]; + out[pos + tmpoutpos] |= exceptvalue << b; + } + } + } else { + idx += 2; + } + } + outpos.set(tmpoutpos); + inpos.set(inexcept); + } + + @Override + public void compress(int[] in, IntWrapper inpos, int inlength, int[] out, + IntWrapper outpos) { + inlength = inlength - inlength % BLOCK_SIZE; + if (inlength == 0) + return; + out[outpos.get()] = inlength; + outpos.increment(); + headlessCompress(in, inpos, inlength, out, outpos); + } + + @Override + public void uncompress(int[] in, IntWrapper inpos, int inlength, int[] out, + IntWrapper outpos) { + if (inlength == 0) + return; + final int outlength = in[inpos.get()]; + inpos.increment(); + headlessUncompress(in, inpos, inlength, out, outpos, outlength); + } + @Override + public String toString() { + return this.getClass().getSimpleName(); + } + + /** + * Creates a new buffer of the requested size. + * + * In case you need a different way to allocate buffers, you can override this + * method with a custom behavior. The default implementation allocates a new + * Java direct + * {@link ByteBuffer} on each invocation. + */ + protected ByteBuffer makeBuffer(int sizeInBytes) { + return ByteBuffer.allocateDirect(sizeInBytes); + } +} diff --git a/src/main/java/me/lemire/longcompression/ByteLongCODEC.java b/src/main/java/me/lemire/longcompression/ByteLongCODEC.java new file mode 100644 index 0000000..dbc6864 --- /dev/null +++ b/src/main/java/me/lemire/longcompression/ByteLongCODEC.java @@ -0,0 +1,62 @@ +/** + * This code is released under the + * Apache License Version 2.0 http://www.apache.org/licenses/. + * + * (c) Daniel Lemire, http://lemire.me/en/ + */ + +package me.lemire.longcompression; + +import me.lemire.integercompression.IntWrapper; + +/** + * Interface describing a CODEC to compress longs to bytes. + * + * @author Benoit Lacelle + * + */ +public interface ByteLongCODEC { + /** + * Compress data from an array to another array. + * + * Both inpos and outpos are modified to represent how much data was + * read and written to. If 12 longs (inlength = 12) are compressed to 3 + * bytes, then inpos will be incremented by 12 while outpos will be + * incremented by 3. We use IntWrapper to pass the values by reference. + * + * @param in + * input array + * @param inpos + * location in the input array + * @param inlength + * how many longs to compress + * @param out + * output array + * @param outpos + * where to write in the output array + */ + public void compress(long[] in, IntWrapper inpos, int inlength, + byte[] out, IntWrapper outpos); + + /** + * Uncompress data from an array to another array. + * + * Both inpos and outpos parameters are modified to indicate new + * positions after read/write. + * + * @param in + * array containing data in compressed form + * @param inpos + * where to start reading in the array + * @param inlength + * length of the compressed data (ignored by some + * schemes) + * @param out + * array where to write the compressed output + * @param outpos + * where to write the compressed output in out + */ + public void uncompress(byte[] in, IntWrapper inpos, int inlength, + long[] out, IntWrapper outpos); + +} diff --git a/src/main/java/me/lemire/longcompression/IntegratedLongCODEC.java b/src/main/java/me/lemire/longcompression/IntegratedLongCODEC.java new file mode 100644 index 0000000..b21ef68 --- /dev/null +++ b/src/main/java/me/lemire/longcompression/IntegratedLongCODEC.java @@ -0,0 +1,11 @@ +package me.lemire.longcompression; + +/** + * This is just like LongCODEC, except that it indicates that delta coding is + * "integrated", so that you don't need a separate step for delta coding. + * + * @author Benoit Lacelle + */ +public interface IntegratedLongCODEC extends LongCODEC { + +} diff --git a/src/main/java/me/lemire/longcompression/LongAs2IntsCodec.java b/src/main/java/me/lemire/longcompression/LongAs2IntsCodec.java new file mode 100644 index 0000000..35c1166 --- /dev/null +++ b/src/main/java/me/lemire/longcompression/LongAs2IntsCodec.java @@ -0,0 +1,189 @@ +package me.lemire.longcompression; + +import java.util.Arrays; + +import me.lemire.integercompression.BinaryPacking; +import me.lemire.integercompression.Composition; +import me.lemire.integercompression.IntCompressor; +import me.lemire.integercompression.IntWrapper; +import me.lemire.integercompression.IntegerCODEC; +import me.lemire.integercompression.VariableByte; + +/** + * A {@link LongCODEC} which split each long in a highpart (32 first bits) and a low part (32 last bits). + * + * @author Benoit Lacelle + * + */ +public class LongAs2IntsCodec implements LongCODEC { + final IntegerCODEC highPartsCodec; + final IntegerCODEC lowPartsCodec; + + public LongAs2IntsCodec(IntegerCODEC highPartsCodec, IntegerCODEC lowPartsCodec) { + this.highPartsCodec = highPartsCodec; + this.lowPartsCodec = lowPartsCodec; + } + + /** + * By default, we expect longs to be slightly above Integer.MAX_VALUE. Hence highParts to be small and positive + * integers. For lowParts, we rely on {@link IntCompressor} default IntegerCODEC + */ + public LongAs2IntsCodec() { + this(new VariableByte(), new Composition(new BinaryPacking(), new VariableByte())); + } + + @Override + public void compress(long[] in, IntWrapper inpos, int inlength, long[] out, IntWrapper outpos) { + if (inlength == 0) { + return; + } + + int[] highParts = new int[inlength]; + int[] lowParts = new int[inlength]; + + for (int i = 0; i < inlength; i++) { + int inPosition = inpos.get() + i; + + highParts[i] = RoaringIntPacking.high(in[inPosition]); + lowParts[i] = RoaringIntPacking.low(in[inPosition]); + } + + // TODO What would be a relevant buffer size? + int[] buffer = new int[inlength * 16]; + + int outPosition = outpos.get(); + + boolean hasLeftover; + { + // The first integer is reserved to hold the number of compressed ints + IntWrapper highPartsOutPosition = new IntWrapper(1); + + highPartsCodec.compress(highParts, new IntWrapper(), inlength, buffer, highPartsOutPosition); + + // Record the compressedHighparts length + buffer[0] = highPartsOutPosition.get() - 1; + + for (int i = 0; i < highPartsOutPosition.get() / 2; i++) { + long pack = RoaringIntPacking.pack(buffer[i * 2], buffer[i * 2 + 1]); + out[outPosition++] = pack; + } + + if (1 == highPartsOutPosition.get() % 2) { + // Shift the trailing integer as first in the buffer + hasLeftover = true; + buffer[0] = buffer[highPartsOutPosition.get() - 1]; + } else { + hasLeftover = false; + } + } + + { + // The first integer is reserved to hold the number of compressed ints + IntWrapper lowPartsOutPosition = new IntWrapper(1); + if (hasLeftover) { + // Keep the trailing int from highParts before the reserved int from lowParts compressed length + lowPartsOutPosition.set(2); + } + + lowPartsCodec.compress(lowParts, new IntWrapper(0), inlength, buffer, lowPartsOutPosition); + + // Record the compressedHighparts length + buffer[hasLeftover ? 1 : 0] = lowPartsOutPosition.get() - (hasLeftover ? 2 : 1); + + for (int i = 0; i < lowPartsOutPosition.get() / 2; i++) { + long pack = RoaringIntPacking.pack(buffer[i * 2], buffer[i * 2 + 1]); + out[outPosition++] = pack; + } + + if (1 == lowPartsOutPosition.get() % 2) { + // The trailing integer is packed with a 0 + long pack = RoaringIntPacking.pack(buffer[lowPartsOutPosition.get() - 1], 0); + out[outPosition++] = pack; + } + } + + inpos.add(inlength); + outpos.set(outPosition); + } + + /** + * inlength is ignored by this codec. We may rely on it instead of storing the compressedLowPart length + */ + @Override + public void uncompress(long[] in, IntWrapper inpos, int inlength, long[] out, IntWrapper outpos) { + if (inlength == 0) { + return; + } + + int longIndex = inpos.get(); + + int nbCompressedHighParts = RoaringIntPacking.high(in[longIndex]); + int[] compressedHighParts = new int[nbCompressedHighParts]; + + // !highPart as we just read the highPart for nbCompressedHighParts + boolean highPart = false; + for (int i = 0; i < nbCompressedHighParts; i++) { + int nextInt; + if (highPart) { + nextInt = RoaringIntPacking.high(in[longIndex + (i + 1) / 2]); + } else { + nextInt = RoaringIntPacking.low(in[longIndex + (i + 1) / 2]); + } + compressedHighParts[i] = nextInt; + + highPart = !highPart; + } + + // TODO What would be a relevant buffer size? + int[] buffer = new int[inlength * 16]; + + IntWrapper highPartsOutPosition = new IntWrapper(); + highPartsCodec.uncompress(compressedHighParts, + new IntWrapper(), + compressedHighParts.length, + buffer, + highPartsOutPosition); + int[] highParts = Arrays.copyOf(buffer, highPartsOutPosition.get()); + + // +1 as we initially read nbCompressedHighParts + int intIndexNbCompressedLowParts = longIndex * 2 + 1 + nbCompressedHighParts; + int nbCompressedLowParts; + if (highPart) { + nbCompressedLowParts = RoaringIntPacking.high(in[intIndexNbCompressedLowParts / 2]); + } else { + nbCompressedLowParts = RoaringIntPacking.low(in[intIndexNbCompressedLowParts / 2]); + } + highPart = !highPart; + + int[] compressedLowParts = new int[nbCompressedLowParts]; + for (int i = 0; i < nbCompressedLowParts; i++) { + int nextInt; + if (highPart) { + nextInt = RoaringIntPacking.high(in[(intIndexNbCompressedLowParts + 1 + i) / 2]); + } else { + nextInt = RoaringIntPacking.low(in[(intIndexNbCompressedLowParts + 1 + i) / 2]); + } + compressedLowParts[i] = nextInt; + + highPart = !highPart; + } + + IntWrapper lowPartsOutPosition = new IntWrapper(); + lowPartsCodec.uncompress(compressedLowParts, + new IntWrapper(), + compressedLowParts.length, + buffer, + lowPartsOutPosition); + int[] lowParts = Arrays.copyOf(buffer, lowPartsOutPosition.get()); + assert highParts.length == lowParts.length; + + int outposition = outpos.get(); + for (int i = 0; i < highParts.length; i++) { + out[outposition++] = RoaringIntPacking.pack(highParts[i], lowParts[i]); + } + + inpos.add(inlength); + outpos.set(outposition); + } + +} diff --git a/src/main/java/me/lemire/longcompression/LongBinaryPacking.java b/src/main/java/me/lemire/longcompression/LongBinaryPacking.java new file mode 100644 index 0000000..b6ea58f --- /dev/null +++ b/src/main/java/me/lemire/longcompression/LongBinaryPacking.java @@ -0,0 +1,153 @@ +package me.lemire.longcompression; + +import me.lemire.integercompression.BinaryPacking; +import me.lemire.integercompression.IntWrapper; +import me.lemire.integercompression.Util; + +/** + * Scheme based on a commonly used idea: can be extremely fast. + * It encodes integers in blocks of 64 longs. For arrays containing + * an arbitrary number of longs, you should use it in conjunction + * with another CODEC: + * + *
LongCODEC ic = 
+ *  new Composition(new LongBinaryPacking(), new LongVariableByte()).
+ * + * Note that this does not use differential coding: if you are working on sorted + * lists, you must compute the deltas separately. + * + *

+ * For details, please see {@link BinaryPacking} + *

+ * + * @author Benoit Lacelle + */ +public final class LongBinaryPacking implements LongCODEC, SkippableLongCODEC { + public final static int BLOCK_SIZE = 64; + private static final int MAX_BIT_WIDTH = Long.SIZE; + + @Override + public void compress(long[] in, IntWrapper inpos, int inlength, + long[] out, IntWrapper outpos) { + inlength = Util.greatestMultiple(inlength, BLOCK_SIZE); + if (inlength == 0) + return; + out[outpos.get()] = inlength; + outpos.increment(); + headlessCompress(in, inpos, inlength, out, outpos); + } + + @Override + public void headlessCompress(long[] in, IntWrapper inpos, int inlength, + long[] out, IntWrapper outpos) { + inlength = Util.greatestMultiple(inlength, BLOCK_SIZE); + int tmpoutpos = outpos.get(); + int s = inpos.get(); + // Compress by block of 8 * 64 longs as much as possible + for (; s + BLOCK_SIZE * 8 - 1 < inpos.get() + inlength; s += BLOCK_SIZE * 8) { + // maxbits can be anything between 0 and 64 included: expressed within a byte (1 << 6) + final int mbits1 = LongUtil.maxbits(in, s + 0 * BLOCK_SIZE, BLOCK_SIZE); + final int mbits2 = LongUtil.maxbits(in, s + 1 * BLOCK_SIZE, BLOCK_SIZE); + final int mbits3 = LongUtil.maxbits(in, s + 2 * BLOCK_SIZE, BLOCK_SIZE); + final int mbits4 = LongUtil.maxbits(in, s + 3 * BLOCK_SIZE, BLOCK_SIZE); + final int mbits5 = LongUtil.maxbits(in, s + 4 * BLOCK_SIZE, BLOCK_SIZE); + final int mbits6 = LongUtil.maxbits(in, s + 5 * BLOCK_SIZE, BLOCK_SIZE); + final int mbits7 = LongUtil.maxbits(in, s + 6 * BLOCK_SIZE, BLOCK_SIZE); + final int mbits8 = LongUtil.maxbits(in, s + 7 * BLOCK_SIZE, BLOCK_SIZE); + // The first long expressed the maxbits for the 8 buckets + out[tmpoutpos++] = ((long) mbits1 << 56) | ((long) mbits2 << 48) | ((long) mbits3 << 40) | ((long) mbits4 << 32) | (mbits5 << 24) | (mbits6 << 16) | (mbits7 << 8) | (mbits8); + LongBitPacking.fastpackwithoutmask(in, s + 0 * BLOCK_SIZE, out, tmpoutpos, (int) mbits1); + tmpoutpos += mbits1; + LongBitPacking.fastpackwithoutmask(in, s + 1 * BLOCK_SIZE, out, tmpoutpos, (int) mbits2); + tmpoutpos += mbits2; + LongBitPacking.fastpackwithoutmask(in, s + 2 * BLOCK_SIZE, out, tmpoutpos, (int) mbits3); + tmpoutpos += mbits3; + LongBitPacking.fastpackwithoutmask(in, s + 3 * BLOCK_SIZE, out, tmpoutpos, (int) mbits4); + tmpoutpos += mbits4; + LongBitPacking.fastpackwithoutmask(in, s + 4 * BLOCK_SIZE, out, tmpoutpos, (int) mbits5); + tmpoutpos += mbits5; + LongBitPacking.fastpackwithoutmask(in, s + 5 * BLOCK_SIZE, out, tmpoutpos, (int) mbits6); + tmpoutpos += mbits6; + LongBitPacking.fastpackwithoutmask(in, s + 6 * BLOCK_SIZE, out, tmpoutpos, (int) mbits7); + tmpoutpos += mbits7; + LongBitPacking.fastpackwithoutmask(in, s + 7 * BLOCK_SIZE, out, tmpoutpos, (int) mbits8); + tmpoutpos += mbits8; + } + // Then we compress up to 7 blocks of 64 longs + for (; s < inpos.get() + inlength; s += BLOCK_SIZE ) { + final int mbits = LongUtil.maxbits(in, s, BLOCK_SIZE); + out[tmpoutpos++] = mbits; + LongBitPacking.fastpackwithoutmask(in, s, out, tmpoutpos, mbits); + tmpoutpos += mbits; + } + inpos.add(inlength); + outpos.set(tmpoutpos); + } + + @Override + public void uncompress(long[] in, IntWrapper inpos, int inlength, + long[] out, IntWrapper outpos) { + if (inlength == 0) + return; + final int outlength = (int) in[inpos.get()]; + inpos.increment(); + headlessUncompress(in,inpos, inlength,out,outpos,outlength); + } + + @Override + public void headlessUncompress(long[] in, IntWrapper inpos, int inlength, + long[] out, IntWrapper outpos, int num) { + final int outlength = Util.greatestMultiple(num, BLOCK_SIZE); + int tmpinpos = inpos.get(); + int s = outpos.get(); + for (; s + BLOCK_SIZE * 8 - 1 < outpos.get() + outlength; s += BLOCK_SIZE * 8) { + final int mbits1 = (int) ((in[tmpinpos] >>> 56)); + final int mbits2 = (int) ((in[tmpinpos] >>> 48) & 0xFF); + final int mbits3 = (int) ((in[tmpinpos] >>> 40) & 0xFF); + final int mbits4 = (int) ((in[tmpinpos] >>> 32) & 0xFF); + final int mbits5 = (int) ((in[tmpinpos] >>> 24) & 0xFF); + final int mbits6 = (int) ((in[tmpinpos] >>> 16) & 0xFF); + final int mbits7 = (int) ((in[tmpinpos] >>> 8) & 0xFF); + final int mbits8 = (int) ((in[tmpinpos]) & 0xFF); + ++tmpinpos; + LongBitPacking.fastunpack(in, tmpinpos, out, s + 0 * BLOCK_SIZE, mbits1); + tmpinpos += mbits1; + LongBitPacking.fastunpack(in, tmpinpos, out, s + 1 * BLOCK_SIZE, mbits2); + tmpinpos += mbits2; + LongBitPacking.fastunpack(in, tmpinpos, out, s + 2 * BLOCK_SIZE, mbits3); + tmpinpos += mbits3; + LongBitPacking.fastunpack(in, tmpinpos, out, s + 3 * BLOCK_SIZE, mbits4); + tmpinpos += mbits4; + LongBitPacking.fastunpack(in, tmpinpos, out, s + 4 * BLOCK_SIZE, mbits5); + tmpinpos += mbits5; + LongBitPacking.fastunpack(in, tmpinpos, out, s + 5 * BLOCK_SIZE, mbits6); + tmpinpos += mbits6; + LongBitPacking.fastunpack(in, tmpinpos, out, s + 6 * BLOCK_SIZE, mbits7); + tmpinpos += mbits7; + LongBitPacking.fastunpack(in, tmpinpos, out, s + 7 * BLOCK_SIZE, mbits8); + tmpinpos += mbits8; + } + for (; s < outpos.get() + outlength; s += BLOCK_SIZE ) { + final int mbits = (int) in[tmpinpos]; + ++tmpinpos; + LongBitPacking.fastunpack(in, tmpinpos, out, s, mbits); + tmpinpos += mbits; + } + outpos.add(outlength); + inpos.set(tmpinpos); + } + + @Override + public int maxHeadlessCompressedLength(IntWrapper compressedPositions, int inlength) { + int blockCount = inlength / BLOCK_SIZE; + int headersSizeInLongs = blockCount / Long.BYTES + (blockCount % Long.BYTES); + int blocksSizeInLongs = blockCount * MAX_BIT_WIDTH; + compressedPositions.add(blockCount * BLOCK_SIZE); + return headersSizeInLongs + blocksSizeInLongs; + } + + @Override + public String toString() { + return this.getClass().getSimpleName(); + } +} diff --git a/src/main/java/me/lemire/longcompression/LongBitPacking.java b/src/main/java/me/lemire/longcompression/LongBitPacking.java new file mode 100644 index 0000000..2d282ec --- /dev/null +++ b/src/main/java/me/lemire/longcompression/LongBitPacking.java @@ -0,0 +1,146 @@ +/** + * This code is released under the + * Apache License Version 2.0 http://www.apache.org/licenses/. + * + * (c) Daniel Lemire, http://lemire.me/en/ + */ + +package me.lemire.longcompression; + +import java.util.Arrays; + +/** + * Bitpacking routines + * + *

For details, please see

+ *

+ * Daniel Lemire and Leonid Boytsov, Decoding billions of integers per second + * through vectorization Software: Practice & Experience + * http://onlinelibrary.wiley.com/doi/10.1002/spe.2203/abstract + * http://arxiv.org/abs/1209.2137 + *

+ * + * @author Benoit Lacelle + * + */ +public final class LongBitPacking { + + /** + * Pack 64 longs + * + * @param in + * source array + * @param inpos + * position in source array + * @param out + * output array + * @param outpos + * position in output array + * @param bit + * number of bits to use per long + */ + public static void fastpackwithoutmask(final long[] in, final int inpos, + final long[] out, final int outpos, final int bit) { + if (bit == 0) { + fastpackwithoutmask0(in, inpos, out, outpos); + } else if (bit == 64) { + fastpackwithoutmask64(in, inpos, out, outpos); + } else if (bit > 0 && bit < 64) { + slowpackwithoutmask(in, inpos, out, outpos, bit); + } else { + throw new IllegalArgumentException("Unsupported bit width: " + bit); + } + } + + protected static void fastpackwithoutmask0(final long[] in, int inpos, + final long[] out, int outpos) { + // nothing + } + + protected static void fastpackwithoutmask64(final long[] in, int inpos, + final long[] out, int outpos) { + System.arraycopy(in, inpos, out, outpos, 64); + } + + protected static void slowpackwithoutmask(final long[] in, int inpos, + final long[] out, int outpos, final int bit) { + int bucket = 0; + int shift = 0; + + out[outpos + bucket] = 0L; + for (int i = 0 ; i < 64 ; i++) { + if (shift >= 64) { + bucket++; + out[bucket + outpos] = 0L; + shift -= 64; + + if (shift > 0) { + // There is some leftovers from previous input in the next bucket + out[outpos + bucket] |= in[inpos + i - 1] >> (bit - shift); + } + } + out[outpos + bucket] |= in[inpos + i] << shift; + + shift += bit; + } + } + + + /** + * Unpack the 64 longs + * + * @param in + * source array + * @param inpos + * starting point in the source array + * @param out + * output array + * @param outpos + * starting point in the output array + * @param bit + * how many bits to use per integer + */ + public static void fastunpack(final long[] in, final int inpos, + final long[] out, final int outpos, final int bit) { + if (bit == 0) { + fastunpack0(in, inpos, out, outpos); + } else if (bit == 64) { + fastunpack64(in, inpos, out, outpos); + } else if (bit > 0 && bit < 64) { + slowunpack(in, inpos, out, outpos, bit); + } else { + throw new IllegalArgumentException("Unsupported bit width: " + bit); + } + } + + + protected static void fastunpack0(final long[] in, int inpos, + final long[] out, int outpos) { + Arrays.fill(out, outpos, outpos + 64, 0); + } + + protected static void fastunpack64(final long[] in, int inpos, + final long[] out, int outpos) { + System.arraycopy(in, inpos, out, outpos, 64); + } + + protected static void slowunpack(final long[] in, int inpos, + final long[] out, int outpos, final int bit) { + int bucket = 0; + int shift = 0; + for (int i = 0 ; i < 64 ; i++) { + if (shift >= 64) { + bucket++; + shift -= 64; + + if (shift > 0) { + // There is some leftovers from previous input in the next bucket + out[outpos + i - 1] |= (in[inpos + bucket] << (bit - shift) & ((1L << bit) - 1)); + } + } + out[outpos + i] = ((in[inpos + bucket] >>> shift) & ((1L << bit) - 1)); + + shift += bit; + } + } +} diff --git a/src/main/java/me/lemire/longcompression/LongCODEC.java b/src/main/java/me/lemire/longcompression/LongCODEC.java new file mode 100644 index 0000000..0951ffd --- /dev/null +++ b/src/main/java/me/lemire/longcompression/LongCODEC.java @@ -0,0 +1,62 @@ +/** + * This code is released under the + * Apache License Version 2.0 http://www.apache.org/licenses/. + * + * (c) Daniel Lemire, http://lemire.me/en/ + */ + +package me.lemire.longcompression; + +import me.lemire.integercompression.IntWrapper; + +/** + * Interface describing a standard CODEC to compress longs. + * + * @author Benoit Lacelle + * + */ +public interface LongCODEC { + /** + * Compress data from an array to another array. + * + * Both inpos and outpos are modified to represent how much data was + * read and written to. If 12 longs (inlength = 12) are compressed to 3 + * longs, then inpos will be incremented by 12 while outpos will be + * incremented by 3. We use IntWrapper to pass the values by reference. + * + * @param in + * input array + * @param inpos + * where to start reading in the array + * @param inlength + * how many longs to compress + * @param out + * output array + * @param outpos + * where to write in the output array + */ + public void compress(long[] in, IntWrapper inpos, int inlength, + long[] out, IntWrapper outpos); + + /** + * Uncompress data from an array to another array. + * + * Both inpos and outpos parameters are modified to indicate new + * positions after read/write. + * + * @param in + * array containing data in compressed form + * @param inpos + * where to start reading in the array + * @param inlength + * length of the compressed data (ignored by some + * schemes) + * @param out + * array where to write the uncompressed output + * @param outpos + * where to start writing the uncompressed output in out + */ + public void uncompress(long[] in, IntWrapper inpos, int inlength, + long[] out, IntWrapper outpos); + +} diff --git a/src/main/java/me/lemire/longcompression/LongComposition.java b/src/main/java/me/lemire/longcompression/LongComposition.java new file mode 100644 index 0000000..5111a51 --- /dev/null +++ b/src/main/java/me/lemire/longcompression/LongComposition.java @@ -0,0 +1,71 @@ +/** + * This code is released under the + * Apache License Version 2.0 http://www.apache.org/licenses/. + * + * (c) Daniel Lemire, http://lemire.me/en/ + */ +package me.lemire.longcompression; + +import me.lemire.integercompression.IntWrapper; + +/** + * Helper class to compose schemes. + * + * @author Benoit Lacelle + */ +public class LongComposition implements LongCODEC { + LongCODEC F1, F2; + + /** + * Compose a scheme from a first one (f1) and a second one (f2). The + * first one is called first and then the second one tries to compress + * whatever remains from the first run. + * + * By convention, the first scheme should be such that if, during + * decoding, a 32-bit zero is first encountered, then there is no + * output. + * + * @param f1 + * first codec + * @param f2 + * second codec + */ + public LongComposition(LongCODEC f1, LongCODEC f2) { + F1 = f1; + F2 = f2; + } + + @Override + public void compress(long[] in, IntWrapper inpos, int inlength, + long[] out, IntWrapper outpos) { + if (inlength == 0) { + return; + } + int inposInit = inpos.get(); + int outposInit = outpos.get(); + F1.compress(in, inpos, inlength, out, outpos); + if (outpos.get() == outposInit) { + out[outposInit] = 0; + outpos.increment(); + } + inlength -= inpos.get() - inposInit; + F2.compress(in, inpos, inlength, out, outpos); + } + + @Override + public void uncompress(long[] in, IntWrapper inpos, int inlength, + long[] out, IntWrapper outpos) { + if (inlength == 0) + return; + final int init = inpos.get(); + F1.uncompress(in, inpos, inlength, out, outpos); + inlength -= inpos.get() - init; + F2.uncompress(in, inpos, inlength, out, outpos); + } + + @Override + public String toString() { + return F1.toString() + " + " + F2.toString(); + } + +} diff --git a/src/main/java/me/lemire/longcompression/LongCompressor.java b/src/main/java/me/lemire/longcompression/LongCompressor.java new file mode 100644 index 0000000..246647f --- /dev/null +++ b/src/main/java/me/lemire/longcompression/LongCompressor.java @@ -0,0 +1,68 @@ +package me.lemire.longcompression; + +import java.util.Arrays; + +import me.lemire.integercompression.IntWrapper; + +/** + * This is a convenience class that wraps a codec to provide + * a "friendly" API. + * + * @author Benoit Lacelle + */ +public class LongCompressor { + + SkippableLongCODEC codec; + + /** + * Constructor wrapping a codec. + * + * @param c the underlying codec + */ + public LongCompressor(SkippableLongCODEC c) { + codec = c; + } + + /** + * Constructor with default codec. + */ + public LongCompressor() { + codec = new SkippableLongComposition(new LongBinaryPacking(), + new LongVariableByte()); + } + + /** + * Compress an array and returns the compressed result as a new array. + * + * @param input array to be compressed + * @return compressed array + */ + public long[] compress(long[] input) { + int maxCompressedLength = codec.maxHeadlessCompressedLength(new IntWrapper(0), input.length); + long[] compressed = new long[maxCompressedLength + 1]; // +1 to store the length of the input + // Store at index=0 the length of the input, hence enabling .headlessCompress + compressed[0] = input.length; + IntWrapper outpos = new IntWrapper(1); + codec.headlessCompress(input, new IntWrapper(0), input.length, compressed, outpos); + compressed = Arrays.copyOf(compressed,outpos.intValue()); + return compressed; + } + + /** + * Uncompress an array and returns the uncompressed result as a new array. + * + * @param compressed compressed array + * @return uncompressed array + */ + public long[] uncompress(long[] compressed) { + // Read at index=0 the length of the input, hence enabling .headlessUncompress + long[] decompressed = new long[(int) compressed[0]]; + IntWrapper inpos = new IntWrapper(1); + codec.headlessUncompress(compressed, inpos, + compressed.length - inpos.intValue(), + decompressed, new IntWrapper(0), + decompressed.length); + return decompressed; + } + +} diff --git a/src/main/java/me/lemire/longcompression/LongJustCopy.java b/src/main/java/me/lemire/longcompression/LongJustCopy.java new file mode 100644 index 0000000..95abc1e --- /dev/null +++ b/src/main/java/me/lemire/longcompression/LongJustCopy.java @@ -0,0 +1,58 @@ +/** + * This code is released under the + * Apache License Version 2.0 http://www.apache.org/licenses/. + * + * (c) Daniel Lemire, http://lemire.me/en/ + */ + +package me.lemire.longcompression; + +import me.lemire.integercompression.IntWrapper; + +/** + * @author Benoit lacelle + * + */ +public final class LongJustCopy implements LongCODEC, SkippableLongCODEC { + + @Override + public void headlessCompress(long[] in, IntWrapper inpos, int inlength, + long[] out, IntWrapper outpos) { + System.arraycopy(in, inpos.get(), out, outpos.get(), inlength); + inpos.add(inlength); + outpos.add(inlength); + } + + @Override + public void uncompress(long[] in, IntWrapper inpos, int inlength, + long[] out, IntWrapper outpos) { + headlessUncompress(in,inpos,inlength,out,outpos,inlength); + } + + @Override + public String toString() { + return this.getClass().getSimpleName(); + } + + @Override + public void headlessUncompress(long[] in, IntWrapper inpos, int inlength, + long[] out, IntWrapper outpos, int num) { + System.arraycopy(in, inpos.get(), out, outpos.get(), num); + inpos.add(num); + outpos.add(num); + + } + + @Override + public int maxHeadlessCompressedLength(IntWrapper compressedPositions, int inlength) { + compressedPositions.add(inlength); + return inlength; + } + + @Override + public void compress(long[] in, IntWrapper inpos, int inlength, + long[] out, IntWrapper outpos) { + headlessCompress(in,inpos,inlength,out,outpos); + } + +} diff --git a/src/main/java/me/lemire/longcompression/LongUtil.java b/src/main/java/me/lemire/longcompression/LongUtil.java new file mode 100644 index 0000000..7bdce83 --- /dev/null +++ b/src/main/java/me/lemire/longcompression/LongUtil.java @@ -0,0 +1,52 @@ +/** + * This code is released under the + * Apache License Version 2.0 http://www.apache.org/licenses/. + * + * (c) Daniel Lemire, http://lemire.me/en/ + */ + +package me.lemire.longcompression; + +/** + * These are unofficial helpers related to long compression + * + * @author Benoit Lacelle + * + */ +@Deprecated +public class LongUtil { + + /** + * Compute the maximum of the integer logarithms (ceil(log(x+1)) of a range + * of value + * + * @param i + * source array + * @param pos + * starting position + * @param length + * number of integers to consider + * @return integer logarithm + */ + public static int maxbits(long[] i, int pos, int length) { + long mask = 0; + for (int k = pos; k < pos + length; ++k) + mask |= i[k]; + return bits(mask); + } + + /** + * Compute the integer logarithms (ceil(log(x+1)) of a value + * + * @param i + * source value + * @return integer logarithm + */ + public static int bits(long i) { + return 64 - Long.numberOfLeadingZeros(i); + } + + protected static String longToBinaryWithLeading(long l) { + return String.format("%64s", Long.toBinaryString(l)).replace(' ', '0'); + } +} diff --git a/src/main/java/me/lemire/longcompression/LongVariableByte.java b/src/main/java/me/lemire/longcompression/LongVariableByte.java new file mode 100644 index 0000000..63c194b --- /dev/null +++ b/src/main/java/me/lemire/longcompression/LongVariableByte.java @@ -0,0 +1,348 @@ +/** + * This code is released under the + * Apache License Version 2.0 http://www.apache.org/licenses/. + * + * (c) Daniel Lemire, http://lemire.me/en/ + */ +package me.lemire.longcompression; + +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.nio.LongBuffer; + +import me.lemire.integercompression.IntWrapper; + +/** + * Implementation of variable-byte. For best performance, use it using the + * ByteLongCODEC interface. + * + * Note that this does not use differential coding: if you are working on sorted + * lists, you must compute the deltas separately. + * + * @author Benoit Lacelle + */ +public class LongVariableByte implements LongCODEC, ByteLongCODEC, SkippableLongCODEC { + private static final int MAX_BYTES_PER_INT = 10; + + private static byte extract7bits(int i, long val) { + return (byte) ((val >>> (7 * i)) & ((1 << 7) - 1)); + } + + private static byte extract7bitsmaskless(int i, long val) { + return (byte) ((val >>> (7 * i))); + } + @Override + public void compress(long[] in, IntWrapper inpos, int inlength, long[] out, + IntWrapper outpos) { + headlessCompress(in, inpos, inlength, out, outpos); + } + + @Override + public void headlessCompress(long[] in, IntWrapper inpos, int inlength, long[] out, + IntWrapper outpos) { + if (inlength == 0) + return; + // Worst case: we write 10 bytes per long, hence 2 longs for a long, hence 16 bytes per long + ByteBuffer buf = makeBuffer(inlength * 16); + buf.order(ByteOrder.LITTLE_ENDIAN); + for (int k = inpos.get(); k < inpos.get() + inlength; ++k) { + final long val = in[k]; + if (val >= 0 && val < (1 << 7)) { + buf.put((byte) (val | (1 << 7))); + } else if (val >= 0 && val < (1 << 14)) { + buf.put((byte) extract7bits(0, val)); + buf.put((byte) (extract7bitsmaskless(1, (val)) | (1 << 7))); + } else if (val >= 0 && val < (1 << 21)) { + buf.put((byte) extract7bits(0, val)); + buf.put((byte) extract7bits(1, val)); + buf.put((byte) (extract7bitsmaskless(2, (val)) | (1 << 7))); + } else if (val >= 0 && val < (1 << 28)) { + buf.put((byte) extract7bits(0, val)); + buf.put((byte) extract7bits(1, val)); + buf.put((byte) extract7bits(2, val)); + buf.put((byte) (extract7bitsmaskless(3, (val)) | (1 << 7))); + } else if (val >= 0 && val < (1L << 35)) { + buf.put((byte) extract7bits(0, val)); + buf.put((byte) extract7bits(1, val)); + buf.put((byte) extract7bits(2, val)); + buf.put((byte) extract7bits(3, val)); + buf.put((byte) (extract7bitsmaskless(4, (val)) | (1 << 7))); + } else if (val >= 0 && val < (1L << 42)) { + buf.put((byte) extract7bits(0, val)); + buf.put((byte) extract7bits(1, val)); + buf.put((byte) extract7bits(2, val)); + buf.put((byte) extract7bits(3, val)); + buf.put((byte) extract7bits(4, val)); + buf.put((byte) (extract7bitsmaskless(5, (val)) | (1 << 7))); + } else if (val >= 0 && val < (1L << 49)) { + buf.put((byte) extract7bits(0, val)); + buf.put((byte) extract7bits(1, val)); + buf.put((byte) extract7bits(2, val)); + buf.put((byte) extract7bits(3, val)); + buf.put((byte) extract7bits(4, val)); + buf.put((byte) extract7bits(5, val)); + buf.put((byte) (extract7bitsmaskless(6, (val)) | (1 << 7))); + } else if (val >= 0 && val < (1L << 56)) { + buf.put((byte) extract7bits(0, val)); + buf.put((byte) extract7bits(1, val)); + buf.put((byte) extract7bits(2, val)); + buf.put((byte) extract7bits(3, val)); + buf.put((byte) extract7bits(4, val)); + buf.put((byte) extract7bits(5, val)); + buf.put((byte) extract7bits(6, val)); + buf.put((byte) (extract7bitsmaskless(7, (val)) | (1 << 7))); + } else if (val >= 0) { + buf.put((byte) extract7bits(0, val)); + buf.put((byte) extract7bits(1, val)); + buf.put((byte) extract7bits(2, val)); + buf.put((byte) extract7bits(3, val)); + buf.put((byte) extract7bits(4, val)); + buf.put((byte) extract7bits(5, val)); + buf.put((byte) extract7bits(6, val)); + buf.put((byte) extract7bits(7, val)); + buf.put((byte) (extract7bitsmaskless(8, (val)) | (1 << 7))); + } else { + buf.put((byte) extract7bits(0, val)); + buf.put((byte) extract7bits(1, val)); + buf.put((byte) extract7bits(2, val)); + buf.put((byte) extract7bits(3, val)); + buf.put((byte) extract7bits(4, val)); + buf.put((byte) extract7bits(5, val)); + buf.put((byte) extract7bits(6, val)); + buf.put((byte) extract7bits(7, val)); + buf.put((byte) extract7bits(8, val)); + buf.put((byte) (extract7bitsmaskless(9, (val)) | (1 << 7))); + } + } + while (buf.position() % 8 != 0) + buf.put((byte) 0); + final int length = buf.position(); + buf.flip(); + LongBuffer ibuf = buf.asLongBuffer(); + ibuf.get(out, outpos.get(), length / 8); + outpos.add(length / 8); + inpos.add(inlength); + } + + @Override + public void compress(long[] in, IntWrapper inpos, int inlength, byte[] out, + IntWrapper outpos) { + if (inlength == 0) + return; + int outpostmp = outpos.get(); + for (int k = inpos.get(); k < inpos.get() + inlength; ++k) { + final long val = in[k]; + if (val >= 0 && val < (1 << 7)) { + out[outpostmp++] = (byte) (val | (1 << 7)); + } else if (val >= 0 && val < (1 << 14)) { + out[outpostmp++] = (byte) extract7bits(0, val); + out[outpostmp++] = (byte) (extract7bitsmaskless(1, (val)) | (1 << 7)); + } else if (val >= 0 && val < (1 << 21)) { + out[outpostmp++] = (byte) extract7bits(0, val); + out[outpostmp++] = (byte) extract7bits(1, val); + out[outpostmp++] = (byte) (extract7bitsmaskless(2, (val)) | (1 << 7)); + } else if (val >= 0 && val < (1 << 28)) { + out[outpostmp++] = (byte) extract7bits(0, val); + out[outpostmp++] = (byte) extract7bits(1, val); + out[outpostmp++] = (byte) extract7bits(2, val); + out[outpostmp++] = (byte) (extract7bitsmaskless(3, (val)) | (1 << 7)); + } else if (val >= 0 && val < (1L << 35)) { + out[outpostmp++] = (byte) extract7bits(0, val); + out[outpostmp++] = (byte) extract7bits(1, val); + out[outpostmp++] = (byte) extract7bits(2, val); + out[outpostmp++] = (byte) extract7bits(3, val); + out[outpostmp++] = (byte) (extract7bitsmaskless(4, (val)) | (1 << 7)); + } else if (val >= 0 && val < (1L << 42)) { + out[outpostmp++] = (byte) extract7bits(0, val); + out[outpostmp++] = (byte) extract7bits(1, val); + out[outpostmp++] = (byte) extract7bits(2, val); + out[outpostmp++] = (byte) extract7bits(3, val); + out[outpostmp++] = (byte) extract7bits(4, val); + out[outpostmp++] = (byte) (extract7bitsmaskless(5, (val)) | (1 << 7)); + } else if (val >= 0 && val < (1L << 49)) { + out[outpostmp++] = (byte) extract7bits(0, val); + out[outpostmp++] = (byte) extract7bits(1, val); + out[outpostmp++] = (byte) extract7bits(2, val); + out[outpostmp++] = (byte) extract7bits(3, val); + out[outpostmp++] = (byte) extract7bits(4, val); + out[outpostmp++] = (byte) extract7bits(5, val); + out[outpostmp++] = (byte) (extract7bitsmaskless(6, (val)) | (1 << 7)); + } else if (val >= 0 && val < (1L << 56)) { + out[outpostmp++] = (byte) extract7bits(0, val); + out[outpostmp++] = (byte) extract7bits(1, val); + out[outpostmp++] = (byte) extract7bits(2, val); + out[outpostmp++] = (byte) extract7bits(3, val); + out[outpostmp++] = (byte) extract7bits(4, val); + out[outpostmp++] = (byte) extract7bits(5, val); + out[outpostmp++] = (byte) extract7bits(6, val); + out[outpostmp++] = (byte) (extract7bitsmaskless(7, (val)) | (1 << 7)); + } else if (val >= 0) { + out[outpostmp++] = (byte) extract7bits(0, val); + out[outpostmp++] = (byte) extract7bits(1, val); + out[outpostmp++] = (byte) extract7bits(2, val); + out[outpostmp++] = (byte) extract7bits(3, val); + out[outpostmp++] = (byte) extract7bits(4, val); + out[outpostmp++] = (byte) extract7bits(5, val); + out[outpostmp++] = (byte) extract7bits(6, val); + out[outpostmp++] = (byte) extract7bits(7, val); + out[outpostmp++] = (byte) (extract7bitsmaskless(8, (val)) | (1 << 7)); + } else { + out[outpostmp++] = (byte) extract7bits(0, val); + out[outpostmp++] = (byte) extract7bits(1, val); + out[outpostmp++] = (byte) extract7bits(2, val); + out[outpostmp++] = (byte) extract7bits(3, val); + out[outpostmp++] = (byte) extract7bits(4, val); + out[outpostmp++] = (byte) extract7bits(5, val); + out[outpostmp++] = (byte) extract7bits(6, val); + out[outpostmp++] = (byte) extract7bits(7, val); + out[outpostmp++] = (byte) extract7bits(8, val); + out[outpostmp++] = (byte) (extract7bitsmaskless(9, (val)) | (1 << 7)); + } + } + outpos.set(outpostmp); + inpos.add(inlength); + } + + @Override + public void uncompress(long[] in, IntWrapper inpos, int inlength, long[] out, + IntWrapper outpos) { + int s = 0; + long val = 0; + int p = inpos.get(); + int finalp = inpos.get() + inlength; + int tmpoutpos = outpos.get(); + for (long v = 0, shift = 0; p < finalp;) { + val = in[p]; + long c = (byte) (val >>> s); + // Shift to next byte + s += 8; + // Shift to next long if s==64 + p += s>>6; + // Cycle from 63 to 0 + s = s & 63; + v += ((c & 127) << shift); + if ((c & 128) == 128) { + out[tmpoutpos++] = v; + v = 0; + shift = 0; + } else + shift += 7; + assert shift < 64; + } + outpos.set(tmpoutpos); + inpos.add(inlength); + } + + @Override + public void uncompress(byte[] in, IntWrapper inpos, int inlength, + long[] out, IntWrapper outpos) { + int p = inpos.get(); + int finalp = inpos.get() + inlength; + int tmpoutpos = outpos.get(); + for (long v = 0; p < finalp; out[tmpoutpos++] = v) { + v = in[p] & 0x7F; + if (in[p] < 0) { + p += 1; + continue; + } + v = ((in[p + 1] & 0x7F) << 7) | v; + if (in[p + 1] < 0) { + p += 2; + continue; + } + v = ((in[p + 2] & 0x7F) << 14) | v; + if (in[p + 2] < 0 ) { + p += 3; + continue; + } + v = ((in[p + 3] & 0x7F) << 21) | v; + if (in[p + 3] < 0) { + p += 4; + continue; + } + v = (((long) in[p + 4] & 0x7F) << 28) | v; + if (in[p + 4] < 0) { + p += 5; + continue; + } + v = (((long) in[p + 5] & 0x7F) << 35) | v; + if (in[p + 5] < 0) { + p += 6; + continue; + } + v = (((long) in[p + 6] & 0x7F) << 42) | v; + if (in[p + 6] < 0) { + p += 7; + continue; + } + v = (((long) in[p + 7] & 0x7F) << 49) | v; + if (in[p + 7] < 0) { + p += 8; + continue; + } + v = (((long) in[p + 8] & 0x7F) << 56) | v; + if (in[p + 8] < 0) { + p += 9; + continue; + } + v = (((long) in[p + 9] & 0x7F) << 63) | v; + p += 10; + } + outpos.set(tmpoutpos); + inpos.add(p); + } + + @Override + public String toString() { + return this.getClass().getSimpleName(); + } + + @Override + public void headlessUncompress(long[] in, IntWrapper inpos, int inlength, long[] out, + IntWrapper outpos, int num) { + int s = 0; + long val = 0; + int p = inpos.get(); + int tmpoutpos = outpos.get(); + int finaloutpos = num + tmpoutpos; + for (long v = 0, shift = 0; tmpoutpos < finaloutpos;) { + val = in[p]; + long c = val >>> s; + // Shift to next byte + s += 8; + // Shift to next long if s == 64 + p += s>>6; + // Cycle from 63 to 0 + s = s & 63; + v += ((c & 127) << shift); + if ((c & 128) == 128) { + out[tmpoutpos++] = v; + v = 0; + shift = 0; + } else + shift += 7; + assert shift < 64; + } + outpos.set(tmpoutpos); + inpos.set(p + (s!=0 ? 1 : 0)); + } + + @Override + public int maxHeadlessCompressedLength(IntWrapper compressedPositions, int inlength) { + int maxLengthInBytes = inlength * MAX_BYTES_PER_INT; + int maxLengthInLongs = (maxLengthInBytes + Long.BYTES - 1) / Long.BYTES; + compressedPositions.add(inlength); + return maxLengthInLongs; + } + + /** + * Creates a new buffer of the requested size. + * + * In case you need a different way to allocate buffers, you can override this method + * with a custom behavior. The default implementation allocates a new Java direct + * {@link ByteBuffer} on each invocation. + */ + protected ByteBuffer makeBuffer(int sizeInBytes) { + return ByteBuffer.allocateDirect(sizeInBytes); + } +} diff --git a/src/main/java/me/lemire/longcompression/RoaringIntPacking.java b/src/main/java/me/lemire/longcompression/RoaringIntPacking.java new file mode 100644 index 0000000..d6b6baa --- /dev/null +++ b/src/main/java/me/lemire/longcompression/RoaringIntPacking.java @@ -0,0 +1,46 @@ +/* + * (c) the authors Licensed under the Apache License, Version 2.0. + */ +package me.lemire.longcompression; + +/** + * Used to hold the logic packing 2 integers in a long, and separating a long in two integers. It is + * useful in {@link Roaring64NavigableMap} as the implementation split the input long in two + * integers, one used as key of a NavigableMap while the other is added in a Bitmap + * + * @author Benoit Lacelle + * + */ +// Duplicated from RoaringBitmap +class RoaringIntPacking { + + /** + * + * @param id any long, positive or negative + * @return an int holding the 32 highest order bits of information of the input long + */ + public static int high(long id) { + return (int) (id >> 32); + } + + /** + * + * @param id any long, positive or negative + * @return an int holding the 32 lowest order bits of information of the input long + */ + public static int low(long id) { + return (int) id; + } + + /** + * + * @param high an integer representing the highest order bits of the output long + * @param low an integer representing the lowest order bits of the output long + * @return a long packing together the integers as computed by + * {@link RoaringIntPacking#high(long)} and {@link RoaringIntPacking#low(long)} + */ + // https://stackoverflow.com/questions/12772939/java-storing-two-ints-in-a-long + public static long pack(int high, int low) { + return (((long) high) << 32) | (low & 0xffffffffL); + } +} diff --git a/src/main/java/me/lemire/longcompression/SkippableLongCODEC.java b/src/main/java/me/lemire/longcompression/SkippableLongCODEC.java new file mode 100644 index 0000000..33fd562 --- /dev/null +++ b/src/main/java/me/lemire/longcompression/SkippableLongCODEC.java @@ -0,0 +1,87 @@ +/** + * This is code is released under the + * Apache License Version 2.0 http://www.apache.org/licenses/. + * + * (c) Daniel Lemire, http://lemire.me/en/ + */ + +package me.lemire.longcompression; + +import me.lemire.integercompression.IntWrapper; + +/** + * Interface describing a standard CODEC to compress longs. This is a + * variation on the LongCODEC interface meant to be used for random access + * (i.e., given a large array, you can segment it and decode just the subarray you need). + * + * The main difference is that we must specify the number of longs we wish to + * decode. This information should be stored elsewhere. + * + * This interface was designed by the Terrier team for their search engine. + * + * @author Benoit Lacelle + * + */ +public interface SkippableLongCODEC { + /** + * Compress data from an array to another array. + * + * Both inpos and outpos are modified to represent how much data was read + * and written to. If 12 longs (inlength = 12) are compressed to 3 longs, then + * inpos will be incremented by 12 while outpos will be incremented by 3. We + * use IntWrapper to pass the values by reference. + * + * @param in + * input array + * @param inpos + * where to start reading in the array + * @param inlength + * how many longs to compress + * @param out + * output array + * @param outpos + * where to write in the output array + */ + public void headlessCompress(long[] in, IntWrapper inpos, int inlength, long[] out, + IntWrapper outpos); + + /** + * Uncompress data from an array to another array. + * + * Both inpos and outpos parameters are modified to indicate new positions + * after read/write. + * + * @param in + * array containing data in compressed form + * @param inpos + * where to start reading in the array + * @param inlength + * length of the compressed data (ignored by some schemes) + * @param out + * array where to write the uncompressed output + * @param outpos + * where to start writing the uncompressed output in out + * @param num + * number of longs we want to decode, the actual number of longs decoded can be less + */ + public void headlessUncompress(long[] in, IntWrapper inpos, int inlength, long[] out, + IntWrapper outpos, int num); + + /** + * Compute the maximum number of longs that might be required to store + * the compressed form of a given input array segment, without headers. + *

+ * This is useful to pre-allocate the output buffer before calling + * {@link #headlessCompress(long[], IntWrapper, int, long[], IntWrapper)}. + *

+ * + * @param compressedPositions + * since not all schemes compress every input integer, this parameter + * returns how many input integers will actually be compressed. + * This is useful when composing multiple schemes. + * @param inlength + * number of longs to be compressed + * @return the maximum number of longs needed in the output array + */ + int maxHeadlessCompressedLength(IntWrapper compressedPositions, int inlength); +} diff --git a/src/main/java/me/lemire/longcompression/SkippableLongComposition.java b/src/main/java/me/lemire/longcompression/SkippableLongComposition.java new file mode 100644 index 0000000..eb03b72 --- /dev/null +++ b/src/main/java/me/lemire/longcompression/SkippableLongComposition.java @@ -0,0 +1,82 @@ +/** + * This is code is released under the + * Apache License Version 2.0 http://www.apache.org/licenses/. + * + * (c) Daniel Lemire, http://lemire.me/en/ + */ +package me.lemire.longcompression; + +import me.lemire.integercompression.IntWrapper; + +/** + * Helper class to compose schemes. + * + * @author Benoit Lacelle + */ +public class SkippableLongComposition implements SkippableLongCODEC { + SkippableLongCODEC F1, F2; + + /** + * Compose a scheme from a first one (f1) and a second one (f2). The first + * one is called first and then the second one tries to compress whatever + * remains from the first run. + * + * By convention, the first scheme should be such that if, during decoding, + * a 32-bit zero is first encountered, then there is no output. + * + * @param f1 + * first codec + * @param f2 + * second codec + */ + public SkippableLongComposition(SkippableLongCODEC f1, + SkippableLongCODEC f2) { + F1 = f1; + F2 = f2; + } + + @Override + public void headlessCompress(long[] in, IntWrapper inpos, int inlength, long[] out, + IntWrapper outpos) { + int init = inpos.get(); + int outposInit = outpos.get(); + F1.headlessCompress(in, inpos, inlength, out, outpos); + if (outpos.get() == outposInit) { + out[outposInit] = 0; + outpos.increment(); + } + inlength -= inpos.get() - init; + F2.headlessCompress(in, inpos, inlength, out, outpos); + } + + @Override + public void headlessUncompress(long[] in, IntWrapper inpos, int inlength, long[] out, + IntWrapper outpos, int num) { + int init = inpos.get(); + int outposInit = outpos.get(); + + F1.headlessUncompress(in, inpos, inlength, out, outpos, num); + if (inpos.get() == init) { + inpos.increment(); + } + inlength -= inpos.get() - init; + num -= outpos.get() - outposInit; + F2.headlessUncompress(in, inpos, inlength, out, outpos, num); + } + + @Override + public int maxHeadlessCompressedLength(IntWrapper compressedPositions, int inlength) { + int init = compressedPositions.get(); + int maxLength = F1.maxHeadlessCompressedLength(compressedPositions, inlength); + maxLength += 1; // Add +1 for the potential F2 header. Question: is this header actually needed in the headless version? + inlength -= compressedPositions.get() - init; + maxLength += F2.maxHeadlessCompressedLength(compressedPositions, inlength); + return maxLength; + } + + @Override + public String toString() { + return F1.toString() + "+" + F2.toString(); + } + +} diff --git a/src/main/java/me/lemire/longcompression/differential/LongDelta.java b/src/main/java/me/lemire/longcompression/differential/LongDelta.java new file mode 100644 index 0000000..8399f94 --- /dev/null +++ b/src/main/java/me/lemire/longcompression/differential/LongDelta.java @@ -0,0 +1,150 @@ +/** + * This code is released under the + * Apache License Version 2.0 http://www.apache.org/licenses/. + * + * (c) Daniel Lemire, http://lemire.me/en/ + */ + +package me.lemire.longcompression.differential; + +/** + * Generic class to compute differential coding. + * + * @author Benoit lacelle + * + */ +public final class LongDelta { + + /** + * Apply differential coding (in-place). + * + * @param data + * data to be modified + */ + public static void delta(long[] data) { + for (int i = data.length - 1; i > 0; --i) { + data[i] -= data[i - 1]; + } + } + + /** + * Apply differential coding (in-place) given an initial value. + * + * @param data + * data to be modified + * @param start + * starting index + * @param length + * number of integers to process + * @param init + * initial value + * @return next initial vale + */ + public static long delta(long[] data, int start, int length, int init) { + final long nextinit = data[start + length - 1]; + for (int i = length - 1; i > 0; --i) { + data[start + i] -= data[start + i - 1]; + } + data[start] -= init; + return nextinit; + } + + /** + * Compute differential coding given an initial value. Output is written + * to a provided array: must have length "length" or better. + * + * @param data + * data to be modified + * @param start + * starting index + * @param length + * number of integers to process + * @param init + * initial value + * @param out + * output array + * @return next initial vale + */ + public static long delta(long[] data, int start, int length, int init, + long[] out) { + for (int i = length - 1; i > 0; --i) { + out[i] = data[start + i] - data[start + i - 1]; + } + out[0] = data[start] - init; + return data[start + length - 1]; + } + + /** + * Undo differential coding (in-place). Effectively computes a prefix + * sum. + * + * @param data + * to be modified. + */ + public static void inverseDelta(long[] data) { + for (int i = 1; i < data.length; ++i) { + data[i] += data[i - 1]; + } + } + + /** + * Undo differential coding (in-place). Effectively computes a prefix + * sum. Like inverseDelta, only faster. + * + * @param data + * to be modified + */ + public static void fastinverseDelta(long[] data) { + int sz0 = data.length / 4 * 4; + int i = 1; + if (sz0 >= 4) { + long a = data[0]; + for (; i < sz0 - 4; i += 4) { + a = data[i] += a; + a = data[i + 1] += a; + a = data[i + 2] += a; + a = data[i + 3] += a; + } + } + + for (; i < data.length; ++i) { + data[i] += data[i - 1]; + } + } + + /** + * Undo differential coding (in-place). Effectively computes a prefix + * sum. Like inverseDelta, only faster. Uses an initial value. + * + * @param data + * to be modified + * @param start + * starting index + * @param length + * number of integers to process + * @param init + * initial value + * @return next initial value + */ + public static long fastinverseDelta(long[] data, int start, int length, + int init) { + data[start] += init; + int sz0 = length / 4 * 4; + int i = 1; + if (sz0 >= 4) { + long a = data[start]; + for (; i < sz0 - 4; i += 4) { + a = data[start + i] += a; + a = data[start + i + 1] += a; + a = data[start + i + 2] += a; + a = data[start + i + 3] += a; + } + } + + for (; i != length; ++i) { + data[start + i] += data[start + i - 1]; + } + return data[start + length - 1]; + } + +} diff --git a/src/main/java/module-info.java b/src/main/java/module-info.java new file mode 100644 index 0000000..f134601 --- /dev/null +++ b/src/main/java/module-info.java @@ -0,0 +1,12 @@ +// Copyright (C) 2022 Intel Corporation + +// SPDX-License-Identifier: Apache-2.0 +module me.lemire.integercompression { + // This is currently only for advanced users: + // requires jdk.incubator.vector; + exports me.lemire.integercompression; + exports me.lemire.longcompression; + exports me.lemire.longcompression.differential; + exports me.lemire.integercompression.differential; + // exports me.lemire.integercompression.vector; +} diff --git a/src/test/java/me/lemire/integercompression/AdhocTest.java b/src/test/java/me/lemire/integercompression/AdhocTest.java new file mode 100644 index 0000000..ee911b3 --- /dev/null +++ b/src/test/java/me/lemire/integercompression/AdhocTest.java @@ -0,0 +1,156 @@ +/** + * This code is released under the + * Apache License Version 2.0 http://www.apache.org/licenses/. + * + * (c) Daniel Lemire, http://lemire.me/en/ + */ + +package me.lemire.integercompression; + +import org.junit.Assert; +import org.junit.Test; + +import me.lemire.integercompression.differential.*; + +import static me.lemire.integercompression.TestUtils.*; + +import java.util.Arrays; + +/** + * Collection of adhoc tests. + */ +@SuppressWarnings({ "static-method" }) +public class AdhocTest { + + @Test + public void testIssue59() { + FastPFOR128 fastpfor = new FastPFOR128(); + + int N = 9984; + int[] data = new int[N]; + for (var i = 0; i < N; i += 150) { + data[i] = i; + } + + int[] compressedoutput1 = new int[N + 1024]; + + IntWrapper inputoffset1 = new IntWrapper(0); + IntWrapper outputoffset1 = new IntWrapper(0); + + fastpfor.compress(data, inputoffset1, N, compressedoutput1, outputoffset1); + int compressedsize1 = outputoffset1.get(); + + int[] recovered1 = new int[N]; + inputoffset1 = new IntWrapper(0); + outputoffset1 = new IntWrapper(0); + fastpfor.uncompress(compressedoutput1, outputoffset1, compressedsize1, recovered1, inputoffset1); + Assert.assertArrayEquals(data, recovered1); + + int[] compressedoutput2 = new int[N + 1024]; + + IntWrapper inputoffset2 = new IntWrapper(0); + IntWrapper outputoffset2 = new IntWrapper(0); + + fastpfor.compress(data, inputoffset2, N, compressedoutput2, outputoffset2); + int compressedsize2 = outputoffset2.get(); + + int[] recovered2 = new int[N]; + inputoffset2 = new IntWrapper(0); + outputoffset2 = new IntWrapper(0); + fastpfor.uncompress(compressedoutput2, outputoffset2, compressedsize2, recovered2, inputoffset2); + Assert.assertArrayEquals(data, recovered2); + } + + @Test + public void testIssue29() { + for(int x = 0; x < 64; x++) { + int[] a = {2, 3, 4, 5}; + int[] b = new int[90]; + int[] c = new int[a.length]; + IntegerCODEC codec = new Composition(new BinaryPacking(), new VariableByte()); + + IntWrapper aOffset = new IntWrapper(0); + IntWrapper bOffset = new IntWrapper(x); + codec.compress(a, aOffset, a.length, b, bOffset); + int len = bOffset.get() - x; + bOffset.set(x); + IntWrapper cOffset = new IntWrapper(0); + codec.uncompress(b, bOffset, len, c, cOffset); + Assert.assertArrayEquals(a,c); + } + } + + /** + * + */ + @Test + public void testIssue29b() { + for(int x = 0; x < 64; x++) { + SkippableIntegerCODEC codec = new SkippableComposition(new BinaryPacking(), new VariableByte()); + int[] a = {2, 3, 4, 5}; + int[] b = new int[x + codec.maxHeadlessCompressedLength(new IntWrapper(0), a.length)]; + int[] c = new int[a.length]; + IntWrapper aOffset = new IntWrapper(0); + IntWrapper bOffset = new IntWrapper(x); + codec.headlessCompress(a, aOffset, a.length, b, bOffset); + int len = bOffset.get() - x; + bOffset.set(x); + IntWrapper cOffset = new IntWrapper(0); + codec.headlessUncompress(b, bOffset, len, c, cOffset, a.length); + Assert.assertArrayEquals(a,c); + } + } + + + /** + * + */ + @Test + public void testIssue41() { + for (int x = 0; x < 64; x++) { + SkippableIntegratedIntegerCODEC codec = new SkippableIntegratedComposition(new IntegratedBinaryPacking(), + new IntegratedVariableByte()); + int[] a = { 2, 3, 4, 5 }; + int[] b = new int[x + codec.maxHeadlessCompressedLength(new IntWrapper(0), a.length)]; + int[] c = new int[a.length]; + IntWrapper aOffset = new IntWrapper(0); + IntWrapper bOffset = new IntWrapper(x); + IntWrapper initValue = new IntWrapper(0); + + codec.headlessCompress(a, aOffset, a.length, b, bOffset, initValue); + int len = bOffset.get() - x; + bOffset.set(x); + IntWrapper cOffset = new IntWrapper(0); + initValue = new IntWrapper(0); + codec.headlessUncompress(b, bOffset, len, c, cOffset, a.length, initValue); + Assert.assertArrayEquals(a, c); + } + } + + @Test + public void biggerCompressedArray0() { + // No problem: for comparison. + IntegerCODEC c = new Composition(new FastPFOR128(), new VariableByte()); + assertSymmetry(c, 0, 16384); + c = new Composition(new FastPFOR(), new VariableByte()); + assertSymmetry(c, 0, 16384); + } + + @Test + public void biggerCompressedArray1() { + // Compressed array is bigger than original, because of VariableByte. + IntegerCODEC c = new VariableByte(); + assertSymmetry(c, -1); + } + + @Test + public void biggerCompressedArray2() { + // Compressed array is bigger than original, because of Composition. + IntegerCODEC c = new Composition(new FastPFOR128(), new VariableByte()); + assertSymmetry(c, 65535, 65535); + c = new Composition(new FastPFOR(), new VariableByte()); + assertSymmetry(c, 65535, 65535); + } + + +} diff --git a/src/test/java/me/lemire/integercompression/BasicTest.java b/src/test/java/me/lemire/integercompression/BasicTest.java index afb47b3..b29ae0d 100644 --- a/src/test/java/me/lemire/integercompression/BasicTest.java +++ b/src/test/java/me/lemire/integercompression/BasicTest.java @@ -1,333 +1,683 @@ +/** + * This code is released under the + * Apache License Version 2.0 http://www.apache.org/licenses/. + * + * (c) Daniel Lemire, http://lemire.me/en/ + */ + package me.lemire.integercompression; import java.util.Arrays; import java.util.Random; -import junit.framework.Assert; - +import me.lemire.integercompression.differential.Delta; +import me.lemire.integercompression.differential.IntegratedBinaryPacking; +import me.lemire.integercompression.differential.IntegratedComposition; +import me.lemire.integercompression.differential.IntegratedIntegerCODEC; +import me.lemire.integercompression.differential.IntegratedVariableByte; +import me.lemire.integercompression.differential.XorBinaryPacking; import me.lemire.integercompression.synth.ClusteredDataGenerator; import org.junit.Test; +import static org.junit.Assert.*; + /** * Just some basic sanity tests. * * @author Daniel Lemire - * */ +@SuppressWarnings({ "static-method" }) public class BasicTest { - - /** - * Verify bitpacking - */ - @SuppressWarnings("static-method") - @Test - public void verify() { - System.out.println("Checking the code..."); + final IntegerCODEC[] codecs = { + new IntegratedComposition(new IntegratedBinaryPacking(), + new IntegratedVariableByte()), + new JustCopy(), + new VariableByte(), + new GroupSimple9(), + new IntegratedVariableByte(), + new Composition(new BinaryPacking(), new VariableByte()), + new Composition(new NewPFD(), new VariableByte()), + new Composition(new NewPFDS16(), new VariableByte()), + new Composition(new OptPFDS9(), new VariableByte()), + new Composition(new OptPFDS16(), new VariableByte()), + new Composition(new FastPFOR128(), new VariableByte()), + new Composition(new FastPFOR(), new VariableByte()), + new Simple9(), + new Simple16(), + new GroupSimple9(), + new Composition(new XorBinaryPacking(), new VariableByte()), + new Composition(new DeltaZigzagBinaryPacking(), + new DeltaZigzagVariableByte()) }; + + /** + * This tests with a compressed array with various offset + */ + @Test + public void saulTest() { + for (IntegerCODEC C : codecs) { + for (int x = 0; x < 50; ++x) { + int[] a = { 2, 3, 4, 5 }; + int[] b = new int[90]; + int[] c = new int[a.length]; + + IntWrapper aOffset = new IntWrapper(0); + IntWrapper bOffset = new IntWrapper(x); + C.compress(a, aOffset, a.length, b, bOffset); + int len = bOffset.get() - x; + + bOffset.set(x); + IntWrapper cOffset = new IntWrapper(0); + C.uncompress(b, bOffset, len, c, cOffset); + if(!Arrays.equals(a, c)) { + System.out.println("Problem with "+C); + } + assertArrayEquals(a, c); + + } + } + } + /** + * + */ + @Test + public void varyingLengthTest() { + int N = 4096; + int[] data = new int[N]; + for (int k = 0; k < N; ++k) + data[k] = k; + for (IntegerCODEC c : codecs) { + System.out.println("[BasicTest.varyingLengthTest] codec = " + c); + for (int L = 1; L <= 128; L++) { + int[] comp = TestUtils.compress(c, Arrays.copyOf(data, L)); + int[] answer = TestUtils.uncompress(c, comp, L); + for (int k = 0; k < L; ++k) + if (answer[k] != data[k]) + throw new RuntimeException("bug"); + } + for (int L = 128; L <= N; L *= 2) { + int[] comp = TestUtils.compress(c, Arrays.copyOf(data, L)); + int[] answer = TestUtils.uncompress(c, comp, L); + for (int k = 0; k < L; ++k) + if (answer[k] != data[k]) { + System.out.println(Arrays.toString(Arrays.copyOf( + answer, L))); + System.out.println(Arrays.toString(Arrays.copyOf(data, + L))); + throw new RuntimeException("bug"); + } + } + + } + } + + /** + * + */ + @Test + public void varyingLengthTest2() { + int N = 128; + int[] data = new int[N]; + data[127] = -1; + for (IntegerCODEC c : codecs) { + System.out.println("[BasicTest.varyingLengthTest2] codec = " + c); + try { + // CODEC Simple9 is limited to "small" integers. + if (c.getClass().equals( + Class.forName("me.lemire.integercompression.Simple9"))) + continue; + } catch (ClassNotFoundException e) { + e.printStackTrace(); + } + try { + // CODEC Simple16 is limited to "small" integers. + if (c.getClass().equals( + Class.forName("me.lemire.integercompression.Simple16"))) + continue; + } catch (ClassNotFoundException e) { + e.printStackTrace(); + } + try { + // CODEC GroupSimple9 is limited to "small" integers. + if (c.getClass().equals( + Class.forName("me.lemire.integercompression.GroupSimple9"))) + continue; + } catch (ClassNotFoundException e) { + e.printStackTrace(); + } + + for (int L = 1; L <= 128; L++) { + int[] comp = TestUtils.compress(c, Arrays.copyOf(data, L)); + int[] answer = TestUtils.uncompress(c, comp, L); + for (int k = 0; k < L; ++k) + if (answer[k] != data[k]) + throw new RuntimeException("bug"); + } + for (int L = 128; L <= N; L *= 2) { + int[] comp = TestUtils.compress(c, Arrays.copyOf(data, L)); + int[] answer = TestUtils.uncompress(c, comp, L); + for (int k = 0; k < L; ++k) + if (answer[k] != data[k]) + throw new RuntimeException("bug"); + } + + } + } + + /** + * + */ + @Test + public void checkDeltaZigzagVB() { + DeltaZigzagVariableByte codec = new DeltaZigzagVariableByte(); + DeltaZigzagVariableByte codeco = new DeltaZigzagVariableByte(); + + testZeroInZeroOut(codec); + test(codec, codeco, 5, 10); + test(codec, codeco, 5, 14); + test(codec, codeco, 2, 18); + } + + /** + * + */ + @Test + public void checkDeltaZigzagPacking() { + DeltaZigzagBinaryPacking codec = new DeltaZigzagBinaryPacking(); + testZeroInZeroOut(codec); + testSpurious(codec); + + IntegerCODEC compo = new Composition(new DeltaZigzagBinaryPacking(), + new VariableByte()); + IntegerCODEC compo2 = new Composition(new DeltaZigzagBinaryPacking(), + new VariableByte()); + + testZeroInZeroOut(compo); + testUnsorted(compo); + test(compo, compo2, 5, 10); + test(compo, compo2, 5, 14); + test(compo, compo2, 2, 18); + } + + /** + * + */ + @Test + public void checkXorBinaryPacking() { + testZeroInZeroOut(new XorBinaryPacking()); + testSpurious(new XorBinaryPacking()); + } + + /** + * + */ + @Test + public void checkXorBinaryPacking1() { + IntegerCODEC c = new IntegratedComposition(new XorBinaryPacking(), + new IntegratedVariableByte()); + testZeroInZeroOut(c); + } + + /** + * + */ + @Test + public void checkXorBinaryPacking2() { + IntegerCODEC c = new IntegratedComposition(new XorBinaryPacking(), + new IntegratedVariableByte()); + testUnsorted(c); + } + + /** + * + */ + @Test + public void checkXorBinaryPacking3() { + IntegerCODEC c = new IntegratedComposition(new XorBinaryPacking(), + new IntegratedVariableByte()); + IntegerCODEC co = new IntegratedComposition(new XorBinaryPacking(), + new IntegratedVariableByte()); + test(c, co, 5, 10); + test(c, co, 5, 14); + test(c, co, 2, 18); + } + + /** + * Verify bitpacking. + */ + @Test + public void verifyBitPacking() { final int N = 32; - final int times = 1000; + final int TIMES = 1000; Random r = new Random(); int[] data = new int[N]; int[] compressed = new int[N]; int[] uncompressed = new int[N]; for (int bit = 0; bit < 31; ++bit) { - for (int t = 0; t < times; ++t) { + for (int t = 0; t < TIMES; ++t) { for (int k = 0; k < N; ++k) { data[k] = r.nextInt(1 << bit); } BitPacking.fastpack(data, 0, compressed, 0, bit); BitPacking.fastunpack(compressed, 0, uncompressed, 0, bit); - if (!Arrays.equals(uncompressed, data)) { - throw new RuntimeException("bug " + bit); - } + assertArrayEquals(uncompressed, data); } } - System.out.println("Code appears to be correct."); } - /** - * Verify bitpacking without mask - */ - @SuppressWarnings("static-method") - @Test - public void verifyWithoutMask() { - System.out.println("Checking the code..."); + /** + * Verify bitpacking without mask. + */ + @Test + public void verifyWithoutMask() { final int N = 32; - final int times = 1000; + final int TIMES = 1000; Random r = new Random(); int[] data = new int[N]; int[] compressed = new int[N]; int[] uncompressed = new int[N]; for (int bit = 0; bit < 31; ++bit) { - for (int t = 0; t < times; ++t) { + for (int t = 0; t < TIMES; ++t) { for (int k = 0; k < N; ++k) { data[k] = r.nextInt(1 << bit); } BitPacking.fastpackwithoutmask(data, 0, compressed, 0, bit); BitPacking.fastunpack(compressed, 0, uncompressed, 0, bit); - if (!Arrays.equals(uncompressed, data)) { - throw new RuntimeException("bug " + bit); - } + assertArrayEquals(uncompressed, data); } } - System.out.println("Code appears to be correct."); } - /** - * Verify bitpacking with exception - */ - @SuppressWarnings("static-method") - @Test - public void verifyWithExceptions() { - System.out.println("Checking the code..."); + /** + * @param array + * some array + * @param mask + * provided mask + */ + public static void maskArray(int[] array, int mask) { + for (int i = 0, end = array.length; i < end; ++i) { + array[i] &= mask; + } + } + + /** + * Verify bitpacking with exception. + */ + @Test + public void verifyWithExceptions() { final int N = 32; - final int times = 1000; + final int TIMES = 1000; Random r = new Random(); int[] data = new int[N]; int[] compressed = new int[N]; int[] uncompressed = new int[N]; for (int bit = 0; bit < 31; ++bit) { - for (int t = 0; t < times; ++t) { + for (int t = 0; t < TIMES; ++t) { for (int k = 0; k < N; ++k) { data[k] = r.nextInt(); } BitPacking.fastpack(data, 0, compressed, 0, bit); BitPacking.fastunpack(compressed, 0, uncompressed, 0, bit); - for (int k = 0; k < N; ++k) { - if ((data[k] & ((1 << bit) - 1)) != uncompressed[k]) { - for (int k2 = 0; k2 < N; ++k2) { - System.out.println((data[k] & ((1 << bit) - 1)) + " " + uncompressed[k]); - } - System.out.println(compressed[0]); - throw new RuntimeException("bug " + bit); - } - } + + // Check assertions. + maskArray(data, ((1 << bit) - 1)); + assertArrayEquals(data, uncompressed); } } - System.out.println("Code with overflow appears to be correct."); } - /** - * check that the codecs can be inverted. - */ - @SuppressWarnings("static-method") - @Test - public void basictest() { - test(5, 10); - test(5, 14); - test(2, 18); - } - /** - * check that there is no spurious output. - */ - @SuppressWarnings("static-method") - @Test - public void spuriousouttest() { - testSpurious(new IntegratedBinaryPacking()); - testSpurious(new BinaryPacking()); - testSpurious(new NewPFD()); - testSpurious(new NewPFDS9()); - testSpurious(new NewPFDS16()); - testSpurious(new OptPFD()); - testSpurious(new OptPFDS9()); - testSpurious(new OptPFDS16()); - testSpurious(new FastPFOR()); - - } - /** - * check that an empty array generates an empty array - * after compression. - */ - @SuppressWarnings("static-method") - @Test - public void zeroinzerouttest() { - testZeroInZeroOut(new IntegratedBinaryPacking()); - testZeroInZeroOut(new IntegratedVariableByte()); - testZeroInZeroOut(new BinaryPacking()); - testZeroInZeroOut(new NewPFD()); - testZeroInZeroOut(new NewPFDS9()); - testZeroInZeroOut(new NewPFDS16()); - testZeroInZeroOut(new OptPFD()); - testZeroInZeroOut(new OptPFDS9()); - testZeroInZeroOut(new OptPFDS16()); - testZeroInZeroOut(new FastPFOR()); - testZeroInZeroOut(new VariableByte()); - testZeroInZeroOut(new Composition(new IntegratedBinaryPacking(), new VariableByte())); - testZeroInZeroOut(new Composition(new BinaryPacking(), new VariableByte())); - testZeroInZeroOut(new Composition(new NewPFD(), new VariableByte())); - testZeroInZeroOut(new Composition(new NewPFDS9(), new VariableByte())); - testZeroInZeroOut(new Composition(new NewPFDS16(), new VariableByte())); - testZeroInZeroOut(new Composition(new OptPFD(), new VariableByte())); - testZeroInZeroOut(new Composition(new OptPFDS9(), new VariableByte())); - testZeroInZeroOut(new Composition(new OptPFDS16(), new VariableByte())); - testZeroInZeroOut(new Composition(new FastPFOR(), new VariableByte())); - - testZeroInZeroOut(new IntegratedComposition(new IntegratedBinaryPacking(), - new IntegratedVariableByte())); + /** + * check that the codecs can be inverted. + */ + @Test + public void basictest() { + test(5, 10); + test(5, 14); + test(2, 18); + } + + /** + * check that there is no spurious output. + */ + @Test + public void spuriousouttest() { + testSpurious(new IntegratedBinaryPacking()); + testSpurious(new BinaryPacking()); + testSpurious(new NewPFD()); + testSpurious(new NewPFDS9()); + testSpurious(new NewPFDS16()); + testSpurious(new OptPFD()); + testSpurious(new OptPFDS9()); + testSpurious(new OptPFDS16()); + testSpurious(new FastPFOR128()); + testSpurious(new FastPFOR()); + } + + /** + * check that an empty array generates an empty array after compression. + */ + @Test + public void zeroinzerouttest() { + testZeroInZeroOut(new IntegratedBinaryPacking()); + testZeroInZeroOut(new IntegratedVariableByte()); + testZeroInZeroOut(new BinaryPacking()); + testZeroInZeroOut(new NewPFD()); + testZeroInZeroOut(new NewPFDS9()); + testZeroInZeroOut(new NewPFDS16()); + testZeroInZeroOut(new OptPFD()); + testZeroInZeroOut(new OptPFDS9()); + testZeroInZeroOut(new OptPFDS16()); + testZeroInZeroOut(new FastPFOR128()); + testZeroInZeroOut(new FastPFOR()); + testZeroInZeroOut(new VariableByte()); + testZeroInZeroOut(new Composition(new IntegratedBinaryPacking(), + new VariableByte())); + testZeroInZeroOut(new Composition(new BinaryPacking(), + new VariableByte())); + testZeroInZeroOut(new Composition(new NewPFD(), new VariableByte())); + testZeroInZeroOut(new Composition(new NewPFDS9(), new VariableByte())); + testZeroInZeroOut(new Composition(new NewPFDS16(), new VariableByte())); + testZeroInZeroOut(new Composition(new OptPFD(), new VariableByte())); + testZeroInZeroOut(new Composition(new OptPFDS9(), new VariableByte())); + testZeroInZeroOut(new Composition(new OptPFDS16(), new VariableByte())); + testZeroInZeroOut(new Composition(new FastPFOR128(), new VariableByte())); + testZeroInZeroOut(new Composition(new FastPFOR(), new VariableByte())); + + testZeroInZeroOut(new IntegratedComposition( + new IntegratedBinaryPacking(), new IntegratedVariableByte())); + } + private static void testSpurious(IntegerCODEC c) { + int[] x = new int[1024]; + int[] y = new int[0]; + IntWrapper i0 = new IntWrapper(0); + IntWrapper i1 = new IntWrapper(0); + for (int inlength = 0; inlength < 32; ++inlength) { + c.compress(x, i0, inlength, y, i1); + assertEquals(0, i1.intValue()); } + } + + private static void testZeroInZeroOut(IntegerCODEC c) { + int[] x = new int[0]; + int[] y = new int[0]; + IntWrapper i0 = new IntWrapper(0); + IntWrapper i1 = new IntWrapper(0); + c.compress(x, i0, 0, y, i1); + assertEquals(0, i1.intValue()); + + int[] out = new int[0]; + IntWrapper outpos = new IntWrapper(0); + c.uncompress(y, i1, 0, out, outpos); + assertEquals(0, outpos.intValue()); + } - - private static void testSpurious(IntegerCODEC c) { - int[] x = new int[1024]; - int[] y = new int[0]; - IntWrapper i0 = new IntWrapper(0); - IntWrapper i1 = new IntWrapper(0); - for(int inlength = 0; inlength <128;++inlength) { - c.compress(x, i0, inlength,y,i1); - Assert.assertEquals(i1.intValue(), 0); - } - } - - private static void testZeroInZeroOut(IntegerCODEC c) { - int[] x = new int[0]; - int[] y = new int[0]; - IntWrapper i0 = new IntWrapper(0); - IntWrapper i1 = new IntWrapper(0); - c.compress(x, i0, 0,y,i1); - Assert.assertEquals(i1.intValue(), 0); - int[] out = new int[0]; - IntWrapper outpos = new IntWrapper(0); - c.uncompress(y, i1, 0, out, outpos); - Assert.assertEquals(outpos.intValue(), 0); + private static void test(IntegerCODEC c, IntegerCODEC co, int N, int nbr) { + ClusteredDataGenerator cdg = new ClusteredDataGenerator(); + for (int sparsity = 1; sparsity < 31 - nbr; sparsity += 4) { + int[][] data = new int[N][]; + int max = (1 << (nbr + sparsity)); + for (int k = 0; k < N; ++k) { + data[k] = cdg.generateClustered((1 << nbr), max); + } + testCodec(c, co, data, max); } + } - private static void test(int N, int nbr) { - ClusteredDataGenerator cdg = new ClusteredDataGenerator(); - for (int sparsity = 1; sparsity < 31 - nbr; sparsity += 4) { - System.out.println("#testing sparsity "+sparsity); - int[][] data = new int[N][]; - int Max = (1 << (nbr + sparsity)); - for (int k = 0; k < N; ++k) { - data[k] = cdg.generateClustered((1 << nbr), Max); - } - - testCodec(new IntegratedComposition(new IntegratedBinaryPacking(), - new IntegratedVariableByte()), data, Max); - testCodec(new JustCopy(), data, Max); - testCodec(new VariableByte(), data, Max); - testCodec(new IntegratedVariableByte(), data, Max); - testCodec(new Composition(new BinaryPacking(), new VariableByte()), - data, Max); - testCodec(new Composition(new NewPFD(), new VariableByte()), data, - Max); - testCodec(new Composition(new NewPFDS9(), new VariableByte()), - data, Max); - testCodec(new Composition(new NewPFDS16(), new VariableByte()), - data, Max); - testCodec(new Composition(new OptPFD(), new VariableByte()), data, - Max); - testCodec(new Composition(new OptPFDS9(), new VariableByte()), - data, Max); - testCodec(new Composition(new OptPFDS16(), new VariableByte()), - data, Max); - testCodec(new Composition(new FastPFOR(), new VariableByte()), - data, Max); - testCodec(new Simple9(), data, Max); - } - } - - private static void testCodec(IntegerCODEC c, int[][] data, int Max) { - int N = data.length; - int maxlength = 0; - for (int k = 0; k < N; ++k) { - if (data[k].length > maxlength) - maxlength = data[k].length; - } - int[] buffer = new int[maxlength + 1024]; - int[] dataout = new int[4 * maxlength + 1024]; - /* 4x + 1024 to account for the possibility of some negative compression */ - IntWrapper inpos = new IntWrapper(); - IntWrapper outpos = new IntWrapper(); - for (int k = 0; k < N; ++k) { - int[] backupdata = Arrays.copyOf(data[k], data[k].length); - // - inpos.set(1); - outpos.set(0); - if (!(c instanceof IntegratedIntegerCODEC)) { - Delta.delta(backupdata); - } - c.compress(backupdata, inpos, backupdata.length - inpos.get(), - dataout, outpos); - final int thiscompsize = outpos.get() + 1; - inpos.set(0); - outpos.set(1); - buffer[0] = backupdata[0]; - c.uncompress(dataout, inpos, thiscompsize - 1, buffer, outpos); - if (!(c instanceof IntegratedIntegerCODEC)) - Delta.fastinverseDelta(buffer); - // - if (outpos.get() != data[k].length) - throw new RuntimeException("we have a bug (diff length) " + c - + " expected " + data[k].length + " got " - + outpos.get()); - for (int m = 0; m < outpos.get(); ++m) - if (buffer[m] != data[k][m]) { - throw new RuntimeException( - "we have a bug (actual difference), expected " - + data[k][m] + " found " + buffer[m] - + " at " + m); - } - - } - } - - /** - * Test - */ - @SuppressWarnings("static-method") - @Test - public void testUnsortedExample() { - - testUnsorted(new VariableByte()); - testUnsorted(new IntegratedVariableByte()); - testUnsorted(new Composition(new BinaryPacking(), new VariableByte())); - testUnsorted(new Composition(new NewPFD(), new VariableByte())); - testUnsorted(new Composition(new NewPFDS9(), new VariableByte())); - testUnsorted(new Composition(new NewPFDS16(), new VariableByte())); - testUnsorted(new Composition(new OptPFD(), new VariableByte())); - testUnsorted(new Composition(new OptPFDS9(), new VariableByte())); - testUnsorted(new Composition(new OptPFDS16(), new VariableByte())); - testUnsorted(new Composition(new FastPFOR(), new VariableByte())); - - testUnsorted(new IntegratedComposition(new IntegratedBinaryPacking(), - new IntegratedVariableByte())); - testUnsorted(new Composition(new IntegratedBinaryPacking(), new VariableByte())); + private static void test(int N, int nbr) { + ClusteredDataGenerator cdg = new ClusteredDataGenerator(); + System.out.println("[BasicTest.test] N = " + N + " " + nbr); + for (int sparsity = 1; sparsity < 31 - nbr; sparsity += 4) { + int[][] data = new int[N][]; + int max = (1 << (nbr + sparsity)); + for (int k = 0; k < N; ++k) { + data[k] = cdg.generateClustered((1 << nbr), max); + } + testCodec(new IntegratedComposition(new IntegratedBinaryPacking(), + new IntegratedVariableByte()), + new IntegratedComposition(new IntegratedBinaryPacking(), + new IntegratedVariableByte()), data, max); + testCodec(new JustCopy(), new JustCopy(), data, max); + testCodec(new VariableByte(), new VariableByte(), data, max); + testCodec(new IntegratedVariableByte(), + new IntegratedVariableByte(), data, max); + testCodec(new Composition(new BinaryPacking(), new VariableByte()), + new Composition(new BinaryPacking(), new VariableByte()), + data, max); + testCodec(new Composition(new NewPFD(), new VariableByte()), + new Composition(new NewPFD(), new VariableByte()), data, + max); + testCodec(new Composition(new NewPFDS9(), new VariableByte()), + new Composition(new NewPFDS9(), new VariableByte()), data, + max); + testCodec(new Composition(new NewPFDS16(), new VariableByte()), + new Composition(new NewPFDS16(), new VariableByte()), data, + max); + testCodec(new Composition(new OptPFD(), new VariableByte()), + new Composition(new OptPFD(), new VariableByte()), data, + max); + testCodec(new Composition(new OptPFDS9(), new VariableByte()), + new Composition(new OptPFDS9(), new VariableByte()), data, + max); + testCodec(new Composition(new OptPFDS16(), new VariableByte()), + new Composition(new OptPFDS16(), new VariableByte()), data, + max); + testCodec(new Composition(new FastPFOR128(), new VariableByte()), + new Composition(new FastPFOR128(), new VariableByte()), + data, max); + testCodec(new Composition(new FastPFOR(), new VariableByte()), + new Composition(new FastPFOR(), new VariableByte()), + data, max); + testCodec(new Simple9(), new Simple9(), data, max); } - - public void testUnsorted(IntegerCODEC codec) { - int[] lengths = {133,1333333}; - for (int N : lengths ) { - int[] data = new int[N]; - // initialize the data (most will be small - for (int k = 0; k < N; k += 1) - data[k] = 3; - // throw some larger values - for (int k = 0; k < N; k += 5) - data[k] = 100; - for (int k = 0; k < N; k += 533) - data[k] = 10000; - data[5] = -311; - int[] compressed = new int[(int) Math.ceil(N * 1.01) + 1024];// could - // need - // more - // compressing - IntWrapper inputoffset = new IntWrapper(0); - IntWrapper outputoffset = new IntWrapper(0); - codec.compress(data, inputoffset, data.length, - compressed, outputoffset); - // we can repack the data: (optional) - compressed = Arrays.copyOf(compressed, - outputoffset.intValue()); - - int[] recovered = new int[N]; - IntWrapper recoffset = new IntWrapper(0); - codec.uncompress(compressed, new IntWrapper(0), - compressed.length, recovered, recoffset); - Assert.assertTrue(Arrays.equals(data, recovered)); - } + } + + private static void testCodec(IntegerCODEC c, IntegerCODEC co, + int[][] data, int max) { + int N = data.length; + int maxlength = 0; + for (int k = 0; k < N; ++k) { + if (data[k].length > maxlength) + maxlength = data[k].length; + } + int[] buffer = new int[maxlength + 1024]; + int[] dataout = new int[4 * maxlength + 1024]; + // 4x + 1024 to account for the possibility of some negative + // compression. + IntWrapper inpos = new IntWrapper(); + IntWrapper outpos = new IntWrapper(); + for (int k = 0; k < N; ++k) { + int[] backupdata = Arrays.copyOf(data[k], data[k].length); + + inpos.set(1); + outpos.set(0); + if (!(c instanceof IntegratedIntegerCODEC)) { + Delta.delta(backupdata); + } + c.compress(backupdata, inpos, backupdata.length - inpos.get(), + dataout, outpos); + final int thiscompsize = outpos.get() + 1; + inpos.set(0); + outpos.set(1); + buffer[0] = backupdata[0]; + co.uncompress(dataout, inpos, thiscompsize - 1, buffer, outpos); + if (!(c instanceof IntegratedIntegerCODEC)) + Delta.fastinverseDelta(buffer); + // Check assertions. + assertEquals("length is not match", outpos.get(), data[k].length); + int[] bufferCutout = Arrays.copyOf(buffer, outpos.get()); + assertArrayEquals("failed to reconstruct original data", data[k], + bufferCutout); } + } + + /** + * Test for unsorted array. + */ + @Test + public void testUnsortedExample() { + testUnsorted(new VariableByte()); + testUnsorted(new IntegratedVariableByte()); + testUnsorted(new Composition(new BinaryPacking(), new VariableByte())); + testUnsorted(new Composition(new NewPFD(), new VariableByte())); + testUnsorted(new Composition(new NewPFDS9(), new VariableByte())); + testUnsorted(new Composition(new NewPFDS16(), new VariableByte())); + testUnsorted(new Composition(new OptPFD(), new VariableByte())); + testUnsorted(new Composition(new OptPFDS9(), new VariableByte())); + testUnsorted(new Composition(new OptPFDS16(), new VariableByte())); + testUnsorted(new Composition(new FastPFOR128(), new VariableByte())); + testUnsorted(new Composition(new FastPFOR(), new VariableByte())); + + testUnsorted(new IntegratedComposition(new IntegratedBinaryPacking(), + new IntegratedVariableByte())); + testUnsorted(new Composition(new IntegratedBinaryPacking(), + new VariableByte())); + + testUnsorted2(new VariableByte()); + testUnsorted2(new IntegratedVariableByte()); + testUnsorted2(new Composition(new BinaryPacking(), new VariableByte())); + testUnsorted2(new Composition(new NewPFD(), new VariableByte())); + testUnsorted2(new Composition(new NewPFDS9(), new VariableByte())); + testUnsorted2(new Composition(new NewPFDS16(), new VariableByte())); + testUnsorted2(new Composition(new OptPFD(), new VariableByte())); + testUnsorted2(new Composition(new OptPFDS9(), new VariableByte())); + testUnsorted2(new Composition(new OptPFDS16(), new VariableByte())); + testUnsorted2(new Composition(new FastPFOR128(), new VariableByte())); + testUnsorted2(new Composition(new FastPFOR(), new VariableByte())); + + testUnsorted3(new IntegratedComposition(new IntegratedBinaryPacking(), + new IntegratedVariableByte())); + testUnsorted3(new Composition(new IntegratedBinaryPacking(), + new VariableByte())); + testUnsorted3(new VariableByte()); + testUnsorted3(new IntegratedVariableByte()); + testUnsorted3(new Composition(new BinaryPacking(), new VariableByte())); + testUnsorted3(new Composition(new NewPFD(), new VariableByte())); + testUnsorted3(new Composition(new NewPFDS9(), new VariableByte())); + testUnsorted3(new Composition(new NewPFDS16(), new VariableByte())); + testUnsorted3(new Composition(new OptPFD(), new VariableByte())); + testUnsorted3(new Composition(new OptPFDS9(), new VariableByte())); + testUnsorted3(new Composition(new OptPFDS16(), new VariableByte())); + testUnsorted3(new Composition(new FastPFOR128(), new VariableByte())); + testUnsorted3(new Composition(new FastPFOR(), new VariableByte())); + + testUnsorted2(new IntegratedComposition(new IntegratedBinaryPacking(), + new IntegratedVariableByte())); + testUnsorted2(new Composition(new IntegratedBinaryPacking(), + new VariableByte())); + + } + + /** + * @param codec + * provided codec + */ + public void testUnsorted(IntegerCODEC codec) { + int[] lengths = { 133, 1026, 1333333 }; + for (int N : lengths) { + int[] data = new int[N]; + // initialize the data (most will be small) + for (int k = 0; k < N; k += 1) + data[k] = 3; + // throw some larger values + for (int k = 0; k < N; k += 5) + data[k] = 100; + for (int k = 0; k < N; k += 533) + data[k] = 10000; + data[5] = -311; + // could need more compressing + int[] compressed = new int[(int) Math.ceil(N * 1.01) + 1024]; + IntWrapper inputoffset = new IntWrapper(0); + IntWrapper outputoffset = new IntWrapper(0); + codec.compress(data, inputoffset, data.length, compressed, + outputoffset); + // we can repack the data: (optional) + compressed = Arrays.copyOf(compressed, outputoffset.intValue()); + + int[] recovered = new int[N]; + IntWrapper recoffset = new IntWrapper(0); + codec.uncompress(compressed, new IntWrapper(0), compressed.length, + recovered, recoffset); + assertArrayEquals(data, recovered); + } + } + + private void testUnsorted2(IntegerCODEC codec) { + int[] data = new int[128]; + data[5] = -1; + int[] compressed = new int[1024]; + IntWrapper inputoffset = new IntWrapper(0); + IntWrapper outputoffset = new IntWrapper(0); + codec.compress(data, inputoffset, data.length, compressed, outputoffset); + // we can repack the data: (optional) + compressed = Arrays.copyOf(compressed, outputoffset.intValue()); + + int[] recovered = new int[128]; + IntWrapper recoffset = new IntWrapper(0); + codec.uncompress(compressed, new IntWrapper(0), compressed.length, + recovered, recoffset); + assertArrayEquals(data, recovered); + } + + private void testUnsorted3(IntegerCODEC codec) { + int[] data = new int[128]; + data[127] = -1; + int[] compressed = new int[1024]; + IntWrapper inputoffset = new IntWrapper(0); + IntWrapper outputoffset = new IntWrapper(0); + codec.compress(data, inputoffset, data.length, compressed, outputoffset); + // we can repack the data: (optional) + compressed = Arrays.copyOf(compressed, outputoffset.intValue()); + + int[] recovered = new int[128]; + IntWrapper recoffset = new IntWrapper(0); + codec.uncompress(compressed, new IntWrapper(0), compressed.length, + recovered, recoffset); + assertArrayEquals(data, recovered); + } + + /** + * + */ + @Test + public void fastPforTest() { + // proposed by Stefan Ackermann (https://github.com/Stivo) + FastPFOR codec1 = new FastPFOR(); + FastPFOR codec2 = new FastPFOR(); + int N = FastPFOR.BLOCK_SIZE; + int[] data = new int[N]; + for (int i = 0; i < N; i++) + data[i] = 0; + data[126] = -1; + int[] comp = TestUtils.compress(codec1, Arrays.copyOf(data, N)); + int[] answer = TestUtils.uncompress(codec2, comp, N); + for (int k = 0; k < N; ++k) + if (answer[k] != data[k]) + throw new RuntimeException("bug " + k + " " + answer[k] + + " != " + data[k]); + } + + /** + * + */ + @Test + public void fastPfor128Test() { + // proposed by Stefan Ackermann (https://github.com/Stivo) + FastPFOR128 codec1 = new FastPFOR128(); + FastPFOR128 codec2 = new FastPFOR128(); + int N = FastPFOR128.BLOCK_SIZE; + int[] data = new int[N]; + for (int i = 0; i < N; i++) + data[i] = 0; + data[126] = -1; + int[] comp = TestUtils.compress(codec1, Arrays.copyOf(data, N)); + int[] answer = TestUtils.uncompress(codec2, comp, N); + for (int k = 0; k < N; ++k) + if (answer[k] != data[k]) + throw new RuntimeException("bug " + k + " " + answer[k] + + " != " + data[k]); + } } diff --git a/src/test/java/me/lemire/integercompression/BoundaryTest.java b/src/test/java/me/lemire/integercompression/BoundaryTest.java index f8539d8..128b431 100644 --- a/src/test/java/me/lemire/integercompression/BoundaryTest.java +++ b/src/test/java/me/lemire/integercompression/BoundaryTest.java @@ -1,12 +1,28 @@ +/** + * This code is released under the + * Apache License Version 2.0 http://www.apache.org/licenses/. + * + * (c) Daniel Lemire, http://lemire.me/en/ + */ + package me.lemire.integercompression; import java.util.Arrays; +import me.lemire.integercompression.differential.IntegratedBinaryPacking; +import me.lemire.integercompression.differential.IntegratedComposition; +import me.lemire.integercompression.differential.IntegratedVariableByte; + import org.junit.Test; + import static org.junit.Assert.*; -public class BoundaryTest -{ +/** + * @author lemire + * + */ +@SuppressWarnings({ "static-method" }) +public class BoundaryTest { private static void compressAndUncompress(int length, IntegerCODEC c) { // Initialize array. int[] source = new int[length]; @@ -25,14 +41,25 @@ private static void compressAndUncompress(int length, IntegerCODEC c) { int[] uncompressed = new int[length]; IntWrapper u_inpos = new IntWrapper(0); IntWrapper u_outpos = new IntWrapper(0); - c.uncompress(compressed, u_inpos, c_outpos.get(), - uncompressed, u_outpos); + c.uncompress(compressed, u_inpos, c_outpos.get(), uncompressed, + u_outpos); // Compare between uncompressed and original arrays. int[] target = Arrays.copyOf(uncompressed, u_outpos.get()); + if (!Arrays.equals(source, target)) { + System.out.println("problem with length = " + length + " and " + c); + System.out.println(Arrays.toString(source)); + System.out.println(Arrays.toString(target)); + } assertArrayEquals(source, target); } + private static void around32(IntegerCODEC c) { + compressAndUncompress(31, c); + compressAndUncompress(32, c); + compressAndUncompress(33, c); + } + private static void around128(IntegerCODEC c) { compressAndUncompress(127, c); compressAndUncompress(128, c); @@ -46,23 +73,26 @@ private static void around256(IntegerCODEC c) { } private static void testBoundary(IntegerCODEC c) { + around32(c); around128(c); around256(c); } + + /** + */ @Test - public void testIntegratedComposition() throws Exception { + public void testIntegratedComposition() { IntegratedComposition c = new IntegratedComposition( - new IntegratedBinaryPacking(), - new IntegratedVariableByte()); + new IntegratedBinaryPacking(), new IntegratedVariableByte()); testBoundary(c); } + /** + */ @Test - public void testComposition() throws Exception { - Composition c = new Composition( - new BinaryPacking(), - new VariableByte()); + public void testComposition() { + Composition c = new Composition(new BinaryPacking(), new VariableByte()); testBoundary(c); } } diff --git a/src/test/java/me/lemire/integercompression/ByteBasicTest.java b/src/test/java/me/lemire/integercompression/ByteBasicTest.java new file mode 100644 index 0000000..2b2d4f1 --- /dev/null +++ b/src/test/java/me/lemire/integercompression/ByteBasicTest.java @@ -0,0 +1,121 @@ +/** + * This code is released under the + * Apache License Version 2.0 http://www.apache.org/licenses/. + * + * (c) Daniel Lemire, http://lemire.me/en/ + */ + +package me.lemire.integercompression; + +import java.util.Arrays; + +import me.lemire.integercompression.differential.IntegratedVariableByte; + +import org.junit.Test; + +import static org.junit.Assert.*; + + +/** + * Just some basic sanity tests. + * + * @author Daniel Lemire + */ +@SuppressWarnings({ "static-method" }) +public class ByteBasicTest { + ByteIntegerCODEC[] codecs = { + new VariableByte(), + new IntegratedVariableByte(), + }; + + /** + * + */ + @Test + public void saulTest() { + for (ByteIntegerCODEC C : codecs) { + for (int x = 0; x < 50 * 4; ++x) { + int[] a = { 2, 3, 4, 5 }; + byte[] b = new byte[90*4]; + int[] c = new int[a.length]; + + IntWrapper aOffset = new IntWrapper(0); + IntWrapper bOffset = new IntWrapper(x); + C.compress(a, aOffset, a.length, b, bOffset); + int len = bOffset.get() - x; + + bOffset.set(x); + IntWrapper cOffset = new IntWrapper(0); + C.uncompress(b, bOffset, len, c, cOffset); + if(!Arrays.equals(a, c)) { + System.out.println("Problem with "+C); + } + assertArrayEquals(a, c); + } + } + } + /** + * + */ + @Test + public void varyingLengthTest() { + int N = 4096; + int[] data = new int[N]; + for (int k = 0; k < N; ++k) + data[k] = k; + for (ByteIntegerCODEC c : codecs) { + for (int L = 1; L <= 128; L++) { + byte[] comp = TestUtils.compress(c, Arrays.copyOf(data, L)); + int[] answer = TestUtils.uncompress(c, comp, L); + for (int k = 0; k < L; ++k) + if (answer[k] != data[k]) + throw new RuntimeException("bug "+c.toString()+" "+k+" "+answer[k]+" "+data[k]); + } + for (int L = 128; L <= N; L *= 2) { + byte[] comp = TestUtils.compress(c, Arrays.copyOf(data, L)); + int[] answer = TestUtils.uncompress(c, comp, L); + for (int k = 0; k < L; ++k) + if (answer[k] != data[k]) + throw new RuntimeException("bug"); + } + + } + } + + /** + * + */ + @Test + public void varyingLengthTest2() { + int N = 128; + int[] data = new int[N]; + data[127] = -1; + for (ByteIntegerCODEC c : codecs) { + try { + // CODEC Simple9 is limited to "small" integers. + if (c.getClass().equals( + Class.forName("me.lemire.integercompression.Simple9"))) + continue; + } catch (ClassNotFoundException e) { + e.printStackTrace(); + } + for (int L = 1; L <= 128; L++) { + byte[] comp = TestUtils.compress(c, Arrays.copyOf(data, L)); + int[] answer = TestUtils.uncompress(c, comp, L); + for (int k = 0; k < L; ++k) + if (answer[k] != data[k]) + throw new RuntimeException("bug at k = "+k+" "+answer[k]+" "+data[k]); + } + for (int L = 128; L <= N; L *= 2) { + byte[] comp = TestUtils.compress(c, Arrays.copyOf(data, L)); + int[] answer = TestUtils.uncompress(c, comp, L); + for (int k = 0; k < L; ++k) + if (answer[k] != data[k]) + throw new RuntimeException("bug"); + } + + } + } + + +} diff --git a/src/test/java/me/lemire/integercompression/DeltaZigzagEncodingTest.java b/src/test/java/me/lemire/integercompression/DeltaZigzagEncodingTest.java new file mode 100644 index 0000000..ae42c1d --- /dev/null +++ b/src/test/java/me/lemire/integercompression/DeltaZigzagEncodingTest.java @@ -0,0 +1,124 @@ +/** + * This code is released under the + * Apache License Version 2.0 http://www.apache.org/licenses/. + * + * (c) Daniel Lemire, http://lemire.me/en/ + */ + +package me.lemire.integercompression; + +import org.junit.Test; +import static org.junit.Assert.*; + +/** + * @author lemire + * + */ +@SuppressWarnings({ "static-method" }) +public class DeltaZigzagEncodingTest { + + protected static int zigzagEncode(DeltaZigzagEncoding.Encoder e, int value) { + e.setContextValue(0); + return e.encodeInt(value); + } + + protected static int zigzagDecode(DeltaZigzagEncoding.Decoder d, int value) { + d.setContextValue(0); + return d.decodeInt(value); + } + + protected static void checkEncode( + DeltaZigzagEncoding.Encoder e, + int[] data, + int[] expected) + { + assertArrayEquals(expected, e.encodeArray(data)); + assertEquals(data[data.length - 1], e.getContextValue()); + } + + protected static void checkDecode( + DeltaZigzagEncoding.Decoder d, + int[] data, + int[] expected) + { + int[] r = d.decodeArray(data); + assertArrayEquals(expected, r); + assertEquals(r[r.length - 1], d.getContextValue()); + } + /** + * + */ + @Test + public void checkZigzagEncode() { + DeltaZigzagEncoding.Encoder e = new DeltaZigzagEncoding.Encoder(0); + assertEquals(0, zigzagEncode(e, 0)); + assertEquals(2, zigzagEncode(e, 1)); + assertEquals(4, zigzagEncode(e, 2)); + assertEquals(6, zigzagEncode(e, 3)); + assertEquals(1, zigzagEncode(e, -1)); + assertEquals(3, zigzagEncode(e, -2)); + assertEquals(5, zigzagEncode(e, -3)); + } + /** + * + */ + @Test + public void checkZigzagDecoder() { + DeltaZigzagEncoding.Decoder d = new DeltaZigzagEncoding.Decoder(0); + assertEquals( 0, zigzagDecode(d, 0)); + assertEquals(-1, zigzagDecode(d, 1)); + assertEquals( 1, zigzagDecode(d, 2)); + assertEquals(-2, zigzagDecode(d, 3)); + assertEquals( 2, zigzagDecode(d, 4)); + assertEquals(-3, zigzagDecode(d, 5)); + } + /** + * + */ + @Test + public void checkEncodeSimple() { + DeltaZigzagEncoding.Encoder e = new DeltaZigzagEncoding.Encoder(0); + checkEncode(e, + new int[]{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }, + new int[]{ 0, 2, 2, 2, 2, 2, 2, 2, 2, 2 }); + } + /** + * + */ + @Test + public void checkDecodeSimple() { + DeltaZigzagEncoding.Decoder d = new DeltaZigzagEncoding.Decoder(0); + checkDecode(d, + new int[]{ 0, 2, 2, 2, 2, 2, 2, 2, 2, 2 }, + new int[]{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }); + } + + protected static class SpotChecker { + + private final static DeltaZigzagEncoding.Encoder encoder = + new DeltaZigzagEncoding.Encoder(0); + + private final static DeltaZigzagEncoding.Decoder decoder = + new DeltaZigzagEncoding.Decoder(0); + + public void check(int value) { + SpotChecker.encoder.setContextValue(0); + SpotChecker.decoder.setContextValue(0); + int value2 = SpotChecker.decoder.decodeInt(SpotChecker.encoder.encodeInt(value)); + assertEquals(value, value2); + } + } + + /** + * + */ + @Test + public void checkSpots() { + SpotChecker c = new SpotChecker(); + c.check(0); + c.check(1); + c.check(1375228800); + c.check(1 << 30); + c.check(1 << 31); + } +} diff --git a/src/test/java/me/lemire/integercompression/ExampleTest.java b/src/test/java/me/lemire/integercompression/ExampleTest.java new file mode 100644 index 0000000..c63c69b --- /dev/null +++ b/src/test/java/me/lemire/integercompression/ExampleTest.java @@ -0,0 +1,319 @@ +/** + * This code is released under the + * Apache License Version 2.0 http://www.apache.org/licenses/. + * + * (c) Daniel Lemire, http://lemire.me/en/ + */ + +package me.lemire.integercompression; + +import me.lemire.integercompression.differential.*; +import java.util.*; + +import org.junit.Test; + +/** + * + * + */ +public class ExampleTest { + /** + * + */ + @Test + + public void superSimpleExample() { + IntegratedIntCompressor iic = new IntegratedIntCompressor(); + int[] data = new int[2342351]; + for (int k = 0; k < data.length; ++k) + data[k] = k; + System.out.println("Compressing " + data.length + " integers using friendly interface"); + int[] compressed = iic.compress(data); + int[] recov = iic.uncompress(compressed); + System.out + .println("compressed from " + data.length * 4 / 1024 + "KB to " + compressed.length * 4 / 1024 + "KB"); + if (!Arrays.equals(recov, data)) + throw new RuntimeException("bug"); + } + + /** + * + */ + @Test + + public void basicExample() { + int[] data = new int[2342351]; + System.out.println("Compressing " + data.length + " integers in one go"); + // data should be sorted for best + // results + for (int k = 0; k < data.length; ++k) + data[k] = k; + // Very important: the data is in sorted order!!! If not, you + // will get very poor compression with IntegratedBinaryPacking, + // you should use another CODEC. + + // next we compose a CODEC. Most of the processing + // will be done with binary packing, and leftovers will + // be processed using variable byte + IntegratedIntegerCODEC codec = new IntegratedComposition(new IntegratedBinaryPacking(), + new IntegratedVariableByte()); + // output vector should be large enough... + int[] compressed = new int[data.length + 1024]; + // compressed might not be large enough in some cases + // if you get java.lang.ArrayIndexOutOfBoundsException, try + // allocating more memory + + /** + * + * compressing + * + */ + IntWrapper inputoffset = new IntWrapper(0); + IntWrapper outputoffset = new IntWrapper(0); + codec.compress(data, inputoffset, data.length, compressed, outputoffset); + // got it! + // inputoffset should be at data.length but outputoffset tells + // us where we are... + System.out.println( + "compressed from " + data.length * 4 / 1024 + "KB to " + outputoffset.intValue() * 4 / 1024 + "KB"); + // we can repack the data: (optional) + compressed = Arrays.copyOf(compressed, outputoffset.intValue()); + + /** + * + * now uncompressing + * + * This assumes that we otherwise know how many integers have been + * compressed. See basicExampleHeadless for a more general case. + */ + int[] recovered = new int[data.length]; + IntWrapper recoffset = new IntWrapper(0); + codec.uncompress(compressed, new IntWrapper(0), compressed.length, recovered, recoffset); + if (Arrays.equals(data, recovered)) + System.out.println("data is recovered without loss"); + else + throw new RuntimeException("bug"); // could use assert + System.out.println(); + } + + /** + * Like the basicExample, but we store the input array size manually. + */ + @Test + public void basicExampleHeadless() { + int[] data = new int[2342351]; + System.out.println("Compressing " + data.length + " integers in one go using the headless approach"); + // data should be sorted for best + // results + for (int k = 0; k < data.length; ++k) + data[k] = k; + // Very important: the data is in sorted order!!! If not, you + // will get very poor compression with IntegratedBinaryPacking, + // you should use another CODEC. + + // next we compose a CODEC. Most of the processing + // will be done with binary packing, and leftovers will + // be processed using variable byte + SkippableIntegratedComposition codec = new SkippableIntegratedComposition(new IntegratedBinaryPacking(), + new IntegratedVariableByte()); + int[] compressed = new int[codec.maxHeadlessCompressedLength(new IntWrapper(0), data.length)]; + + /** + * + * compressing + * + */ + IntWrapper inputoffset = new IntWrapper(0); + IntWrapper outputoffset = new IntWrapper(1); + compressed[0] = data.length; // we manually store how many integers we + codec.headlessCompress(data, inputoffset, data.length, compressed, outputoffset, new IntWrapper(0)); + // got it! + // inputoffset should be at data.length but outputoffset tells + // us where we are... + System.out.println( + "compressed from " + data.length * 4 / 1024 + "KB to " + outputoffset.intValue() * 4 / 1024 + "KB"); + // we can repack the data: (optional) + compressed = Arrays.copyOf(compressed, outputoffset.intValue()); + + /** + * + * now uncompressing + * + */ + int howmany = compressed[0];// we manually stored the number of + // compressed integers + int[] recovered = new int[howmany]; + IntWrapper recoffset = new IntWrapper(0); + codec.headlessUncompress(compressed, new IntWrapper(1), compressed.length, recovered, recoffset, howmany, new IntWrapper(0)); + if (Arrays.equals(data, recovered)) + System.out.println("data is recovered without loss"); + else + throw new RuntimeException("bug"); // could use assert + System.out.println(); + } + + /** + * This is an example to show you can compress unsorted integers as long as + * most are small. + */ + @Test + public void unsortedExample() { + final int N = 1333333; + int[] data = new int[N]; + // initialize the data (most will be small + for (int k = 0; k < N; k += 1) + data[k] = 3; + // throw some larger values + for (int k = 0; k < N; k += 5) + data[k] = 100; + for (int k = 0; k < N; k += 533) + data[k] = 10000; + int[] compressed = new int[N + 1024];// could need more + IntegerCODEC codec = new Composition(new FastPFOR(), new VariableByte()); + // compressing + IntWrapper inputoffset = new IntWrapper(0); + IntWrapper outputoffset = new IntWrapper(0); + codec.compress(data, inputoffset, data.length, compressed, outputoffset); + System.out.println("compressed unsorted integers from " + data.length * 4 / 1024 + "KB to " + + outputoffset.intValue() * 4 / 1024 + "KB"); + // we can repack the data: (optional) + compressed = Arrays.copyOf(compressed, outputoffset.intValue()); + + int[] recovered = new int[N]; + IntWrapper recoffset = new IntWrapper(0); + codec.uncompress(compressed, new IntWrapper(0), compressed.length, recovered, recoffset); + if (Arrays.equals(data, recovered)) + System.out.println("data is recovered without loss"); + else + throw new RuntimeException("bug"); // could use assert + System.out.println(); + + } + + /** + * This is like the basic example, but we show how to process larger arrays + * in chunks. + * + * Some of this code was written by Pavel Klinov. + */ + @Test + public void advancedExample() { + int TotalSize = 2342351; // some arbitrary number + int ChunkSize = 16384; // size of each chunk, choose a multiple of 128 + System.out.println("Compressing " + TotalSize + " integers using chunks of " + ChunkSize + " integers (" + + ChunkSize * 4 / 1024 + "KB)"); + System.out.println("(It is often better for applications to work in chunks fitting in CPU cache.)"); + int[] data = new int[TotalSize]; + // data should be sorted for best + // results + for (int k = 0; k < data.length; ++k) + data[k] = k; + // next we compose a CODEC. Most of the processing + // will be done with binary packing, and leftovers will + // be processed using variable byte, using variable byte + // only for the last chunk! + IntegratedIntegerCODEC regularcodec = new IntegratedBinaryPacking(); + IntegratedVariableByte ivb = new IntegratedVariableByte(); + IntegratedIntegerCODEC lastcodec = new IntegratedComposition(regularcodec, ivb); + // output vector should be large enough... + int[] compressed = new int[TotalSize + 1024]; + + /** + * + * compressing + * + */ + IntWrapper inputoffset = new IntWrapper(0); + IntWrapper outputoffset = new IntWrapper(0); + for (int k = 0; k < TotalSize / ChunkSize; ++k) + regularcodec.compress(data, inputoffset, ChunkSize, compressed, outputoffset); + lastcodec.compress(data, inputoffset, TotalSize % ChunkSize, compressed, outputoffset); + // got it! + // inputoffset should be at data.length but outputoffset tells + // us where we are... + System.out.println( + "compressed from " + data.length * 4 / 1024 + "KB to " + outputoffset.intValue() * 4 / 1024 + "KB"); + // we can repack the data: + compressed = Arrays.copyOf(compressed, outputoffset.intValue()); + + /** + * + * now uncompressing + * + * We are *not* assuming that the original array length is known, + * however we assume that the chunk size (ChunkSize) is known. + * + */ + int[] recovered = new int[ChunkSize]; + IntWrapper compoff = new IntWrapper(0); + IntWrapper recoffset; + int currentpos = 0; + + while (compoff.get() < compressed.length) { + recoffset = new IntWrapper(0); + regularcodec.uncompress(compressed, compoff, compressed.length - compoff.get(), recovered, recoffset); + + if (recoffset.get() < ChunkSize) {// last chunk detected + ivb.uncompress(compressed, compoff, compressed.length - compoff.get(), recovered, recoffset); + } + for (int i = 0; i < recoffset.get(); ++i) { + if (data[currentpos + i] != recovered[i]) + throw new RuntimeException("bug"); // could use assert + } + currentpos += recoffset.get(); + } + System.out.println("data is recovered without loss"); + System.out.println(); + + } + + /** + * Demo of the headless approach where we must supply the array length + */ + @Test + public void headlessDemo() { + System.out.println("Compressing arrays with minimal header..."); + int[] uncompressed1 = { 1, 2, 1, 3, 1 }; + int[] uncompressed2 = { 3, 2, 4, 6, 1 }; + + SkippableIntegerCODEC codec = new SkippableComposition(new BinaryPacking(), new VariableByte()); + + int maxCompressedLength = codec.maxHeadlessCompressedLength(new IntWrapper(0), uncompressed1.length) + + codec.maxHeadlessCompressedLength(new IntWrapper(0), uncompressed2.length); + int[] compressed = new int[maxCompressedLength]; + + // compressing + IntWrapper outPos = new IntWrapper(); + + IntWrapper previous = new IntWrapper(); + + codec.headlessCompress(uncompressed1, new IntWrapper(), uncompressed1.length, compressed, outPos); + int length1 = outPos.get() - previous.get(); + previous = new IntWrapper(outPos.get()); + codec.headlessCompress(uncompressed2, new IntWrapper(), uncompressed2.length, compressed, outPos); + int length2 = outPos.get() - previous.get(); + + compressed = Arrays.copyOf(compressed, length1 + length2); + System.out + .println("compressed unsorted integers from " + uncompressed1.length * 4 + "B to " + length1 * 4 + "B"); + System.out + .println("compressed unsorted integers from " + uncompressed2.length * 4 + "B to " + length2 * 4 + "B"); + System.out.println("Total compressed output " + compressed.length); + + int[] recovered1 = new int[uncompressed1.length]; + int[] recovered2 = new int[uncompressed1.length]; + IntWrapper inPos = new IntWrapper(); + System.out.println("Decoding first array starting at pos = " + inPos); + codec.headlessUncompress(compressed, inPos, compressed.length, recovered1, new IntWrapper(0), + uncompressed1.length); + System.out.println("Decoding second array starting at pos = " + inPos); + codec.headlessUncompress(compressed, inPos, compressed.length, recovered2, new IntWrapper(0), + uncompressed2.length); + if (!Arrays.equals(uncompressed1, recovered1)) + throw new RuntimeException("First array does not match."); + if (!Arrays.equals(uncompressed2, recovered2)) + throw new RuntimeException("Second array does not match."); + System.out.println("The arrays match, your code is probably ok."); + + } +} diff --git a/src/test/java/me/lemire/integercompression/IntCompressorTest.java b/src/test/java/me/lemire/integercompression/IntCompressorTest.java new file mode 100644 index 0000000..79e51fc --- /dev/null +++ b/src/test/java/me/lemire/integercompression/IntCompressorTest.java @@ -0,0 +1,84 @@ +/** + * This code is released under the + * Apache License Version 2.0 http://www.apache.org/licenses/. + * + * (c) Daniel Lemire, http://lemire.me/en/ + */ + +package me.lemire.integercompression; + +import java.util.Arrays; + +import org.junit.Assert; +import org.junit.Test; + +import me.lemire.integercompression.differential.IntegratedBinaryPacking; +import me.lemire.integercompression.differential.IntegratedIntCompressor; +import me.lemire.integercompression.differential.IntegratedVariableByte; +import me.lemire.integercompression.differential.SkippableIntegratedComposition; + +/** + * Testing IntCompressor objects. + */ +public class IntCompressorTest { + IntegratedIntCompressor[] iic = { + new IntegratedIntCompressor(new IntegratedVariableByte()), + new IntegratedIntCompressor( + new SkippableIntegratedComposition( + new IntegratedBinaryPacking(), + new IntegratedVariableByte())) }; + IntCompressor[] ic = { + new IntCompressor(new VariableByte()), + new IntCompressor(new SkippableComposition(new BinaryPacking(), + new VariableByte())) }; + + /** + * + */ + @Test + public void basicTest() { + for (int N = 1; N <= 10000; N *= 10) { + int[] orig = new int[N]; + for (int k = 0; k < N; k++) + orig[k] = 3 * k + 5; + for (IntCompressor i : ic) { + int[] comp = i.compress(orig); + int[] back = i.uncompress(comp); + Assert.assertArrayEquals(back, orig); + } + } + + } + /** + * + */ + @Test + public void superSimpleExample() { + IntegratedIntCompressor iic = new IntegratedIntCompressor(); + int[] data = new int[2342351]; + for(int k = 0; k < data.length; ++k) + data[k] = k; + System.out.println("Compressing "+data.length+" integers using friendly interface"); + int[] compressed = iic.compress(data); + int[] recov = iic.uncompress(compressed); + System.out.println("compressed from "+data.length*4/1024+"KB to "+compressed.length*4/1024+"KB"); + if(!Arrays.equals(recov,data)) throw new RuntimeException("bug"); + } + + /** + * + */ + @Test + public void basicIntegratedTest() { + for (int N = 1; N <= 10000; N *= 10) { + int[] orig = new int[N]; + for (int k = 0; k < N; k++) + orig[k] = 3 * k + 5; + for (IntegratedIntCompressor i : iic) { + int[] comp = i.compress(orig); + int[] back = i.uncompress(comp); + Assert.assertArrayEquals(back, orig); + } + } + } +} diff --git a/src/test/java/me/lemire/integercompression/ResourcedTest.java b/src/test/java/me/lemire/integercompression/ResourcedTest.java new file mode 100644 index 0000000..8316129 --- /dev/null +++ b/src/test/java/me/lemire/integercompression/ResourcedTest.java @@ -0,0 +1,88 @@ +/** + * This code is released under the + * Apache License Version 2.0 http://www.apache.org/licenses/. + * + * (c) Daniel Lemire, http://lemire.me/en/ + */ + +package me.lemire.integercompression; + +import java.util.ArrayList; +import me.lemire.integercompression.differential.IntegratedIntCompressor; +import me.lemire.integercompression.differential.SkippableIntegratedIntegerCODEC; + +import java.io.BufferedReader; +import java.io.File; +import org.junit.Assert; +import java.io.FileReader; +import java.io.IOException; + +import org.junit.Test; + +/** + * Tests with resources + * + */ +public class ResourcedTest { + SkippableIntegerCODEC[] codecs = { new JustCopy(), new VariableByte(), + new SkippableComposition(new BinaryPacking(), new VariableByte()), + new SkippableComposition(new NewPFD(), new VariableByte()), + new SkippableComposition(new NewPFDS9(), new VariableByte()), + new SkippableComposition(new NewPFDS16(), new VariableByte()), + new SkippableComposition(new OptPFD(), new VariableByte()), + new SkippableComposition(new OptPFDS9(), new VariableByte()), + new SkippableComposition(new OptPFDS16(), new VariableByte()), + new SkippableComposition(new FastPFOR128(), new VariableByte()), + new SkippableComposition(new FastPFOR(), new VariableByte()), new Simple9(), new Simple16() }; + + /** + * @throws IOException + * if the resource cannot be accessed (should be considered a + * bug) + * + */ + @Test + public void IntCompressorTest() throws IOException { + // next line requires Java8? + // int[] data = + // Files.lines(Paths.get("integers.txt")).mapToInt(Integer::parseInt).toArray(); + File f = new File("src/test/resources/integers.txt"); + System.out.println("loading test data from "+ f.getAbsolutePath()); + BufferedReader bfr = new BufferedReader(new FileReader(f)); + String line; + ArrayList ai = new ArrayList(); + while ((line = bfr.readLine()) != null) { + ai.add(Integer.parseInt(line)); + } + bfr.close(); + int[] data = new int[ai.size()]; + for (int k = 0; k < data.length; ++k) + data[k] = ai.get(k).intValue(); + ai = null; + // finally! + { + IntegratedIntCompressor iic = new IntegratedIntCompressor(); + int[] compressed = iic.compress(data); + int[] recovered = iic.uncompress(compressed); + Assert.assertArrayEquals(recovered, data); + } + for (SkippableIntegerCODEC C : codecs) { + IntCompressor iic = new IntCompressor(C); + int[] compressed = iic.compress(data); + int[] recovered = iic.uncompress(compressed); + Assert.assertArrayEquals(recovered, data); + + } + for (SkippableIntegerCODEC C : codecs) { + if (C instanceof SkippableIntegratedIntegerCODEC) { + IntegratedIntCompressor iic = new IntegratedIntCompressor((SkippableIntegratedIntegerCODEC) C); + int[] compressed = iic.compress(data); + int[] recovered = iic.uncompress(compressed); + Assert.assertArrayEquals(recovered, data); + } + + } + + } + +} diff --git a/src/test/java/me/lemire/integercompression/SkippableBasicTest.java b/src/test/java/me/lemire/integercompression/SkippableBasicTest.java new file mode 100644 index 0000000..881dada --- /dev/null +++ b/src/test/java/me/lemire/integercompression/SkippableBasicTest.java @@ -0,0 +1,288 @@ +/** + * This code is released under the + * Apache License Version 2.0 http://www.apache.org/licenses/. + * + * (c) Daniel Lemire, http://lemire.me/en/ + */ + +package me.lemire.integercompression; + +import java.util.Arrays; + +import me.lemire.integercompression.differential.IntegratedBinaryPacking; +import me.lemire.integercompression.differential.IntegratedVariableByte; +import me.lemire.integercompression.differential.SkippableIntegratedComposition; +import me.lemire.integercompression.differential.SkippableIntegratedIntegerCODEC; +import org.junit.Test; + +import static org.junit.Assert.assertArrayEquals; +import static org.junit.Assert.assertTrue; + +/** + * Just some basic sanity tests. + * + * @author Daniel Lemire + */ +@SuppressWarnings({ "static-method" }) +public class SkippableBasicTest { + final SkippableIntegerCODEC[] codecs = { + new JustCopy(), + new VariableByte(), + new SkippableComposition(new BinaryPacking(), new VariableByte()), + new SkippableComposition(new NewPFD(), new VariableByte()), + new SkippableComposition(new NewPFDS9(), new VariableByte()), + new SkippableComposition(new NewPFDS16(), new VariableByte()), + new SkippableComposition(new OptPFD(), new VariableByte()), + new SkippableComposition(new OptPFDS9(), new VariableByte()), + new SkippableComposition(new OptPFDS16(), new VariableByte()), + new SkippableComposition(new FastPFOR128(), new VariableByte()), + new SkippableComposition(new FastPFOR(), new VariableByte()), + new Simple9(), + new Simple16() }; + + + /** + * + */ + @Test + public void consistentTest() { + int N = 4096; + int[] data = new int[N]; + int[] rev = new int[N]; + for (int k = 0; k < N; ++k) + data[k] = k % 128; + for (SkippableIntegerCODEC c : codecs) { + System.out.println("[SkippeableBasicTest.consistentTest] codec = " + + c); + for (int n = 0; n <= N; ++n) { + IntWrapper inPos = new IntWrapper(); + IntWrapper outPos = new IntWrapper(); + int[] outBuf = new int[c.maxHeadlessCompressedLength(new IntWrapper(0), n)]; + + c.headlessCompress(data, inPos, n, outBuf, outPos); + + IntWrapper inPoso = new IntWrapper(); + IntWrapper outPoso = new IntWrapper(); + c.headlessUncompress(outBuf, inPoso, outPos.get(), rev, + outPoso, n); + if (outPoso.get() != n) { + throw new RuntimeException("bug "+n); + } + if (inPoso.get() != outPos.get()) { + throw new RuntimeException("bug "+n+" "+inPoso.get()+" "+outPos.get()); + } + for (int j = 0; j < n; ++j) + if (data[j] != rev[j]) { + throw new RuntimeException("bug"); + } + } + } + } + + + /** + * + */ + @Test + public void varyingLengthTest() { + int N = 4096; + int[] data = new int[N]; + for (int k = 0; k < N; ++k) + data[k] = k; + for (SkippableIntegerCODEC c : codecs) { + System.out.println("[SkippeableBasicTest.varyingLengthTest] codec = "+c); + for (int L = 1; L <= 128; L++) { + int[] comp = TestUtils.compressHeadless(c, Arrays.copyOf(data, L)); + int[] answer = TestUtils.uncompressHeadless(c, comp, L); + for (int k = 0; k < L; ++k) + if (answer[k] != data[k]) + throw new RuntimeException("bug "+c.toString()+" "+k+" "+answer[k]+" "+data[k]); + } + for (int L = 128; L <= N; L *= 2) { + int[] comp = TestUtils.compressHeadless(c, Arrays.copyOf(data, L)); + int[] answer = TestUtils.uncompressHeadless(c, comp, L); + for (int k = 0; k < L; ++k) + if (answer[k] != data[k]) + throw new RuntimeException("bug"); + } + + } + } + + /** + * + */ + @Test + public void varyingLengthTest2() { + int N = 128; + int[] data = new int[N]; + data[127] = -1; + for (SkippableIntegerCODEC c : codecs) { + System.out.println("[SkippeableBasicTest.varyingLengthTest2] codec = "+c); + + try { + // CODEC Simple9 is limited to "small" integers. + if (c.getClass().equals( + Class.forName("me.lemire.integercompression.Simple9"))) + continue; + } catch (ClassNotFoundException e) { + e.printStackTrace(); + } + try { + // CODEC Simple16 is limited to "small" integers. + if (c.getClass().equals( + Class.forName("me.lemire.integercompression.Simple16"))) + continue; + } catch (ClassNotFoundException e) { + e.printStackTrace(); + } + for (int L = 1; L <= 128; L++) { + int[] comp = TestUtils.compressHeadless(c, Arrays.copyOf(data, L)); + int[] answer = TestUtils.uncompressHeadless(c, comp, L); + for (int k = 0; k < L; ++k) + if (answer[k] != data[k]) + throw new RuntimeException("bug at k = "+k+" "+answer[k]+" "+data[k]+" for "+c.toString()); + } + for (int L = 128; L <= N; L *= 2) { + int[] comp = TestUtils.compressHeadless(c, Arrays.copyOf(data, L)); + int[] answer = TestUtils.uncompressHeadless(c, comp, L); + for (int k = 0; k < L; ++k) + if (answer[k] != data[k]) + throw new RuntimeException("bug"); + } + + } + } + + @Test + public void testMaxHeadlessCompressedLength() { + testMaxHeadlessCompressedLength(new IntegratedBinaryPacking(), 16 * IntegratedBinaryPacking.BLOCK_SIZE); + testMaxHeadlessCompressedLength(new IntegratedVariableByte(), 128); + testMaxHeadlessCompressedLength(new SkippableIntegratedComposition(new IntegratedBinaryPacking(), new IntegratedVariableByte()), 16 * IntegratedBinaryPacking.BLOCK_SIZE + 10); + + testMaxHeadlessCompressedLength(new BinaryPacking(), 16 * BinaryPacking.BLOCK_SIZE, 32); + testMaxHeadlessCompressedLength(new VariableByte(), 128, 32); + testMaxHeadlessCompressedLength(new SkippableComposition(new BinaryPacking(), new VariableByte()), 16 * BinaryPacking.BLOCK_SIZE + 10, 32); + testMaxHeadlessCompressedLength(new JustCopy(), 128, 32); + testMaxHeadlessCompressedLength(new Simple9(), 128, 28); + testMaxHeadlessCompressedLength(new Simple16(), 128, 28); + testMaxHeadlessCompressedLength(new GroupSimple9(), 128, 28); + testMaxHeadlessCompressedLength(new OptPFD(), 4 * OptPFD.BLOCK_SIZE, 32); + testMaxHeadlessCompressedLength(new SkippableComposition(new OptPFD(), new VariableByte()), 4 * OptPFD.BLOCK_SIZE + 10, 32); + testMaxHeadlessCompressedLength(new OptPFDS9(), 4 * OptPFDS9.BLOCK_SIZE, 32); + testMaxHeadlessCompressedLength(new SkippableComposition(new OptPFDS9(), new VariableByte()), 4 * OptPFDS9.BLOCK_SIZE + 10, 32); + testMaxHeadlessCompressedLength(new OptPFDS16(), 4 * OptPFDS16.BLOCK_SIZE, 32); + testMaxHeadlessCompressedLength(new SkippableComposition(new OptPFDS9(), new VariableByte()), 4 * OptPFDS16.BLOCK_SIZE + 10, 32); + testMaxHeadlessCompressedLength(new NewPFD(), 4 * NewPFD.BLOCK_SIZE, 32); + testMaxHeadlessCompressedLength(new SkippableComposition(new NewPFD(), new VariableByte()), 4 * NewPFD.BLOCK_SIZE + 10, 32); + testMaxHeadlessCompressedLength(new NewPFDS9(), 4 * NewPFDS9.BLOCK_SIZE, 32); + testMaxHeadlessCompressedLength(new SkippableComposition(new NewPFDS9(), new VariableByte()), 4 * NewPFDS9.BLOCK_SIZE + 10, 32); + testMaxHeadlessCompressedLength(new NewPFDS16(), 4 * NewPFDS16.BLOCK_SIZE, 32); + testMaxHeadlessCompressedLength(new SkippableComposition(new NewPFDS16(), new VariableByte()), 4 * NewPFDS16.BLOCK_SIZE + 10, 32); + + int fastPfor128PageSize = FastPFOR128.BLOCK_SIZE * 4; // smaller page size than the default to speed up the test + testMaxHeadlessCompressedLength(new FastPFOR128(fastPfor128PageSize), 2 * fastPfor128PageSize, 32); + testMaxHeadlessCompressedLength(new SkippableComposition(new FastPFOR128(fastPfor128PageSize), new VariableByte()), 2 * fastPfor128PageSize + 10, 32); + int fastPforPageSize = FastPFOR.BLOCK_SIZE * 4; // smaller page size than the default to speed up the test + testMaxHeadlessCompressedLength(new FastPFOR(fastPforPageSize), 2 * fastPforPageSize, 32); + testMaxHeadlessCompressedLength(new SkippableComposition(new FastPFOR(fastPforPageSize), new VariableByte()), 2 * fastPforPageSize + 10, 32); + } + + private static void testMaxHeadlessCompressedLength(SkippableIntegratedIntegerCODEC codec, int inlengthTo) { + // We test the worst-case scenario by making all deltas and the initial value negative. + int delta = -1; + int value = delta; + + for (int inlength = 0; inlength < inlengthTo; ++inlength) { + int[] input = new int[inlength]; + for (int i = 0; i < inlength; i++) { + input[i] = value; + value += delta; + } + + int maxOutputLength = codec.maxHeadlessCompressedLength(new IntWrapper(), inlength); + int[] output = new int[maxOutputLength]; + IntWrapper outPos = new IntWrapper(); + + codec.headlessCompress(input, new IntWrapper(), inlength, output, outPos, new IntWrapper()); + // If we reach this point, no exception was thrown, which means the calculated output length was sufficient. + + assertTrue(maxOutputLength <= outPos.get() + 1); // +1 because SkippableIntegratedComposition always adds one extra integer for the potential header + } + } + + private static void testMaxHeadlessCompressedLength(SkippableIntegerCODEC codec, int inlengthTo, int maxBitWidth) { + // Some schemes ignore bit widths between 21 and 31. Therefore, in addition to maxBitWidth - 1, we also test 20. + assertTrue(maxBitWidth >= 20); + int[] regularValueBitWidths = { 20, maxBitWidth - 1 }; + + for (int inlength = 0; inlength < inlengthTo; ++inlength) { + int[] input = new int[inlength]; + + int maxOutputLength = codec.maxHeadlessCompressedLength(new IntWrapper(), inlength); + int[] output = new int[maxOutputLength]; + + for (int exceptionCount = 0; exceptionCount < inlength; exceptionCount++) { + int exception = maxBitWidth == 32 ? -1 : (1 << maxBitWidth) - 1; + + for (int regularValueBitWidth : regularValueBitWidths) { + int regularValue = regularValueBitWidth == 32 ? -1 : (1 << regularValueBitWidth) - 1; + + Arrays.fill(input, 0, exceptionCount, exception); + Arrays.fill(input, exceptionCount, input.length, regularValue); + + codec.headlessCompress(input, new IntWrapper(), inlength, output, new IntWrapper()); + // If we reach this point, no exception was thrown, which means the calculated output length was sufficient. + } + } + } + } + + @Test + public void testUncompressOutputOffset_SkippableComposition() { + for (int offset : new int[] {0, 1, 6}) { + SkippableComposition codec = new SkippableComposition(new BinaryPacking(), new VariableByte()); + + int[] input = { 2, 3, 4, 5 }; + int[] compressed = new int[codec.maxHeadlessCompressedLength(new IntWrapper(0), input.length)]; + int[] uncompressed = new int[offset + input.length]; + + IntWrapper inputOffset = new IntWrapper(0); + IntWrapper compressedOffset = new IntWrapper(0); + + codec.headlessCompress(input, inputOffset, input.length, compressed, compressedOffset); + + int compressedLength = compressedOffset.get(); + IntWrapper uncompressedOffset = new IntWrapper(offset); + compressedOffset = new IntWrapper(0); + codec.headlessUncompress(compressed, compressedOffset, compressedLength, uncompressed, uncompressedOffset, input.length); + + assertArrayEquals(input, Arrays.copyOfRange(uncompressed, offset, offset + input.length)); + } + } + + @Test + public void testUncompressOutputOffset_SkippableIntegratedComposition() { + for (int offset : new int[] {0, 1, 6}) { + SkippableIntegratedComposition codec = new SkippableIntegratedComposition(new IntegratedBinaryPacking(), new IntegratedVariableByte()); + + int[] input = { 2, 3, 4, 5 }; + int[] compressed = new int[codec.maxHeadlessCompressedLength(new IntWrapper(0), input.length)]; + int[] uncompressed = new int[offset + input.length]; + + IntWrapper inputOffset = new IntWrapper(0); + IntWrapper compressedOffset = new IntWrapper(0); + IntWrapper initValue = new IntWrapper(0); + + codec.headlessCompress(input, inputOffset, input.length, compressed, compressedOffset, initValue); + + int compressedLength = compressedOffset.get(); + IntWrapper uncompressedOffset = new IntWrapper(offset); + compressedOffset = new IntWrapper(0); + initValue = new IntWrapper(0); + codec.headlessUncompress(compressed, compressedOffset, compressedLength, uncompressed, uncompressedOffset, input.length, initValue); + + assertArrayEquals(input, Arrays.copyOfRange(uncompressed, offset, offset + input.length)); + } + } +} diff --git a/src/test/java/me/lemire/integercompression/TestUtils.java b/src/test/java/me/lemire/integercompression/TestUtils.java new file mode 100644 index 0000000..b3cbff3 --- /dev/null +++ b/src/test/java/me/lemire/integercompression/TestUtils.java @@ -0,0 +1,184 @@ +/** + * This code is released under the + * Apache License Version 2.0 http://www.apache.org/licenses/. + * + * (c) Daniel Lemire, http://lemire.me/en/ + */ + +package me.lemire.integercompression; + +import java.util.Arrays; + +import org.junit.Test; + +import static org.junit.Assert.*; + +/** + * Static utility methods for test. + */ +public class TestUtils { + + /** + * + */ + @Test + public void testPacking() { + int[] outputarray = new int[32]; + for(int b = 1; b < 32; ++b) { + int[] data = new int[32]; + int[] newdata = new int[32]; + int mask = (1< 0), LongStream.of(-1)).toArray(); + + checkConsistency(getCodec(), array); + } + + @Test + public void testCodec_ZeroTimes128Minus1() { + long[] array = LongStream.concat(LongStream.range(0, 128).map(l -> 0), LongStream.of(-1)).toArray(); + + checkConsistency(getCodec(), array); + } + + @Test + public void testCodec_MinValue() { + checkConsistency(getCodec(), new long[] { Long.MIN_VALUE }); + } + + @Test + public void testCodec_ZeroMinValue() { + checkConsistency(getCodec(), new long[] { 0, Long.MIN_VALUE }); + } + + @Test + public void testCodec_allPowerOfTwo() { + checkConsistency(getCodec(), new long[] { 1L << 42 }); + for (int i = 0; i < 64; i++) { + checkConsistency(getCodec(), new long[] { 1L << i }); + } + } + + @Test + public void testCodec_ZeroThenAllPowerOfTwo() { + for (int i = 0; i < 64; i++) { + checkConsistency(getCodec(), new long[] { 0, 1L << i }); + } + } + +} diff --git a/src/test/java/me/lemire/longcompression/LongBasicTest.java b/src/test/java/me/lemire/longcompression/LongBasicTest.java new file mode 100644 index 0000000..8dc0c9b --- /dev/null +++ b/src/test/java/me/lemire/longcompression/LongBasicTest.java @@ -0,0 +1,391 @@ +/** + * This code is released under the + * Apache License Version 2.0 http://www.apache.org/licenses/. + * + * (c) Daniel Lemire, http://lemire.me/en/ + */ + +package me.lemire.longcompression; + +import static org.junit.Assert.assertArrayEquals; +import static org.junit.Assert.assertEquals; + +import java.util.Arrays; + +import org.junit.Test; + +import me.lemire.integercompression.FastPFOR; +import me.lemire.integercompression.FastPFOR128; +import me.lemire.integercompression.IntWrapper; +import me.lemire.longcompression.differential.LongDelta; +import me.lemire.longcompression.synth.LongClusteredDataGenerator; + +/** + * Just some basic sanity tests. + * + * @author Benoit Lacelle + */ +@SuppressWarnings({ "static-method" }) +public class LongBasicTest { + final LongCODEC[] codecs = { + new LongJustCopy(), + new LongVariableByte(), + new LongAs2IntsCodec(), + new LongComposition(new LongBinaryPacking(), new LongVariableByte()), + }; + + /** + * This tests with a compressed array with various offset + */ + @Test + public void saulTest() { + for (LongCODEC C : codecs) { + for (int x = 0; x < 50; ++x) { + long[] a = { 2, 3, 4, 5 }; + long[] b = new long[90]; + long[] c = new long[a.length]; + + IntWrapper aOffset = new IntWrapper(0); + IntWrapper bOffset = new IntWrapper(x); + C.compress(a, aOffset, a.length, b, bOffset); + int len = bOffset.get() - x; + + bOffset.set(x); + IntWrapper cOffset = new IntWrapper(0); + C.uncompress(b, bOffset, len, c, cOffset); + if(!Arrays.equals(a, c)) { + System.out.println("Problem with "+C); + } + assertArrayEquals(a, c); + + } + } + } + /** + * + */ + @Test + public void varyingLengthTest() { + int N = 4096; + long[] data = new long[N]; + for (int k = 0; k < N; ++k) + data[k] = k; + for (LongCODEC c : codecs) { + System.out.println("[BasicTest.varyingLengthTest] codec = " + c); + for (int L = 1; L <= 128; L++) { + long[] comp = LongTestUtils.compress(c, Arrays.copyOf(data, L)); + long[] answer = LongTestUtils.uncompress(c, comp, L); + for (int k = 0; k < L; ++k) + if (answer[k] != data[k]) { + long[] comp2 = LongTestUtils.compress(c, Arrays.copyOf(data, L)); + long[] answer2 = LongTestUtils.uncompress(c, comp2, L); + throw new RuntimeException("bug"); + } + } + for (int L = 128; L <= N; L *= 2) { + long[] comp = LongTestUtils.compress(c, Arrays.copyOf(data, L)); + long[] answer = LongTestUtils.uncompress(c, comp, L); + for (int k = 0; k < L; ++k) + if (answer[k] != data[k]) { + long[] comp2 = LongTestUtils.compress(c, Arrays.copyOf(data, L)); + long[] answer2 = LongTestUtils.uncompress(c, comp2, L); + System.out.println(Arrays.toString(Arrays.copyOf( + answer, L))); + System.out.println(Arrays.toString(Arrays.copyOf(data, + L))); + throw new RuntimeException("bug"); + } + } + + } + } + + /** + * + */ + @Test + public void varyingLengthTest2() { + int N = 128; + long[] data = new long[N]; + data[127] = -1; + for (LongCODEC c : codecs) { + System.out.println("[BasicTest.varyingLengthTest2] codec = " + c); + try { + // CODEC Simple9 is limited to "small" integers. + if (c.getClass().equals( + Class.forName("me.lemire.integercompression.Simple9"))) + continue; + } catch (ClassNotFoundException e) { + e.printStackTrace(); + } + try { + // CODEC Simple16 is limited to "small" integers. + if (c.getClass().equals( + Class.forName("me.lemire.integercompression.Simple16"))) + continue; + } catch (ClassNotFoundException e) { + e.printStackTrace(); + } + try { + // CODEC GroupSimple9 is limited to "small" integers. + if (c.getClass().equals( + Class.forName("me.lemire.integercompression.GroupSimple9"))) + continue; + } catch (ClassNotFoundException e) { + e.printStackTrace(); + } + + for (int L = 1; L <= 128; L++) { + long[] comp = LongTestUtils.compress(c, Arrays.copyOf(data, L)); + long[] answer = LongTestUtils.uncompress(c, comp, L); + for (int k = 0; k < L; ++k) + if (answer[k] != data[k]) + throw new RuntimeException("bug"); + } + for (int L = 128; L <= N; L *= 2) { + long[] comp = LongTestUtils.compress(c, Arrays.copyOf(data, L)); + long[] answer = LongTestUtils.uncompress(c, comp, L); + for (int k = 0; k < L; ++k) + if (answer[k] != data[k]) + throw new RuntimeException("bug"); + } + + } + } + + /** + * + */ + @Test + public void checkVariousCases() { + for (LongCODEC c : codecs) { + testZeroInZeroOut(c); + test(c, c, 5, 10); + test(c, c, 5, 14); + test(c, c, 2, 18); + // TODO Unclear which codec should manage an empty output array or not + // Some IntegerCodec does not output anything if the input is smaller than some block size + // testSpurious(c); + testUnsorted(c); + testUnsorted2(c); + testUnsorted3(c); + } + } + + /** + * check that the codecs can be inverted. + */ + @Test + public void basictest() { + for (LongCODEC codec : codecs) { + test(codec, 5, 10); + test(codec, 5, 14); + test(codec, 2, 18); + } + } + + private static void testSpurious(LongCODEC c) { + long[] x = new long[1024]; + long[] y = new long[0]; + IntWrapper i0 = new IntWrapper(0); + IntWrapper i1 = new IntWrapper(0); + for (int inlength = 0; inlength < 32; ++inlength) { + c.compress(x, i0, inlength, y, i1); + assertEquals(0, i1.intValue()); + } + } + + private static void testZeroInZeroOut(LongCODEC c) { + long[] x = new long[0]; + long[] y = new long[0]; + IntWrapper i0 = new IntWrapper(0); + IntWrapper i1 = new IntWrapper(0); + c.compress(x, i0, 0, y, i1); + assertEquals(0, i1.intValue()); + + long[] out = new long[0]; + IntWrapper outpos = new IntWrapper(0); + c.uncompress(y, i1, 0, out, outpos); + assertEquals(0, outpos.intValue()); + } + + private static void test(LongCODEC c, LongCODEC co, int N, int nbr) { + LongClusteredDataGenerator cdg = new LongClusteredDataGenerator(); + for (int sparsity = 1; sparsity < 31 - nbr; sparsity += 4) { + long[][] data = new long[N][]; + int max = (1 << (nbr + sparsity)); + for (int k = 0; k < N; ++k) { + data[k] = cdg.generateClustered((1 << nbr), max); + } + testCodec(c, co, data, max); + } + } + + private static void test(LongCODEC codec, int N, int nbr) { + LongClusteredDataGenerator cdg = new LongClusteredDataGenerator(); + System.out.println("[BasicTest.test] N = " + N + " " + nbr); + for (int sparsity = 1; sparsity < 63 - nbr; sparsity += 4) { + long[][] data = new long[N][]; + long max = (1L << (nbr + sparsity)); + for (int k = 0; k < N; ++k) { + data[k] = cdg.generateClustered((1 << nbr), max); + } + + testCodec(codec, codec, data, max); + } + } + + private static void testCodec(LongCODEC c, LongCODEC co, + long[][] data, long max) { + int N = data.length; + int maxlength = 0; + for (int k = 0; k < N; ++k) { + if (data[k].length > maxlength) + maxlength = data[k].length; + } + long[] buffer = new long[maxlength + 1024]; + long[] dataout = new long[4 * maxlength + 1024]; + // 4x + 1024 to account for the possibility of some negative + // compression. + IntWrapper inpos = new IntWrapper(); + IntWrapper outpos = new IntWrapper(); + for (int k = 0; k < N; ++k) { + long[] backupdata = Arrays.copyOf(data[k], data[k].length); + + inpos.set(1); + outpos.set(0); + if (!(c instanceof IntegratedLongCODEC)) { + LongDelta.delta(backupdata); + } + c.compress(backupdata, inpos, backupdata.length - inpos.get(), + dataout, outpos); + final int thiscompsize = outpos.get() + 1; + inpos.set(0); + outpos.set(1); + buffer[0] = backupdata[0]; + co.uncompress(dataout, inpos, thiscompsize - 1, buffer, outpos); + if (!(c instanceof IntegratedLongCODEC)) + LongDelta.fastinverseDelta(buffer); + + // Check assertions. + assertEquals("length is not match", outpos.get(), data[k].length); + long[] bufferCutout = Arrays.copyOf(buffer, outpos.get()); + assertArrayEquals("failed to reconstruct original data", data[k], + bufferCutout); + } + } + + /** + * @param codec + * provided codec + */ + public void testUnsorted(LongCODEC codec) { + int[] lengths = { 133, 1026, 1333333 }; + for (int N : lengths) { + long[] data = new long[N]; + // initialize the data (most will be small) + for (int k = 0; k < N; k += 1) + data[k] = 3; + // throw some larger values + for (int k = 0; k < N; k += 5) + data[k] = 100; + for (int k = 0; k < N; k += 533) + data[k] = 10000; + data[5] = -311; + // could need more compressing + long[] compressed = new long[(int) Math.ceil(N * 1.01) + 1024]; + IntWrapper inputoffset = new IntWrapper(0); + IntWrapper outputoffset = new IntWrapper(0); + codec.compress(data, inputoffset, data.length, compressed, + outputoffset); + // we can repack the data: (optional) + compressed = Arrays.copyOf(compressed, outputoffset.intValue()); + + long[] recovered = new long[N]; + IntWrapper recoffset = new IntWrapper(0); + codec.uncompress(compressed, new IntWrapper(0), compressed.length, + recovered, recoffset); + assertArrayEquals(data, recovered); + } + } + + private void testUnsorted2(LongCODEC codec) { + long[] data = new long[128]; + data[5] = -1; + long[] compressed = new long[1024]; + IntWrapper inputoffset = new IntWrapper(0); + IntWrapper outputoffset = new IntWrapper(0); + codec.compress(data, inputoffset, data.length, compressed, outputoffset); + // we can repack the data: (optional) + compressed = Arrays.copyOf(compressed, outputoffset.intValue()); + + long[] recovered = new long[128]; + IntWrapper recoffset = new IntWrapper(0); + codec.uncompress(compressed, new IntWrapper(0), compressed.length, + recovered, recoffset); + assertArrayEquals(data, recovered); + } + + private void testUnsorted3(LongCODEC codec) { + long[] data = new long[128]; + data[127] = -1; + long[] compressed = new long[1024]; + IntWrapper inputoffset = new IntWrapper(0); + IntWrapper outputoffset = new IntWrapper(0); + codec.compress(data, inputoffset, data.length, compressed, outputoffset); + // we can repack the data: (optional) + compressed = Arrays.copyOf(compressed, outputoffset.intValue()); + + long[] recovered = new long[128]; + IntWrapper recoffset = new IntWrapper(0); + codec.uncompress(compressed, new IntWrapper(0), compressed.length, + recovered, recoffset); + assertArrayEquals(data, recovered); + } + + /** + * + */ + @Test + public void fastPforTest() { + // proposed by Stefan Ackermann (https://github.com/Stivo) + for (LongCODEC codec : codecs) { + int N = FastPFOR.BLOCK_SIZE; + long[] data = new long[N]; + for (int i = 0; i < N; i++) + data[i] = 0; + data[126] = -1; + long[] comp = LongTestUtils.compress(codec, Arrays.copyOf(data, N)); + long[] answer = LongTestUtils.uncompress(codec, comp, N); + for (int k = 0; k < N; ++k) + if (answer[k] != data[k]) { + long[] comp2 = LongTestUtils.compress(codec, Arrays.copyOf(data, N)); + long[] answer2 = LongTestUtils.uncompress(codec, comp2, N); + throw new RuntimeException("bug " + k + " " + answer[k] + + " != " + data[k]); + } + } + } + + /** + * + */ + @Test + public void fastPfor128Test() { + // proposed by Stefan Ackermann (https://github.com/Stivo) + for (LongCODEC codec : codecs) { + int N = FastPFOR128.BLOCK_SIZE; + long[] data = new long[N]; + for (int i = 0; i < N; i++) + data[i] = 0; + data[126] = -1; + long[] comp = LongTestUtils.compress(codec, Arrays.copyOf(data, N)); + long[] answer = LongTestUtils.uncompress(codec, comp, N); + for (int k = 0; k < N; ++k) + if (answer[k] != data[k]) + throw new RuntimeException("bug " + k + " " + answer[k] + + " != " + data[k]); + } + } + +} diff --git a/src/test/java/me/lemire/longcompression/LongDeltaTest.java b/src/test/java/me/lemire/longcompression/LongDeltaTest.java new file mode 100644 index 0000000..bfa1e6f --- /dev/null +++ b/src/test/java/me/lemire/longcompression/LongDeltaTest.java @@ -0,0 +1,23 @@ +package me.lemire.longcompression; + +import me.lemire.longcompression.differential.LongDelta; +import org.junit.Test; + +import static org.junit.Assert.assertArrayEquals; +import static org.junit.Assert.assertNotNull; + +public class LongDeltaTest { + @Test + public void testEmptyArrayFastInverseDelta() { + LongCompressor compressor = new LongCompressor(); + long[] input = new long[0]; + + LongDelta.delta(input); + long[] compressed = compressor.compress(input); + long[] result = compressor.uncompress(compressed); + LongDelta.fastinverseDelta(result); + + assertNotNull(result); + assertArrayEquals(input, result); + } +} diff --git a/src/test/java/me/lemire/longcompression/LongTestUtils.java b/src/test/java/me/lemire/longcompression/LongTestUtils.java new file mode 100644 index 0000000..b7d9c63 --- /dev/null +++ b/src/test/java/me/lemire/longcompression/LongTestUtils.java @@ -0,0 +1,133 @@ +/** + * This code is released under the + * Apache License Version 2.0 http://www.apache.org/licenses/. + * + * (c) Daniel Lemire, http://lemire.me/en/ + */ + +package me.lemire.longcompression; + +import static org.junit.Assert.assertArrayEquals; +import static org.junit.Assert.assertTrue; + +import java.util.Arrays; + +import me.lemire.integercompression.IntWrapper; + +/** + * Static utility methods for test. + */ +public class LongTestUtils { + + protected static void dumpIntArray(long[] data, String label) { + System.out.print(label); + for (int i = 0; i < data.length; ++i) { + if (i % 6 == 0) { + System.out.println(); + } + System.out.format(" %1$11d", data[i]); + } + System.out.println(); + } + + protected static void dumpIntArrayAsHex(long[] data, String label) { + System.out.print(label); + for (int i = 0; i < data.length; ++i) { + if (i % 8 == 0) { + System.out.println(); + } + System.out.format(" %1$08X", data[i]); + } + System.out.println(); + } + + /** + * Check that compress and uncompress keep original array. + * + * @param codec CODEC to test. + * @param orig original integers + */ + public static void assertSymmetry(LongCODEC codec, long... orig) { + // There are some cases that compressed array is bigger than original + // array. So output array for compress must be larger. + // + // Example: + // - VariableByte compresses an array like [ -1 ]. + // - Composition compresses a short array. + final int EXTEND = 1; + + long[] compressed = new long[orig.length + EXTEND]; + IntWrapper c_inpos = new IntWrapper(0); + IntWrapper c_outpos = new IntWrapper(0); + codec.compress(orig, c_inpos, orig.length, compressed, + c_outpos); + + assertTrue(c_outpos.get() <= orig.length + EXTEND); + + // Uncompress an array. + long[] uncompressed = new long[orig.length]; + IntWrapper u_inpos = new IntWrapper(0); + IntWrapper u_outpos = new IntWrapper(0); + codec.uncompress(compressed, u_inpos, c_outpos.get(), + uncompressed, u_outpos); + + // Compare between uncompressed and orig arrays. + long[] target = Arrays.copyOf(uncompressed, u_outpos.get()); + assertArrayEquals(orig, target); + } + + protected static long[] compress(LongCODEC codec, long[] data) { + long[] outBuf = new long[data.length * 8]; + IntWrapper inPos = new IntWrapper(); + IntWrapper outPos = new IntWrapper(); + codec.compress(data, inPos, data.length, outBuf, outPos); + return Arrays.copyOf(outBuf, outPos.get()); + } + + protected static long[] uncompress(LongCODEC codec, long[] data, int len) { + long[] outBuf = new long[len + 1024]; + IntWrapper inPos = new IntWrapper(); + IntWrapper outPos = new IntWrapper(); + codec.uncompress(data, inPos, data.length, outBuf, outPos); + return Arrays.copyOf(outBuf, outPos.get()); + } + + + + protected static byte[] compress(ByteLongCODEC codec, long[] data) { + byte[] outBuf = new byte[data.length * 4 * 4]; + IntWrapper inPos = new IntWrapper(); + IntWrapper outPos = new IntWrapper(); + codec.compress(data, inPos, data.length, outBuf, outPos); + return Arrays.copyOf(outBuf, outPos.get()); + } + + protected static long[] uncompress(ByteLongCODEC codec, byte[] data, int len) { + long[] outBuf = new long[len + 1024]; + IntWrapper inPos = new IntWrapper(); + IntWrapper outPos = new IntWrapper(); + codec.uncompress(data, inPos, data.length, outBuf, outPos); + return Arrays.copyOf(outBuf, outPos.get()); + } + + protected static long[] compressHeadless(SkippableLongCODEC codec, long[] data) { + long[] outBuf = new long[codec.maxHeadlessCompressedLength(new IntWrapper(0), data.length)]; + IntWrapper inPos = new IntWrapper(); + IntWrapper outPos = new IntWrapper(); + codec.headlessCompress(data, inPos, data.length, outBuf, outPos); + return Arrays.copyOf(outBuf, outPos.get()); + } + + protected static long[] uncompressHeadless(SkippableLongCODEC codec, long[] data, int len) { + long[] outBuf = new long[len + 1024]; + IntWrapper inPos = new IntWrapper(); + IntWrapper outPos = new IntWrapper(); + codec.headlessUncompress(data, inPos, data.length, outBuf, outPos,len); + if(outPos.get() < len) throw new RuntimeException("Insufficient output."); + return Arrays.copyOf(outBuf, outPos.get()); + } + + public static String longToBinaryWithLeading(long l) { + return String.format("%64s", Long.toBinaryString(l)).replace(' ', '0'); + } +} diff --git a/src/test/java/me/lemire/longcompression/SkippableLongBasicTest.java b/src/test/java/me/lemire/longcompression/SkippableLongBasicTest.java new file mode 100644 index 0000000..c4b7e01 --- /dev/null +++ b/src/test/java/me/lemire/longcompression/SkippableLongBasicTest.java @@ -0,0 +1,194 @@ +/** + * This code is released under the + * Apache License Version 2.0 http://www.apache.org/licenses/. + * + * (c) Daniel Lemire, http://lemire.me/en/ + */ + +package me.lemire.longcompression; + +import java.util.Arrays; + +import org.junit.Test; + +import me.lemire.integercompression.IntWrapper; +import me.lemire.integercompression.TestUtils; +import me.lemire.integercompression.VariableByte; + +import static org.junit.Assert.assertArrayEquals; +import static org.junit.Assert.assertTrue; + +/** + * Just some basic sanity tests. + * + * @author Benoit Lacelle + */ +@SuppressWarnings({ "static-method" }) +public class SkippableLongBasicTest { + final SkippableLongCODEC[] codecs = { + new LongJustCopy(), + new LongVariableByte(), + new SkippableLongComposition(new LongBinaryPacking(), new LongVariableByte()), }; + + + /** + * + */ + @Test + public void consistentTest() { + int N = 4096; + long[] data = new long[N]; + long[] rev = new long[N]; + for (int k = 0; k < N; ++k) + data[k] = k % 128; + for (SkippableLongCODEC c : codecs) { + System.out.println("[SkippeableBasicTest.consistentTest] codec = " + + c); + for (int n = 0; n <= N; ++n) { + IntWrapper inPos = new IntWrapper(); + IntWrapper outPos = new IntWrapper(); + long[] outBuf = new long[c.maxHeadlessCompressedLength(new IntWrapper(0), n)]; + + c.headlessCompress(data, inPos, n, outBuf, outPos); + + IntWrapper inPoso = new IntWrapper(); + IntWrapper outPoso = new IntWrapper(); + c.headlessUncompress(outBuf, inPoso, outPos.get(), rev, + outPoso, n); + if (outPoso.get() != n) { + throw new RuntimeException("bug "+n); + } + if (inPoso.get() != outPos.get()) { + throw new RuntimeException("bug "+n+" "+inPoso.get()+" "+outPos.get()); + } + for (int j = 0; j < n; ++j) + if (data[j] != rev[j]) { + throw new RuntimeException("bug"); + } + } + } + } + + + /** + * + */ + @Test + public void varyingLengthTest() { + int N = 4096; + long[] data = new long[N]; + for (int k = 0; k < N; ++k) + data[k] = k; + for (SkippableLongCODEC c : codecs) { + System.out.println("[SkippeableBasicTest.varyingLengthTest] codec = "+c); + for (int L = 1; L <= 128; L++) { + long[] comp = LongTestUtils.compressHeadless(c, Arrays.copyOf(data, L)); + long[] answer = LongTestUtils.uncompressHeadless(c, comp, L); + for (int k = 0; k < L; ++k) + if (answer[k] != data[k]) + throw new RuntimeException("bug "+c.toString()+" "+k+" "+answer[k]+" "+data[k]); + } + for (int L = 128; L <= N; L *= 2) { + long[] comp = LongTestUtils.compressHeadless(c, Arrays.copyOf(data, L)); + long[] answer = LongTestUtils.uncompressHeadless(c, comp, L); + for (int k = 0; k < L; ++k) + if (answer[k] != data[k]) + throw new RuntimeException("bug"); + } + + } + } + + /** + * + */ + @Test + public void varyingLengthTest2() { + int N = 128; + long[] data = new long[N]; + data[127] = -1; + for (SkippableLongCODEC c : codecs) { + System.out.println("[SkippeableBasicTest.varyingLengthTest2] codec = "+c); + + try { + // CODEC Simple9 is limited to "small" integers. + if (c.getClass().equals( + Class.forName("me.lemire.integercompression.Simple9"))) + continue; + } catch (ClassNotFoundException e) { + e.printStackTrace(); + } + try { + // CODEC Simple16 is limited to "small" integers. + if (c.getClass().equals( + Class.forName("me.lemire.integercompression.Simple16"))) + continue; + } catch (ClassNotFoundException e) { + e.printStackTrace(); + } + for (int L = 1; L <= 128; L++) { + long[] comp = LongTestUtils.compressHeadless(c, Arrays.copyOf(data, L)); + long[] answer = LongTestUtils.uncompressHeadless(c, comp, L); + for (int k = 0; k < L; ++k) + if (answer[k] != data[k]) { + throw new RuntimeException("L=" + L + ": bug at k = "+k+" "+answer[k]+" "+data[k]+" for "+c.toString()); + } + } + for (int L = 128; L <= N; L *= 2) { + long[] comp = LongTestUtils.compressHeadless(c, Arrays.copyOf(data, L)); + long[] answer = LongTestUtils.uncompressHeadless(c, comp, L); + for (int k = 0; k < L; ++k) + if (answer[k] != data[k]) + throw new RuntimeException("bug"); + } + + } + } + + @Test + public void testMaxHeadlessCompressedLength() { + testMaxHeadlessCompressedLength(new LongJustCopy(), 128); + testMaxHeadlessCompressedLength(new LongBinaryPacking(), 16 * LongBinaryPacking.BLOCK_SIZE); + testMaxHeadlessCompressedLength(new LongVariableByte(), 128); + testMaxHeadlessCompressedLength(new SkippableLongComposition(new LongBinaryPacking(), new LongVariableByte()), 16 * LongBinaryPacking.BLOCK_SIZE + 10); + } + + private static void testMaxHeadlessCompressedLength(SkippableLongCODEC codec, int inlengthTo) { + for (int inlength = 0; inlength < inlengthTo; ++inlength) { + long[] input = new long[inlength]; + Arrays.fill(input, -1L); + + int maxOutputLength = codec.maxHeadlessCompressedLength(new IntWrapper(), inlength); + long[] output = new long[maxOutputLength]; + IntWrapper outPos = new IntWrapper(); + + codec.headlessCompress(input, new IntWrapper(), inlength, output, outPos); + // If we reach this point, no exception was thrown, which means the calculated output length was sufficient. + + assertTrue(maxOutputLength <= outPos.get() + 1); // +1 because SkippableLongComposition always adds one extra integer for the potential header + } + } + + @Test + public void testUncompressOutputOffset_SkippableLongComposition() { + for (int offset : new int[] {0, 1, 6}) { + SkippableLongComposition codec = new SkippableLongComposition(new LongBinaryPacking(), new LongVariableByte()); + + long[] input = { 2, 3, 4, 5 }; + long[] compressed = new long[codec.maxHeadlessCompressedLength(new IntWrapper(0), input.length)]; + long[] uncompressed = new long[offset + input.length]; + + IntWrapper inputOffset = new IntWrapper(0); + IntWrapper compressedOffset = new IntWrapper(0); + + codec.headlessCompress(input, inputOffset, input.length, compressed, compressedOffset); + + int compressedLength = compressedOffset.get(); + IntWrapper uncompressedOffset = new IntWrapper(offset); + compressedOffset = new IntWrapper(0); + codec.headlessUncompress(compressed, compressedOffset, compressedLength, uncompressed, uncompressedOffset, input.length); + + assertArrayEquals(input, Arrays.copyOfRange(uncompressed, offset, offset + input.length)); + } + } +} diff --git a/src/test/java/me/lemire/longcompression/TestLongAs2IntsCodec.java b/src/test/java/me/lemire/longcompression/TestLongAs2IntsCodec.java new file mode 100644 index 0000000..bddff2a --- /dev/null +++ b/src/test/java/me/lemire/longcompression/TestLongAs2IntsCodec.java @@ -0,0 +1,31 @@ +/** + * This code is released under the + * Apache License Version 2.0 http://www.apache.org/licenses/. + * + * (c) Daniel Lemire, http://lemire.me/en/ + */ + +package me.lemire.longcompression; + +import org.junit.Assert; +import org.junit.Test; + +/** + * Edge-cases having caused issue specifically with LongVariableByte. + * + * @author Benoit Lacelle + */ +public class TestLongAs2IntsCodec extends ATestLongCODEC { + final LongAs2IntsCodec codec = new LongAs2IntsCodec(); + + @Override + public LongCODEC getCodec() { + return codec; + } + + @Test + public void testCodec_intermediateHighPowerOfTwo() { + Assert.assertEquals(3, LongTestUtils.compress((LongCODEC) codec, new long[] { 1L << 42 }).length); + } + +} diff --git a/src/test/java/me/lemire/longcompression/TestLongBinaryPacking.java b/src/test/java/me/lemire/longcompression/TestLongBinaryPacking.java new file mode 100644 index 0000000..ecc3f2e --- /dev/null +++ b/src/test/java/me/lemire/longcompression/TestLongBinaryPacking.java @@ -0,0 +1,26 @@ +/** + * This code is released under the + * Apache License Version 2.0 http://www.apache.org/licenses/. + * + * (c) Daniel Lemire, http://lemire.me/en/ + */ + +package me.lemire.longcompression; + +import org.junit.Ignore; + +/** + * Edge-cases having caused issue specifically with LongBinaryPacking. + * + * @author Benoit Lacelle + */ +@Ignore("Parent class tests are not valid as LongBinaryPacking process by chunks of 64 longs") +public class TestLongBinaryPacking extends ATestLongCODEC { + final LongBinaryPacking codec = new LongBinaryPacking(); + + @Override + public LongCODEC getCodec() { + return codec; + } + +} diff --git a/src/test/java/me/lemire/longcompression/TestLongVariableByte.java b/src/test/java/me/lemire/longcompression/TestLongVariableByte.java new file mode 100644 index 0000000..3cb2a49 --- /dev/null +++ b/src/test/java/me/lemire/longcompression/TestLongVariableByte.java @@ -0,0 +1,40 @@ +/** + * This code is released under the + * Apache License Version 2.0 http://www.apache.org/licenses/. + * + * (c) Daniel Lemire, http://lemire.me/en/ + */ + +package me.lemire.longcompression; + +import org.junit.Assert; +import org.junit.Test; + +/** + * Edge-cases having caused issue specifically with LongVariableByte. + * + * @author Benoit Lacelle + */ +public class TestLongVariableByte extends ATestLongCODEC { + final LongVariableByte codec = new LongVariableByte(); + + @Override + public LongCODEC getCodec() { + return codec; + } + + @Test + public void testCodec_allBitWidths() { + for (int bitWidth = 0; bitWidth <= 64; bitWidth++) { + long value = bitWidth == 0 ? 0 : 1L << (bitWidth - 1); + + int expectedSizeInBytes = Math.max(1, (bitWidth + 6) / 7); + int expectedSizeInLongs = (expectedSizeInBytes > 8) ? 2 : 1; + + Assert.assertEquals(expectedSizeInLongs, LongTestUtils.compress((LongCODEC) codec, new long[] { value }).length); + Assert.assertEquals(expectedSizeInBytes, LongTestUtils.compress((ByteLongCODEC) codec, new long[] { value }).length); + Assert.assertEquals(expectedSizeInLongs, + LongTestUtils.compressHeadless((SkippableLongCODEC) codec, new long[] { value }).length); + } + } +} diff --git a/src/test/java/me/lemire/longcompression/synth/LongClusteredDataGenerator.java b/src/test/java/me/lemire/longcompression/synth/LongClusteredDataGenerator.java new file mode 100644 index 0000000..c964f6f --- /dev/null +++ b/src/test/java/me/lemire/longcompression/synth/LongClusteredDataGenerator.java @@ -0,0 +1,91 @@ +/** + * This code is released under the + * Apache License Version 2.0 http://www.apache.org/licenses/. + * + * (c) Daniel Lemire, http://lemire.me/en/ + */ +package me.lemire.longcompression.synth; + +import me.lemire.integercompression.synth.ClusteredDataGenerator; + +/** + * This class will generate lists of random longs based on the clustered + * model: + * + * Reference: Vo Ngoc Anh and Alistair Moffat. 2010. Index compression using + * 64-bit words. Softw. Pract. Exper.40, 2 (February 2010), 131-147. + * + * @author Benoit Lacelle + * @see ClusteredDataGenerator + */ +public class LongClusteredDataGenerator { + + final LongUniformDataGenerator unidg = new LongUniformDataGenerator(); + + /** + * Creating random array generator. + */ + public LongClusteredDataGenerator() { + } + + void fillUniform(long[] array, int offset, int length, long Min, long Max) { + long[] v = this.unidg.generateUniform(length, Max - Min); + for (int k = 0; k < v.length; ++k) + array[k + offset] = Min + v[k]; + } + + void fillClustered(long[] array, int offset, int length, long Min, long Max) { + final long range = Max - Min; + if ((range == length) || (length <= 10)) { + fillUniform(array, offset, length, Min, Max); + return; + } + final long cut = length + / 2 + + ((range - length - 1 > 0) ? (long)this.unidg.rand + .nextDouble() * (range - length - 1) : 0); + final double p = this.unidg.rand.nextDouble(); + if (p < 0.25) { + fillUniform(array, offset, length / 2, Min, Min + cut); + fillClustered(array, offset + length / 2, length + - length / 2, Min + cut, Max); + } else if (p < 0.5) { + fillClustered(array, offset, length / 2, Min, Min + cut); + fillUniform(array, offset + length / 2, length - length + / 2, Min + cut, Max); + } else { + fillClustered(array, offset, length / 2, Min, Min + cut); + fillClustered(array, offset + length / 2, length + - length / 2, Min + cut, Max); + } + } + + /** + * generates randomly N distinct integers from 0 to Max. + * + * @param N + * number of integers to generate + * @param Max + * maximal value of the integers + * @return array containing the integers + */ + public long[] generateClustered(int N, long Max) { + long[] array = new long[N]; + fillClustered(array, 0, N, 0, Max); + return array; + } + + /** + * Little test program. + * + * @param args + * arguments are ignored + */ + public static void main(final String[] args) { + long[] example = (new LongClusteredDataGenerator()) + .generateClustered(20, 1000); + for (int k = 0; k < example.length; ++k) + System.out.println(example[k]); + } + +} diff --git a/src/test/java/me/lemire/longcompression/synth/LongUniformDataGenerator.java b/src/test/java/me/lemire/longcompression/synth/LongUniformDataGenerator.java new file mode 100644 index 0000000..4aa797b --- /dev/null +++ b/src/test/java/me/lemire/longcompression/synth/LongUniformDataGenerator.java @@ -0,0 +1,125 @@ +/** + * This code is released under the + * Apache License Version 2.0 http://www.apache.org/licenses/. + * + * (c) Daniel Lemire, http://lemire.me/en/ + */ +package me.lemire.longcompression.synth; + +import java.util.Arrays; +import java.util.HashSet; +import java.util.Iterator; +import java.util.Random; +import java.util.Set; + +import org.roaringbitmap.longlong.Roaring64Bitmap; + +import me.lemire.integercompression.synth.UniformDataGenerator; + +/** + * This class will generate "uniform" lists of random longs. + * + * @author Benoit Lacelle + * @see UniformDataGenerator + */ +public class LongUniformDataGenerator { + /** + * construct generator of random arrays. + */ + public LongUniformDataGenerator() { + this.rand = new Random(); + } + + /** + * @param seed + * random seed + */ + public LongUniformDataGenerator(final int seed) { + this.rand = new Random(seed); + } + + /** + * generates randomly N distinct longs from 0 to Max. + */ + long[] generateUniformHash(int N, long Max) { + if (N > Max) + throw new RuntimeException("not possible"); + long[] ans = new long[N]; + Set s = new HashSet<>(); + while (s.size() < N) + s.add((long) (this.rand.nextDouble() * Max)); + Iterator i = s.iterator(); + for (int k = 0; k < N; ++k) + ans[k] = i.next().longValue(); + Arrays.sort(ans); + return ans; + } + + /** + * output all longs from the range [0,Max) that are not in the array + */ + static long[] negate(long[] x, long Max) { + int newLength = saturatedCast(Max - x.length); + long[] ans = new long[newLength]; + int i = 0; + int c = 0; + for (int j = 0; j < x.length; ++j) { + long v = x[j]; + for (; i < v; ++i) + ans[c++] = i; + ++i; + } + while (c < ans.length) + ans[c++] = i++; + return ans; + } + + private static int saturatedCast(long toInt) { + if (toInt > Integer.MAX_VALUE) { + return Integer.MAX_VALUE; + } else { + return (int) toInt; + } + } + + /** + * generates randomly N distinct longs from 0 to Max. + * + * @param N + * number of longs to generate + * @param Max + * bound on the value of longs + * @return an array containing randomly selected longs + */ + public long[] generateUniform(int N, long Max) { + assert N >= 0; + assert Max >= 0; + if (N * 2 > Max) { + return negate(generateUniform(saturatedCast(Max - N), Max), Max); + } + if (2048 * N > Max) + return generateUniformBitmap(N, Max); + return generateUniformHash(N, Max); + } + + /** + * generates randomly N distinct longs from 0 to Max. + */ + long[] generateUniformBitmap(int N, long Max) { + if (N > Max) + throw new RuntimeException("not possible"); + Roaring64Bitmap bs = new Roaring64Bitmap(); + int cardinality = 0; + while (cardinality < N) { + long v = (long) (rand.nextDouble() * Max); + if (!bs.contains(v)) { + bs.add(v); + cardinality++; + } + } + return bs.toArray(); + } + + Random rand = new Random(); + +} \ No newline at end of file diff --git a/src/test/resources/integers.txt b/src/test/resources/integers.txt new file mode 100644 index 0000000..06a56d3 --- /dev/null +++ b/src/test/resources/integers.txt @@ -0,0 +1,130657 @@ +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 +15 +30 +31 +9 +32 +19 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +4 +43 +44 +45 +19 +46 +47 +48 +49 +50 +9 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +16 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +9 +12 +86 +87 +88 +89 +90 +91 +92 +10 +93 +77 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +43 +20 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +89 +129 +130 +131 +132 +133 +19 +134 +19 +135 +136 +137 +138 +139 +140 +141 +142 +143 +57 +89 +20 +43 +144 +14 +145 +32 +43 +14 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +43 +158 +159 +160 +161 +43 +162 +163 +164 +165 +57 +166 +167 +168 +169 +170 +171 +172 +19 +173 +174 +9 +175 +19 +14 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +104 +189 +190 +25 +191 +19 +4 +192 +193 +194 +195 +32 +196 +197 +198 +199 +200 +201 +202 +12 +203 +204 +205 +206 +207 +48 +208 +2 +209 +4 +164 +104 +210 +211 +212 +2 +213 +214 +215 +216 +217 +2 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +19 +12 +3 +233 +234 +235 +236 +237 +48 +238 +239 +213 +240 +241 +22 +242 +243 +244 +245 +246 +247 +248 +249 +57 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +248 +269 +270 +271 +272 +273 +3 +57 +19 +46 +274 +275 +276 +213 +277 +278 +43 +279 +280 +281 +282 +283 +283 +248 +284 +213 +213 +2 +285 +43 +32 +286 +284 +287 +288 +289 +290 +15 +291 +292 +293 +57 +294 +60 +295 +296 +297 +179 +298 +299 +29 +300 +284 +301 +302 +303 +213 +213 +304 +305 +89 +306 +307 +308 +248 +99 +309 +19 +188 +310 +311 +19 +312 +313 +314 +155 +22 +213 +248 +315 +176 +316 +317 +318 +319 +320 +19 +57 +248 +321 +322 +323 +324 +325 +43 +326 +327 +303 +328 +329 +330 +15 +248 +303 +331 +332 +333 +205 +334 +335 +14 +336 +337 +283 +43 +338 +339 +340 +341 +57 +342 +343 +337 +43 +344 +345 +346 +284 +347 +337 +348 +349 +14 +350 +46 +337 +351 +352 +286 +353 +43 +15 +354 +355 +356 +357 +358 +359 +238 +9 +360 +361 +164 +362 +363 +364 +365 +366 +367 +368 +369 +370 +371 +372 +373 +374 +375 +376 +377 +378 +379 +114 +380 +15 +381 +382 +43 +383 +384 +385 +386 +387 +388 +389 +179 +390 +358 +20 +391 +392 +349 +393 +9 +394 +395 +396 +397 +14 +398 +399 +210 +32 +400 +401 +20 +402 +403 +404 +405 +406 +407 +408 +409 +345 +410 +411 +412 +413 +414 +415 +416 +417 +418 +419 +14 +48 +2 +420 +421 +422 +423 +424 +425 +426 +427 +228 +428 +20 +429 +430 +431 +432 +433 +434 +435 +9 +14 +436 +25 +437 +438 +32 +439 +440 +32 +441 +442 +443 +444 +137 +345 +445 +20 +446 +447 +448 +449 +450 +451 +452 +48 +453 +454 +455 +456 +457 +458 +459 +16 +460 +461 +462 +463 +464 +465 +466 +467 +468 +469 +137 +470 +17 +471 +472 +473 +474 +475 +476 +477 +478 +479 +480 +481 +15 +482 +483 +484 +317 +485 +486 +19 +487 +488 +489 +490 +2 +491 +492 +369 +493 +494 +495 +496 +497 +9 +498 +499 +32 +500 +501 +502 +213 +14 +503 +77 +504 +505 +345 +506 +507 +508 +12 +509 +20 +510 +43 +511 +512 +115 +513 +514 +515 +176 +516 +15 +517 +518 +2 +519 +3 +520 +521 +522 +523 +524 +525 +526 +527 +528 +529 +19 +530 +531 +532 +155 +533 +534 +535 +536 +537 +538 +539 +540 +541 +542 +345 +115 +543 +544 +545 +546 +547 +548 +549 +550 +551 +552 +553 +554 +354 +555 +556 +357 +557 +558 +559 +560 +561 +562 +563 +564 +565 +566 +567 +541 +568 +57 +569 +14 +66 +570 +15 +109 +249 +571 +572 +15 +573 +574 +575 +576 +201 +577 +578 +579 +274 +580 +581 +582 +583 +584 +585 +196 +586 +201 +342 +587 +588 +39 +589 +590 +140 +591 +592 +593 +594 +43 +595 +596 +597 +598 +9 +286 +599 +600 +601 +228 +602 +603 +604 +200 +605 +196 +606 +607 +608 +509 +609 +610 +10 +17 +611 +248 +612 +613 +614 +197 +615 +616 +617 +618 +48 +619 +286 +620 +621 +622 +509 +623 +20 +48 +624 +9 +625 +626 +15 +627 +628 +43 +337 +629 +630 +631 +632 +43 +633 +14 +634 +635 +14 +636 +637 +2 +4 +43 +638 +639 +640 +19 +52 +641 +248 +642 +643 +644 +284 +3 +645 +2 +646 +647 +19 +648 +649 +145 +650 +43 +651 +652 +653 +654 +655 +656 +657 +658 +659 +660 +661 +196 +662 +358 +663 +345 +19 +554 +664 +528 +665 +666 +667 +331 +19 +668 +669 +670 +671 +672 +673 +155 +491 +674 +675 +676 +57 +2 +677 +678 +679 +680 +140 +398 +681 +554 +682 +14 +683 +493 +684 +597 +685 +213 +686 +687 +688 +213 +689 +4 +690 +665 +284 +691 +692 +398 +693 +694 +270 +695 +141 +19 +696 +303 +697 +19 +698 +699 +337 +248 +700 +22 +4 +701 +702 +96 +286 +703 +704 +705 +706 +237 +707 +708 +48 +57 +709 +710 +20 +48 +213 +711 +712 +713 +270 +714 +715 +284 +155 +716 +717 +718 +4 +345 +719 +720 +721 +34 +722 +20 +723 +724 +725 +726 +15 +727 +728 +729 +730 +22 +731 +732 +733 +734 +735 +736 +286 +737 +20 +738 +739 +740 +270 +19 +741 +742 +743 +744 +196 +745 +746 +747 +10 +748 +749 +665 +249 +750 +751 +155 +752 +753 +19 +754 +248 +249 +755 +756 +757 +758 +759 +760 +60 +761 +762 +763 +213 +764 +765 +766 +345 +767 +768 +707 +769 +284 +770 +771 +772 +323 +773 +774 +775 +776 +137 +777 +778 +176 +779 +780 +781 +782 +16 +783 +784 +785 +786 +43 +787 +788 +789 +232 +790 +791 +792 +793 +794 +379 +795 +2 +796 +57 +797 +798 +178 +799 +178 +188 +800 +801 +802 +803 +804 +805 +806 +141 +807 +808 +15 +809 +15 +209 +3 +810 +811 +812 +813 +814 +48 +665 +815 +286 +25 +586 +816 +34 +817 +818 +819 +820 +821 +822 +823 +824 +825 +826 +827 +828 +829 +830 +831 +832 +32 +833 +14 +834 +835 +15 +836 +837 +20 +838 +839 +840 +137 +841 +842 +843 +844 +845 +80 +846 +847 +848 +849 +323 +208 +155 +357 +850 +851 +852 +853 +3 +284 +854 +855 +32 +856 +201 +857 +399 +858 +859 +860 +861 +2 +48 +862 +863 +864 +745 +43 +865 +866 +845 +867 +868 +869 +870 +871 +19 +872 +873 +286 +874 +875 +876 +20 +877 +878 +879 +880 +201 +323 +881 +882 +883 +884 +885 +43 +886 +35 +887 +25 +888 +889 +890 +19 +891 +892 +893 +894 +895 +896 +48 +897 +898 +899 +900 +57 +901 +902 +903 +904 +566 +43 +905 +906 +907 +908 +32 +909 +99 +15 +910 +911 +721 +912 +913 +914 +915 +916 +917 +918 +554 +564 +919 +920 +317 +564 +921 +922 +923 +924 +10 +925 +665 +926 +10 +201 +927 +928 +929 +930 +931 +932 +933 +10 +934 +201 +20 +935 +936 +416 +937 +936 +938 +357 +19 +939 +940 +941 +942 +943 +249 +201 +554 +944 +945 +946 +77 +2 +947 +948 +949 +950 +951 +952 +9 +953 +954 +955 +956 +741 +957 +958 +959 +677 +960 +80 +43 +196 +961 +57 +962 +963 +354 +964 +658 +965 +966 +967 +968 +969 +970 +971 +286 +14 +2 +19 +972 +973 +974 +975 +976 +22 +977 +978 +979 +980 +981 +982 +983 +77 +984 +985 +986 +17 +2 +987 +155 +20 +34 +988 +989 +43 +990 +991 +9 +992 +993 +14 +994 +19 +115 +995 +57 +996 +3 +720 +997 +437 +2 +998 +999 +1000 +1001 +184 +1002 +1003 +1004 +15 +1005 +1006 +1007 +1008 +34 +1009 +1010 +1011 +1012 +1013 +1014 +1015 +1016 +67 +910 +1017 +1018 +1019 +19 +1020 +1021 +1022 +1023 +1024 +1025 +1026 +32 +19 +1027 +1028 +1029 +140 +1030 +1031 +1032 +1033 +1034 +1035 +1036 +1037 +1038 +1039 +1040 +165 +1041 +1042 +1043 +1044 +658 +1045 +4 +1046 +14 +1047 +1048 +1049 +1050 +9 +34 +1051 +1052 +1053 +713 +1054 +1055 +1056 +1057 +1058 +1059 +1060 +76 +1061 +1062 +19 +1063 +1064 +9 +1065 +736 +345 +1066 +15 +1067 +428 +1068 +1069 +286 +1070 +1071 +1072 +1073 +1074 +185 +1075 +1076 +57 +1077 +179 +1078 +1079 +703 +14 +1080 +1081 +491 +1082 +57 +1083 +1084 +1085 +1086 +1087 +1088 +788 +1089 +17 +1090 +1091 +1092 +1093 +1094 +692 +1095 +43 +1096 +180 +9 +19 +1097 +57 +14 +1098 +1099 +1100 +1101 +1102 +188 +1103 +1104 +89 +22 +1105 +286 +1106 +1107 +1108 +1109 +658 +1110 +1111 +1112 +1113 +1114 +1115 +57 +33 +1116 +373 +1117 +20 +1118 +32 +959 +179 +1119 +17 +114 +1120 +77 +1121 +1122 +1123 +1124 +1125 +1126 +1127 +1128 +1129 +1130 +713 +57 +60 +671 +109 +1131 +1132 +57 +1133 +1134 +14 +1135 +1136 +1137 +301 +1138 +228 +1139 +249 +1140 +1141 +10 +137 +1142 +927 +1143 +1144 +43 +57 +464 +1145 +1146 +1147 +1148 +1149 +286 +1150 +1151 +1152 +19 +379 +1153 +20 +9 +1154 +32 +200 +1155 +1156 +1157 +16 +222 +1158 +358 +1082 +32 +1159 +1082 +1160 +1161 +1162 +1163 +1164 +1165 +1166 +1167 +1168 +1169 +677 +915 +1170 +1171 +1172 +1173 +1174 +20 +1175 +1176 +15 +1177 +1178 +19 +1179 +1180 +323 +1181 +15 +1182 +1183 +1184 +1185 +1186 +1187 +1188 +1189 +1013 +1190 +237 +1191 +1192 +210 +1193 +4 +658 +1194 +1195 +32 +548 +201 +248 +19 +112 +1196 +1197 +1198 +1199 +323 +1200 +1112 +112 +910 +1201 +286 +707 +1202 +57 +1203 +1204 +317 +1205 +1206 +43 +1207 +15 +303 +1208 +15 +14 +1209 +1021 +1210 +1211 +1212 +43 +1213 +303 +1214 +19 +279 +9 +1215 +1216 +1217 +1218 +1219 +1220 +1221 +1011 +1222 +1105 +32 +1223 +1224 +1225 +1226 +1227 +1228 +1229 +1230 +43 +1231 +284 +1232 +10 +4 +1233 +43 +349 +19 +845 +43 +1234 +1235 +213 +1236 +248 +493 +141 +1237 +1238 +1239 +1240 +1241 +1242 +1243 +1244 +35 +284 +1245 +19 +14 +284 +1246 +1247 +1248 +57 +1249 +1224 +20 +32 +1250 +19 +57 +379 +274 +32 +1251 +337 +1252 +213 +1253 +1254 +1255 +43 +91 +323 +201 +1256 +1257 +1258 +1259 +196 +1260 +1261 +3 +19 +1262 +1263 +15 +20 +48 +1264 +99 +42 +303 +1265 +1266 +1267 +345 +1268 +770 +370 +1269 +1270 +10 +239 +1271 +1272 +15 +1273 +1274 +1275 +1276 +1277 +141 +1278 +1279 +1280 +1281 +849 +1282 +278 +1283 +1284 +464 +373 +1285 +303 +1286 +345 +10 +15 +509 +1287 +1262 +1288 +862 +286 +1289 +1290 +1291 +1292 +809 +514 +1047 +583 +1293 +3 +337 +1294 +201 +484 +1295 +1296 +1297 +1298 +1299 +1300 +237 +1301 +209 +1302 +1303 +872 +1304 +1305 +1306 +4 +1307 +15 +393 +15 +15 +57 +1308 +1309 +1310 +19 +1311 +910 +1312 +1313 +1314 +1315 +322 +20 +1316 +1317 +1318 +1319 +1300 +2 +15 +1320 +10 +699 +1321 +1322 +1323 +1324 +337 +57 +1325 +1326 +1327 +417 +1328 +1329 +32 +1330 +1331 +1021 +286 +1332 +533 +284 +1333 +1334 +1335 +57 +184 +1336 +822 +398 +1337 +1338 +57 +57 +20 +1339 +1340 +1341 +14 +1342 +1300 +1343 +1344 +1345 +155 +15 +1346 +269 +248 +1347 +1348 +2 +1349 +1350 +1048 +1351 +1352 +222 +303 +1353 +1354 +1355 +705 +1356 +1357 +43 +1358 +1359 +1360 +134 +1186 +1361 +1362 +1047 +188 +1363 +164 +1364 +1365 +1366 +32 +1367 +1368 +1369 +2 +22 +1370 +1371 +1372 +358 +842 +1373 +849 +1374 +15 +2 +1375 +1376 +1377 +1378 +1379 +790 +123 +201 +1380 +1381 +1382 +1383 +1384 +1385 +9 +1386 +1387 +1388 +1389 +1390 +9 +155 +1391 +1392 +1393 +1394 +1395 +281 +286 +1396 +1397 +1398 +1399 +1400 +1401 +725 +721 +1402 +1403 +89 +1404 +32 +15 +1405 +1406 +1407 +1408 +1409 +1410 +9 +1411 +317 +46 +1412 +1413 +1414 +1415 +1416 +352 +188 +1417 +1418 +647 +188 +1419 +1420 +1421 +1422 +1423 +43 +1424 +1091 +1425 +1426 +1427 +89 +1428 +1429 +1430 +1431 +77 +43 +1432 +1433 +862 +1434 +1435 +9 +495 +1436 +48 +1437 +1438 +554 +1439 +1440 +32 +971 +1441 +1425 +1442 +1443 +802 +155 +1444 +1445 +1446 +711 +1447 +1448 +57 +1449 +1450 +872 +1451 +1452 +1453 +1454 +1455 +249 +15 +1456 +1457 +1458 +43 +1459 +9 +1460 +1461 +1462 +1463 +1464 +501 +1465 +14 +1466 +1467 +1468 +1469 +1470 +1471 +1472 +1473 +43 +1474 +1475 +1476 +345 +1477 +1478 +1479 +1480 +1481 +1482 +696 +1483 +1484 +1485 +1486 +1487 +32 +1488 +248 +1489 +1490 +1491 +1492 +849 +1493 +228 +1494 +1495 +48 +17 +1496 +19 +286 +1497 +1498 +1499 +1500 +1501 +1502 +111 +10 +1503 +1504 +1384 +1505 +1506 +1507 +1508 +284 +1509 +1510 +331 +1511 +1512 +1396 +213 +32 +1513 +1514 +1515 +248 +1516 +4 +1517 +337 +1518 +244 +1519 +20 +1520 +1300 +1521 +1522 +1523 +43 +1524 +1525 +1526 +1245 +32 +32 +1527 +1528 +43 +597 +1465 +1465 +1364 +1529 +1530 +1531 +1437 +554 +188 +1532 +43 +1533 +958 +1534 +317 +1535 +1536 +1537 +1538 +528 +1384 +1539 +1540 +1541 +1542 +22 +597 +1543 +14 +1544 +19 +19 +1245 +1545 +1546 +1547 +1548 +1444 +1082 +14 +1549 +19 +70 +10 +1550 +57 +178 +1551 +1552 +1553 +1554 +1555 +15 +1556 +1557 +1558 +188 +845 +1559 +1560 +1561 +1562 +1563 +1564 +398 +1565 +1566 +1567 +178 +1568 +25 +9 +1077 +1021 +43 +1569 +1570 +1571 +1572 +1573 +989 +1212 +245 +1574 +1575 +1576 +286 +1577 +1578 +828 +1579 +1580 +1574 +9 +1581 +648 +237 +179 +1582 +1425 +193 +1583 +1584 +1234 +1569 +57 +1585 +1586 +713 +1587 +1588 +1224 +20 +1589 +138 +845 +1590 +1591 +1592 +1593 +43 +1594 +658 +1595 +1011 +1596 +1597 +1598 +1599 +15 +1600 +1601 +1149 +1602 +1603 +1604 +1605 +1606 +1607 +1608 +1609 +57 +178 +1610 +1251 +43 +1042 +738 +1611 +9 +1612 +1613 +1614 +43 +1615 +1580 +1452 +1616 +1617 +286 +1618 +1619 +1620 +1621 +1622 +1623 +1624 +1625 +842 +349 +1626 +213 +966 +1627 +822 +1628 +1629 +1630 +1631 +201 +1632 +1633 +1634 +1635 +1636 +1637 +19 +1638 +57 +12 +2 +178 +1639 +16 +15 +1640 +57 +1641 +1642 +1643 +1644 +1645 +1646 +303 +1647 +1648 +936 +19 +1649 +1650 +1651 +317 +1652 +213 +349 +1653 +365 +1654 +1655 +436 +1376 +1656 +1657 +1658 +1659 +1660 +1661 +1662 +38 +34 +14 +1663 +1664 +248 +1665 +32 +1666 +19 +1667 +284 +1668 +1669 +1670 +1671 +48 +1672 +57 +286 +1673 +274 +1674 +1675 +20 +1596 +1676 +57 +1677 +1678 +1679 +1680 +1681 +703 +1682 +1683 +213 +1684 +1685 +1686 +442 +43 +1220 +373 +1687 +1688 +1689 +1690 +1691 +1692 +1217 +379 +597 +15 +1693 +43 +1694 +248 +1262 +446 +48 +15 +536 +586 +402 +1695 +1696 +1697 +337 +1698 +22 +1699 +115 +1700 +1701 +1702 +1703 +1704 +20 +491 +1705 +1107 +1706 +34 +1707 +1708 +1149 +1709 +15 +1710 +1711 +1712 +1713 +57 +15 +1714 +1715 +14 +284 +1454 +764 +1716 +2 +1717 +1718 +1719 +358 +1720 +1721 +1722 +1723 +1724 +1425 +1725 +1726 +19 +43 +1727 +14 +1728 +1524 +586 +528 +305 +703 +1729 +1730 +337 +1731 +1732 +795 +1733 +1734 +1735 +1736 +286 +1737 +1738 +179 +1739 +152 +1740 +1741 +1742 +20 +1743 +1744 +1745 +1746 +1425 +654 +1747 +648 +495 +1112 +1748 +1749 +10 +1750 +1751 +1752 +1753 +201 +1754 +430 +1755 +1756 +1757 +2 +790 +15 +1758 +48 +1759 +1760 +1761 +1762 +114 +872 +1763 +1764 +201 +416 +1765 +1317 +1766 +1767 +936 +1768 +1769 +1770 +1771 +1772 +1773 +1774 +1234 +1775 +981 +1776 +1777 +1778 +1779 +1780 +1781 +1782 +1783 +1310 +665 +1784 +1785 +15 +1786 +1787 +345 +358 +1788 +29 +1789 +317 +43 +15 +9 +1790 +491 +1791 +415 +1792 +316 +9 +566 +1793 +43 +188 +1794 +1243 +1743 +1795 +155 +1796 +554 +1797 +208 +1798 +514 +1799 +32 +1800 +1801 +1802 +741 +1803 +1804 +1805 +201 +1806 +1807 +1808 +1809 +1300 +1810 +1100 +1811 +442 +1812 +1813 +276 +286 +32 +19 +1425 +1814 +354 +201 +1815 +237 +1816 +1817 +43 +1818 +19 +323 +34 +1819 +1820 +1821 +1822 +1823 +1824 +1825 +36 +1826 +1827 +1828 +1829 +1830 +1823 +1831 +1832 +1833 +1834 +201 +1835 +1836 +142 +1837 +1838 +1839 +1840 +1841 +411 +411 +1842 +1843 +1844 +1845 +369 +1300 +1846 +1847 +357 +1848 +586 +1849 +1850 +1851 +1852 +1853 +1854 +1855 +1856 +1857 +1858 +1859 +15 +1860 +1861 +1862 +1863 +1864 +284 +16 +1865 +1866 +1867 +1868 +1869 +1465 +1870 +1871 +1872 +15 +1873 +1874 +1875 +1876 +1877 +1878 +1879 +1880 +822 +1881 +14 +286 +14 +9 +1882 +1883 +1884 +1885 +14 +1886 +77 +3 +1887 +1888 +286 +14 +1889 +1890 +1100 +1891 +14 +1892 +1893 +1894 +15 +1895 +1896 +554 +43 +1897 +1010 +48 +1898 +708 +1899 +1208 +43 +1900 +1169 +1100 +1901 +1902 +1903 +299 +53 +66 +15 +1904 +1905 +1906 +1907 +1908 +16 +1909 +10 +1910 +671 +1369 +1465 +1911 +1912 +1913 +1655 +1914 +1915 +1916 +104 +1083 +1917 +213 +4 +1918 +1287 +1919 +213 +1920 +39 +1921 +1922 +1923 +43 +201 +1924 +1925 +1926 +43 +43 +1927 +1928 +112 +1929 +1930 +358 +1931 +248 +1932 +1933 +1934 +354 +694 +1907 +1935 +9 +213 +1936 +1937 +1938 +1939 +1940 +20 +178 +1941 +32 +20 +1942 +43 +1943 +1944 +35 +43 +1945 +286 +1946 +276 +1947 +1948 +1949 +1950 +19 +1951 +284 +1952 +14 +337 +1524 +1953 +713 +1513 +1954 +248 +284 +1149 +1955 +1956 +201 +1957 +1958 +1959 +43 +53 +1960 +1961 +1962 +1963 +1091 +1964 +303 +1965 +1966 +1863 +2 +1967 +1968 +1969 +354 +1970 +1971 +99 +1021 +1972 +665 +284 +1973 +1386 +286 +337 +1974 +1975 +1976 +1977 +1978 +1979 +269 +9 +1980 +1981 +337 +32 +1982 +1983 +1984 +713 +1985 +1986 +99 +176 +19 +910 +597 +303 +303 +1987 +1988 +1989 +1990 +32 +1991 +1992 +303 +213 +201 +1993 +237 +1994 +1995 +492 +1996 +155 +761 +1997 +1998 +1999 +2000 +2001 +2002 +2003 +2004 +2005 +2006 +2007 +2008 +2009 +1566 +1224 +1234 +99 +2010 +22 +2011 +936 +2012 +2013 +2014 +2015 +2016 +2017 +590 +2018 +2019 +2020 +15 +43 +2021 +415 +2022 +576 +10 +15 +1543 +48 +2023 +2024 +1684 +2025 +2026 +2027 +2028 +2029 +284 +2030 +248 +2031 +2032 +2033 +2034 +2035 +43 +2036 +2037 +2038 +2039 +2040 +57 +2041 +2042 +2043 +2044 +713 +188 +2045 +694 +586 +1221 +286 +2046 +2047 +2048 +1502 +2049 +554 +2050 +32 +2051 +249 +916 +2052 +2053 +2054 +38 +43 +2055 +2056 +2057 +910 +2058 +2059 +491 +2060 +2061 +170 +2062 +2063 +22 +2064 +2065 +270 +2066 +2067 +2040 +201 +2068 +32 +1542 +2069 +554 +2070 +19 +2071 +2072 +2073 +2074 +2075 +2076 +845 +2077 +201 +2078 +2079 +15 +2080 +77 +12 +2081 +2082 +2083 +57 +694 +2084 +345 +89 +597 +1047 +2085 +867 +2086 +2087 +2088 +1386 +2089 +14 +2090 +2091 +2092 +201 +2093 +373 +10 +764 +2094 +2095 +2096 +2097 +1584 +46 +2098 +9 +2099 +2100 +286 +89 +2101 +2102 +2103 +2104 +2105 +2106 +2107 +2108 +245 +2109 +179 +597 +2110 +1131 +2111 +25 +2112 +665 +2113 +201 +201 +2114 +2115 +2116 +197 +2117 +2118 +2119 +2120 +80 +2121 +176 +2122 +509 +1502 +2123 +2124 +179 +1502 +1047 +2125 +1698 +2126 +2127 +2128 +43 +2129 +2130 +2131 +2132 +2133 +1585 +2134 +2135 +573 +2136 +2137 +2138 +2139 +536 +2140 +2141 +2142 +647 +222 +2143 +2144 +2145 +2146 +2147 +89 +2148 +176 +2149 +2150 +2151 +22 +2152 +2153 +15 +2154 +286 +76 +2155 +2156 +77 +2157 +1522 +2158 +283 +36 +48 +1415 +178 +19 +1533 +1655 +2159 +2160 +43 +2161 +99 +2162 +2163 +2164 +2165 +1169 +2166 +3 +2167 +25 +2168 +138 +2169 +2170 +43 +1514 +2171 +2172 +188 +2173 +2174 +231 +1234 +2175 +21 +155 +2176 +2177 +2178 +2179 +2180 +2181 +2182 +2183 +2184 +2185 +2186 +2187 +2188 +2189 +2190 +2191 +10 +2192 +43 +2193 +2194 +179 +647 +77 +2009 +99 +2195 +2196 +2197 +19 +2198 +2199 +989 +2200 +238 +2201 +286 +2202 +1019 +2203 +22 +2204 +2205 +2206 +209 +188 +2207 +20 +2208 +2209 +155 +2210 +35 +2211 +2212 +15 +48 +2213 +155 +519 +2214 +2215 +3 +2216 +2217 +14 +1010 +2218 +345 +179 +2219 +2220 +188 +2221 +2222 +1091 +57 +2223 +2224 +2225 +2226 +2227 +2228 +2229 +2230 +2231 +201 +2232 +2233 +286 +2234 +2235 +237 +2236 +155 +292 +2237 +10 +791 +2238 +43 +20 +2239 +2240 +2241 +2242 +2243 +2244 +15 +2245 +196 +201 +379 +77 +2246 +2247 +1169 +16 +2248 +2249 +910 +2250 +2251 +9 +2252 +2253 +2254 +48 +2255 +2256 +1100 +2257 +2258 +2259 +2260 +2261 +2262 +2263 +2264 +2185 +2260 +2265 +2266 +57 +2267 +2268 +2269 +491 +89 +2270 +430 +541 +2271 +222 +616 +2272 +2273 +2274 +2275 +713 +2276 +700 +2277 +2278 +48 +2279 +77 +2280 +2281 +2282 +2283 +2284 +19 +43 +201 +15 +2285 +2286 +2287 +2288 +10 +2289 +616 +2290 +586 +2291 +398 +2292 +2293 +2294 +2295 +48 +2296 +411 +2297 +25 +349 +2298 +2299 +1829 +2300 +14 +15 +2301 +10 +2302 +1245 +2303 +2304 +19 +2305 +29 +2306 +598 +2307 +2308 +2309 +1765 +4 +815 +9 +2310 +345 +228 +741 +2311 +2 +2312 +2313 +19 +32 +2314 +2315 +2316 +1529 +590 +1116 +2317 +2318 +2319 +2320 +2321 +2322 +2 +2323 +2324 +2325 +2326 +2327 +2328 +179 +22 +2329 +2330 +2331 +2332 +2333 +2334 +201 +57 +2335 +1775 +2336 +2337 +188 +25 +2338 +14 +2339 +2340 +2341 +2342 +2343 +2344 +2345 +2346 +2347 +2348 +2349 +2042 +57 +2350 +2351 +2352 +2353 +2354 +2355 +35 +176 +2356 +2357 +155 +2358 +2359 +2360 +369 +20 +2361 +9 +1710 +1203 +369 +34 +2362 +57 +34 +2363 +2364 +2365 +536 +2366 +2367 +694 +2368 +2369 +43 +2370 +910 +2371 +141 +2372 +2373 +43 +2374 +2375 +25 +2376 +2377 +2378 +286 +2379 +2380 +19 +286 +2381 +2382 +2383 +20 +2384 +2385 +2386 +2387 +2388 +57 +2197 +3 +2389 +790 +165 +2390 +2391 +15 +1458 +2341 +741 +201 +710 +1038 +43 +2392 +2393 +2394 +188 +484 +2395 +1012 +2396 +2397 +4 +2398 +2399 +2400 +155 +2401 +2402 +283 +3 +2403 +2404 +2405 +2406 +2407 +2408 +209 +238 +2409 +179 +2410 +2411 +2412 +43 +11 +2413 +2414 +2415 +2416 +2417 +2418 +1082 +9 +2419 +2 +2420 +2421 +2422 +2423 +2424 +2425 +2426 +2427 +1364 +2428 +2429 +14 +2430 +43 +176 +201 +2431 +354 +9 +1049 +35 +2432 +2433 +1680 +57 +2434 +104 +2435 +2 +1765 +2135 +411 +397 +2436 +2437 +2438 +2439 +663 +2440 +1454 +43 +2441 +989 +1508 +32 +2442 +2443 +2281 +283 +564 +2444 +436 +155 +2445 +2446 +283 +188 +2447 +15 +2448 +2449 +1765 +2450 +491 +2451 +2452 +2453 +2454 +2455 +2456 +1710 +15 +1809 +43 +2457 +2458 +20 +2459 +2460 +2461 +14 +2462 +2410 +1385 +2463 +2464 +2465 +1790 +1436 +2466 +2467 +2468 +188 +35 +2140 +2469 +2399 +2470 +14 +2471 +2472 +19 +2473 +2474 +741 +1415 +9 +2475 +2476 +16 +2477 +2478 +34 +43 +2479 +2480 +14 +2481 +57 +10 +14 +2482 +554 +2483 +30 +2484 +416 +828 +1425 +2485 +155 +2486 +2487 +672 +2488 +19 +2489 +1124 +665 +2490 +19 +57 +2491 +2410 +2492 +707 +2493 +60 +249 +495 +286 +738 +2494 +16 +2495 +2496 +2497 +57 +2498 +1683 +2499 +815 +2500 +89 +188 +2501 +1867 +2502 +915 +237 +2503 +597 +2504 +2505 +19 +2506 +2507 +2508 +2509 +2510 +2511 +2512 +2513 +60 +2514 +2515 +19 +10 +2260 +2516 +2517 +2518 +2519 +2520 +2521 +99 +35 +2522 +788 +2523 +2524 +2525 +2526 +2527 +2528 +19 +1212 +2529 +2530 +2531 +2532 +201 +1425 +2533 +2534 +2535 +2536 +2537 +10 +272 +2538 +2539 +2540 +66 +2541 +10 +2122 +2542 +323 +2543 +2544 +48 +2545 +1248 +20 +2546 +2547 +1994 +2548 +2549 +2550 +671 +2551 +2552 +48 +1112 +222 +1175 +48 +2553 +2554 +2555 +1384 +43 +2556 +245 +2557 +2558 +2559 +1013 +2560 +201 +2561 +2562 +15 +15 +2563 +2564 +2565 +2566 +2567 +1901 +2568 +1286 +397 +2569 +2570 +2571 +155 +2572 +2287 +259 +179 +2573 +2574 +2575 +2576 +342 +2577 +2578 +286 +2579 +20 +34 +1559 +32 +2580 +989 +2581 +694 +1134 +2582 +2583 +2584 +2585 +484 +297 +2430 +2586 +2587 +105 +373 +2588 +2589 +3 +15 +2590 +2591 +2592 +2593 +2594 +705 +2595 +2596 +57 +2015 +2597 +2598 +2599 +188 +228 +2600 +2601 +1300 +2602 +2603 +2604 +2605 +2606 +1085 +12 +677 +2607 +1578 +2608 +2609 +2610 +1578 +57 +2611 +2612 +2613 +379 +1502 +2614 +2615 +1013 +493 +2616 +491 +671 +2617 +9 +15 +2618 +2 +2619 +2620 +15 +2 +2621 +2622 +457 +2623 +2624 +43 +14 +2625 +696 +2308 +2626 +2627 +2628 +2629 +137 +1870 +2630 +554 +237 +2631 +2632 +2633 +2634 +2635 +2636 +2637 +2638 +2639 +2640 +1291 +1855 +201 +286 +2641 +38 +2642 +2643 +2644 +57 +2645 +2547 +2646 +2318 +222 +345 +19 +104 +2647 +2648 +369 +2649 +342 +2650 +358 +43 +2651 +2652 +301 +677 +2653 +1047 +2654 +57 +845 +2655 +1107 +2656 +2657 +859 +2658 +2659 +123 +2660 +2661 +2662 +14 +1913 +32 +668 +2430 +2663 +2664 +274 +354 +2665 +1992 +2666 +2667 +2668 +2669 +2670 +180 +2671 +1822 +19 +2672 +2673 +22 +402 +2674 +32 +2675 +201 +2676 +2677 +2678 +2655 +2679 +2680 +138 +2681 +2682 +2121 +9 +2683 +286 +397 +2684 +2685 +2686 +770 +34 +2687 +2688 +1870 +2689 +2690 +2686 +554 +43 +286 +19 +2691 +2692 +2693 +1310 +2694 +2695 +2696 +1051 +2697 +2698 +19 +57 +2699 +791 +2700 +2701 +2702 +2703 +188 +2058 +2704 +317 +2705 +2706 +2707 +193 +484 +2708 +2709 +16 +17 +2710 +2711 +2712 +2713 +2714 +2715 +2716 +2717 +2718 +1437 +2719 +2720 +15 +2721 +2722 +2723 +2724 +2725 +509 +1570 +2726 +2727 +2728 +138 +2729 +16 +1716 +2730 +1513 +1287 +2731 +2732 +2733 +193 +2040 +2734 +2735 +2736 +2737 +910 +2738 +43 +2739 +34 +2740 +14 +2741 +2742 +20 +554 +2743 +2744 +597 +707 +2745 +2746 +721 +2747 +333 +2748 +2749 +2750 +2751 +15 +2752 +2753 +57 +2754 +2755 +2756 +20 +2757 +2758 +7 +2759 +2760 +2761 +2762 +2763 +286 +10 +2764 +3 +2765 +2766 +20 +179 +10 +2767 +3 +15 +2768 +2769 +1013 +2770 +2771 +1710 +2772 +15 +2773 +514 +15 +708 +2774 +19 +1172 +2775 +2776 +286 +19 +32 +2777 +415 +2778 +2779 +15 +1013 +1679 +2780 +983 +590 +379 +2781 +1042 +57 +1529 +2782 +188 +32 +200 +1738 +2783 +2784 +2785 +2786 +2787 +2788 +2789 +188 +2790 +417 +19 +2791 +20 +2792 +1606 +2793 +2794 +1711 +2795 +2796 +1169 +2797 +2798 +2799 +2800 +2801 +2802 +20 +10 +2803 +2804 +568 +2805 +2806 +2314 +1091 +2807 +2808 +2809 +915 +845 +32 +237 +2810 +2811 +80 +590 +2812 +2813 +2259 +2814 +2815 +201 +2816 +2817 +15 +586 +188 +2818 +2819 +43 +197 +2820 +66 +828 +1465 +2821 +2822 +2823 +357 +245 +2 +2824 +43 +2825 +2826 +478 +2827 +2828 +34 +1018 +10 +648 +2829 +2830 +2831 +2832 +39 +358 +43 +2833 +2550 +196 +2834 +4 +57 +2835 +2836 +2837 +2838 +2406 +2728 +2839 +2840 +2841 +22 +20 +2842 +2843 +2844 +2845 +2846 +2847 +1970 +2848 +2849 +228 +67 +1612 +2850 +2851 +2852 +98 +2853 +2854 +2414 +2855 +43 +2856 +2857 +2858 +2859 +2860 +2861 +463 +134 +2862 +2694 +201 +1165 +2863 +2864 +2865 +14 +2866 +142 +15 +2 +2867 +2868 +2476 +2869 +1606 +43 +2870 +2871 +2872 +872 +2873 +10 +2874 +583 +14 +19 +2875 +616 +2876 +2877 +15 +15 +2878 +2879 +25 +2880 +2881 +43 +2882 +2883 +48 +2884 +1001 +2885 +9 +9 +2886 +2887 +43 +2888 +2889 +57 +873 +2890 +2891 +2431 +26 +57 +533 +2892 +25 +2893 +533 +2894 +910 +2895 +19 +48 +2896 +2897 +34 +2898 +2526 +286 +2899 +2900 +2762 +19 +533 +2901 +554 +2902 +2903 +2904 +358 +2905 +2906 +2907 +2908 +2909 +2910 +249 +2911 +2912 +1924 +2913 +2092 +2914 +99 +2915 +665 +1066 +2253 +43 +2916 +57 +2917 +196 +2918 +2919 +2920 +2921 +2922 +123 +2923 +16 +237 +75 +284 +2924 +15 +2925 +2926 +237 +33 +2927 +2928 +20 +2929 +2930 +2931 +2932 +299 +721 +440 +1711 +213 +15 +20 +2933 +2934 +2935 +2936 +2937 +213 +303 +9 +2551 +2938 +303 +2939 +2940 +845 +286 +57 +89 +2941 +2942 +2943 +2944 +2945 +2946 +554 +2947 +284 +373 +2948 +2949 +2950 +533 +2951 +2260 +2952 +531 +2953 +2954 +575 +201 +2955 +1116 +213 +2956 +2957 +48 +286 +2958 +20 +2959 +269 +15 +2960 +1710 +1051 +2961 +19 +43 +2962 +43 +2963 +2964 +322 +140 +2965 +2966 +2967 +2968 +2 +2969 +491 +1384 +2970 +2971 +155 +2972 +15 +1425 +15 +2577 +2973 +2974 +14 +2975 +2976 +76 +658 +2977 +2978 +2979 +2980 +509 +2981 +2439 +337 +2982 +25 +57 +2983 +2984 +2985 +2986 +48 +15 +2987 +2988 +170 +3 +19 +2989 +2990 +349 +19 +22 +2525 +9 +43 +317 +788 +665 +32 +2991 +2992 +2993 +2994 +2995 +2996 +484 +2997 +2998 +2999 +3000 +3001 +3002 +67 +3003 +3 +43 +1013 +3004 +15 +248 +3005 +3006 +125 +337 +57 +3007 +3008 +3009 +2561 +3010 +3011 +96 +3012 +3013 +43 +514 +3014 +3015 +3016 +713 +3017 +3018 +3019 +936 +57 +78 +3020 +14 +3021 +1287 +3022 +137 +2764 +3023 +3024 +3025 +1605 +3026 +25 +3027 +15 +554 +43 +3028 +3029 +541 +1224 +3030 +22 +3031 +9 +3032 +663 +3033 +1051 +3034 +1612 +3035 +155 +399 +3036 +1861 +3037 +3038 +3039 +3040 +20 +43 +3041 +32 +3042 +14 +3043 +99 +15 +484 +3044 +3045 +165 +3046 +3047 +3048 +3049 +3050 +237 +3051 +3052 +3053 +3054 +3055 +3056 +3057 +3058 +3059 +3060 +2865 +3061 +57 +3062 +3063 +53 +3064 +399 +3065 +3066 +845 +417 +3067 +3068 +3069 +425 +3070 +3071 +491 +3072 +3073 +2260 +3074 +3075 +3076 +32 +19 +436 +22 +3077 +3078 +14 +3079 +3080 +3081 +3082 +3083 +3084 +57 +3085 +3086 +3087 +3088 +3089 +910 +3090 +3091 +411 +3092 +1245 +3093 +1470 +342 +1604 +3094 +3095 +1612 +3096 +60 +3097 +19 +3098 +3099 +32 +3100 +19 +3101 +3102 +3103 +32 +1172 +3104 +2 +3105 +3106 +270 +2537 +4 +3107 +3108 +20 +3109 +3110 +24 +57 +3111 +1808 +3112 +337 +3113 +480 +32 +3114 +3115 +3116 +3117 +3118 +554 +3119 +3120 +3121 +3122 +3123 +2926 +19 +3003 +19 +3124 +3125 +3126 +3127 +1437 +694 +3128 +3129 +3130 +3131 +2061 +398 +43 +3132 +3133 +3134 +741 +741 +3135 +3136 +3137 +248 +2471 +1513 +3138 +3139 +9 +3140 +3141 +3142 +3143 +3144 +3145 +2402 +2259 +2591 +3146 +3147 +3148 +1792 +3149 +3150 +3151 +3152 +3153 +3154 +3155 +3156 +3157 +3158 +3159 +286 +2769 +3160 +114 +3161 +3162 +3163 +32 +3164 +286 +16 +104 +711 +3165 +1232 +3166 +14 +745 +3167 +777 +3168 +43 +3169 +1668 +32 +125 +165 +3170 +3171 +3172 +3173 +10 +213 +3174 +43 +201 +3175 +3176 +179 +1047 +284 +3177 +3178 +3179 +22 +3180 +3181 +15 +213 +57 +3182 +16 +345 +3183 +3184 +2 +3185 +3186 +519 +66 +197 +3187 +3188 +3189 +104 +3190 +3191 +86 +3192 +3193 +2672 +286 +3194 +3195 +2835 +57 +3196 +337 +3197 +648 +3198 +10 +3199 +3200 +15 +337 +303 +228 +180 +3201 +32 +3202 +3203 +345 +3204 +3205 +1889 +915 +3206 +213 +337 +1401 +3207 +3208 +32 +3209 +3210 +3211 +248 +286 +2410 +1010 +3212 +3213 +3214 +3215 +3216 +32 +3217 +337 +3218 +3219 +3220 +3221 +3222 +337 +337 +2616 +849 +3223 +57 +3224 +317 +15 +293 +3225 +3226 +3227 +248 +3228 +3229 +3230 +915 +1091 +3231 +3232 +9 +1364 +3233 +43 +3234 +3235 +3236 +3237 +38 +1352 +3238 +3239 +3240 +3241 +3242 +3243 +3244 +43 +770 +22 +3245 +3246 +303 +303 +3247 +3248 +3249 +3250 +2728 +3251 +9 +17 +32 +2314 +3252 +3253 +3254 +3255 +3256 +2260 +19 +43 +349 +178 +1465 +337 +138 +3257 +3258 +12 +1364 +1224 +1604 +286 +188 +15 +478 +15 +379 +15 +20 +3259 +15 +3260 +3261 +3262 +3263 +491 +165 +1021 +3264 +3265 +3266 +3267 +3268 +188 +3269 +57 +3270 +3271 +3272 +3273 +3274 +297 +20 +3275 +2 +3276 +3277 +3278 +377 +15 +2129 +3279 +3280 +3281 +4 +270 +3282 +3283 +3284 +32 +1637 +1710 +3285 +2978 +3286 +89 +3287 +3288 +3287 +3289 +3290 +3291 +648 +3292 +3293 +3294 +20 +1961 +48 +3295 +188 +3296 +3297 +3298 +3299 +22 +201 +3300 +3301 +764 +3302 +3303 +3304 +3305 +3306 +2316 +1513 +540 +237 +3307 +583 +3308 +196 +15 +3309 +3310 +89 +89 +89 +104 +2035 +3311 +3312 +3313 +3314 +3315 +3178 +209 +3316 +272 +3317 +509 +3318 +3319 +3320 +764 +3321 +286 +43 +3322 +20 +3323 +15 +3324 +3325 +3326 +3327 +2546 +201 +358 +155 +3328 +554 +3329 +3330 +3331 +43 +3332 +3333 +1655 +1181 +3334 +1615 +3335 +155 +2129 +3336 +3337 +3338 +3339 +671 +3340 +1172 +3341 +142 +48 +3342 +3343 +3344 +3317 +2764 +3345 +3346 +3347 +910 +29 +3348 +3349 +3350 +3351 +3352 +3353 +3354 +3287 +99 +3355 +3356 +3357 +495 +861 +3358 +3359 +77 +3360 +15 +3361 +15 +3362 +2325 +3363 +3364 +379 +10 +3365 +354 +3366 +3367 +3368 +286 +32 +3369 +9 +3370 +1364 +3371 +665 +3372 +286 +142 +14 +3373 +3374 +3375 +99 +3376 +1547 +3377 +1529 +3378 +687 +491 +3379 +3380 +3381 +665 +373 +3382 +249 +3383 +3384 +19 +3385 +3386 +3387 +3388 +3389 +1502 +3390 +3391 +3392 +3393 +931 +22 +3394 +3395 +3396 +286 +2260 +3397 +373 +43 +3398 +3399 +3400 +3401 +15 +22 +1234 +3402 +3403 +943 +2896 +3404 +3405 +3406 +32 +354 +1790 +3407 +3408 +3054 +457 +3409 +3410 +345 +3050 +53 +738 +15 +3411 +3412 +3413 +3414 +2122 +345 +3415 +3416 +25 +3417 +213 +43 +3418 +3419 +3420 +3421 +14 +936 +3422 +3423 +3424 +3425 +3426 +38 +3427 +1508 +3428 +25 +713 +15 +3429 +57 +3430 +20 +3431 +3432 +3433 +14 +3434 +3435 +43 +3436 +3437 +745 +916 +700 +3438 +3439 +3440 +3441 +3442 +3443 +3444 +3445 +2804 +3446 +3447 +3448 +20 +815 +10 +19 +286 +3449 +3450 +3451 +3452 +213 +3453 +764 +57 +3454 +3455 +3456 +284 +3457 +57 +3458 +3459 +386 +248 +3460 +3461 +3462 +10 +3463 +379 +3464 +519 +3465 +3466 +22 +3467 +3468 +3469 +3470 +43 +3471 +3472 +3473 +3310 +12 +3474 +155 +3475 +694 +354 +2015 +3476 +14 +3477 +3478 +3247 +3479 +596 +303 +337 +683 +3480 +3481 +3482 +3483 +3484 +528 +48 +671 +3485 +554 +286 +610 +16 +178 +3486 +1514 +3487 +3488 +3489 +3490 +3491 +1066 +249 +3492 +3493 +3494 +9 +19 +43 +3495 +9 +665 +554 +3496 +3497 +32 +1502 +3498 +43 +3499 +248 +915 +3500 +3501 +3502 +248 +354 +3503 +1423 +248 +3504 +3505 +16 +3506 +3507 +19 +791 +3508 +185 +3509 +3510 +19 +337 +1976 +248 +2195 +1091 +303 +3511 +597 +3512 +2768 +1900 +3513 +3514 +3515 +3516 +3517 +109 +2601 +1585 +3518 +3519 +3520 +20 +20 +44 +66 +3521 +3522 +3523 +3524 +3525 +3526 +3527 +3528 +15 +2260 +3529 +3530 +3531 +1208 +1559 +3532 +3533 +791 +573 +16 +3534 +19 +3535 +3536 +19 +1907 +43 +209 +2019 +2489 +3537 +586 +3538 +15 +3539 +3540 +3541 +3542 +34 +3543 +3544 +15 +3545 +3546 +3547 +43 +3548 +554 +3549 +3550 +3551 +3552 +3553 +3554 +237 +109 +15 +791 +32 +43 +345 +3555 +1630 +248 +3556 +3557 +3558 +3559 +3560 +1716 +57 +1847 +484 +1927 +22 +2762 +3561 +415 +48 +15 +3562 +188 +48 +196 +3317 +3563 +3564 +3565 +3566 +32 +3567 +32 +694 +3568 +861 +3569 +554 +2029 +201 +1508 +3570 +188 +3571 +201 +1091 +3572 +180 +3573 +3287 +286 +3574 +736 +1149 +3575 +3576 +3577 +29 +172 +3578 +3579 +43 +3580 +3581 +3582 +3583 +20 +3584 +3585 +373 +43 +3586 +32 +1013 +3587 +32 +3588 +3589 +3590 +3591 +3592 +3593 +14 +1436 +3594 +3595 +210 +3330 +29 +3596 +9 +398 +430 +3597 +1529 +3598 +15 +3599 +3600 +2896 +3601 +19 +3602 +3603 +3604 +3605 +43 +57 +3606 +3607 +3608 +3609 +201 +3610 +3611 +3612 +1452 +3613 +3307 +3614 +3615 +3616 +57 +14 +1559 +1300 +3617 +178 +3618 +3619 +3620 +3621 +3622 +345 +188 +2260 +3623 +3316 +893 +3624 +595 +1524 +3625 +3626 +3627 +3628 +3629 +3630 +3631 +3632 +3633 +1655 +271 +3634 +3635 +3636 +3637 +3638 +48 +2 +15 +89 +491 +3353 +3639 +3640 +3641 +3642 +22 +3643 +1637 +3644 +279 +34 +2993 +3645 +560 +3646 +25 +3647 +1160 +15 +1019 +1531 +3648 +3649 +22 +3650 +3651 +3652 +3653 +3654 +3655 +3656 +19 +3657 +915 +3658 +323 +3659 +3660 +3661 +3662 +3663 +15 +43 +3664 +3665 +19 +20 +3666 +3667 +379 +3668 +3669 +237 +910 +3670 +3671 +3672 +3673 +3674 +3675 +3676 +3677 +3678 +3679 +3680 +3681 +32 +77 +3682 +57 +14 +3683 +3684 +3685 +3686 +2459 +3687 +3688 +15 +3689 +3690 +1817 +586 +3691 +3692 +1249 +3043 +185 +43 +3693 +57 +22 +3694 +99 +3695 +3696 +178 +15 +19 +3697 +3698 +595 +3699 +1149 +533 +3700 +3701 +3702 +188 +1688 +1508 +3703 +9 +57 +3704 +9 +77 +3705 +1961 +57 +3061 +3706 +1249 +317 +370 +3707 +4 +15 +43 +1015 +3708 +713 +43 +20 +3709 +43 +3710 +3711 +3712 +2314 +3713 +3714 +3715 +3716 +411 +112 +3717 +2289 +323 +3718 +3719 +3720 +3721 +345 +2721 +3722 +3723 +3724 +3725 +2764 +22 +3726 +15 +3727 +292 +3728 +3729 +32 +3730 +3731 +3732 +3733 +3734 +914 +3735 +3736 +2 +9 +3737 +3738 +2 +3739 +3740 +703 +528 +440 +1232 +3741 +1563 +3742 +484 +3743 +3744 +3745 +1559 +1364 +3746 +411 +20 +3747 +3748 +25 +3749 +3750 +566 +2728 +15 +3751 +15 +10 +357 +882 +3752 +178 +46 +3525 +3753 +2260 +3754 +1521 +3755 +20 +3756 +15 +2 +3 +19 +22 +112 +3757 +3758 +3759 +249 +2903 +2764 +3760 +3761 +3762 +694 +303 +3763 +155 +3764 +3765 +16 +3766 +3767 +3768 +3769 +3770 +3771 +15 +303 +3772 +15 +586 +57 +3773 +3003 +3774 +3775 +3776 +228 +3777 +1513 +4 +3778 +2 +3779 +3780 +337 +19 +284 +1889 +3781 +284 +248 +3782 +1021 +3783 +3784 +286 +9 +3785 +3786 +736 +2314 +3787 +464 +15 +3788 +20 +3789 +3790 +34 +43 +213 +337 +3791 +3792 +3793 +303 +3794 +3795 +1817 +3796 +358 +3797 +248 +188 +3798 +3799 +337 +3800 +19 +3801 +3802 +337 +20 +1354 +3803 +1817 +1765 +213 +1234 +3804 +1172 +3805 +1051 +337 +3806 +2410 +3807 +3808 +1013 +2009 +3809 +1682 +3810 +3811 +1468 +213 +43 +3812 +3813 +484 +3814 +10 +597 +3815 +3816 +3817 +337 +3818 +3819 +1833 +188 +3820 +809 +228 +415 +32 +2882 +3821 +1961 +791 +142 +2260 +597 +3822 +3 +3823 +2 +3824 +595 +3825 +14 +89 +3826 +3827 +751 +486 +3828 +3829 +3830 +2202 +3831 +3 +3832 +2035 +3833 +43 +915 +436 +3834 +317 +3835 +337 +1604 +155 +115 +379 +3836 +3837 +3838 +3839 +3840 +3841 +43 +3842 +2064 +3843 +3732 +3844 +3845 +15 +3846 +3847 +3848 +1889 +3849 +1291 +3850 +115 +3851 +3852 +155 +3853 +3854 +3855 +14 +48 +104 +3856 +3857 +3858 +3859 +152 +3860 +2042 +3861 +3862 +2439 +3863 +3864 +2465 +3865 +3866 +3867 +3868 +3869 +3870 +3871 +10 +3872 +1696 +42 +3873 +3546 +3874 +3875 +3876 +3790 +3877 +386 +3878 +286 +3879 +15 +3880 +3881 +3882 +3883 +57 +3884 +19 +495 +509 +3885 +20 +25 +155 +554 +3886 +9 +3887 +3888 +32 +1765 +15 +57 +3889 +3890 +20 +3891 +3476 +57 +20 +213 +1425 +3553 +179 +155 +3892 +271 +3893 +3894 +15 +3895 +3896 +15 +15 +3897 +46 +3898 +3899 +845 +3900 +1927 +22 +3901 +3902 +15 +15 +43 +1083 +3903 +3904 +76 +1655 +3905 +3484 +3906 +827 +3907 +3908 +1710 +3909 +3910 +3911 +3912 +1234 +3913 +3914 +3915 +57 +57 +3916 +1245 +3917 +736 +155 +1096 +3918 +179 +3919 +3920 +3921 +493 +3922 +3923 +1415 +3924 +3925 +3926 +2769 +43 +201 +3927 +48 +3928 +3929 +284 +3930 +1655 +3931 +3932 +3933 +3934 +3935 +3936 +3937 +19 +3938 +3939 +20 +1502 +345 +3940 +20 +3941 +272 +3942 +3943 +484 +283 +3944 +1051 +1115 +3945 +598 +3946 +3947 +3948 +123 +222 +3949 +3950 +3951 +3952 +3953 +3954 +3955 +3956 +12 +3957 +248 +19 +15 +665 +3958 +3959 +3960 +3961 +3962 +248 +2 +1128 +3963 +1864 +3964 +3965 +284 +3966 +3967 +1806 +39 +3968 +3969 +3970 +3971 +1559 +1401 +3972 +12 +43 +3973 +1047 +3974 +3975 +3976 +3654 +3977 +3978 +3979 +32 +3980 +3981 +213 +337 +720 +806 +213 +14 +3982 +284 +3983 +3984 +3985 +286 +284 +3986 +3987 +3988 +213 +3989 +1668 +3990 +3991 +3992 +248 +1234 +955 +15 +3993 +270 +352 +3994 +3995 +1889 +4 +3996 +1499 +3997 +19 +3998 +3999 +237 +4000 +4001 +25 +4002 +4003 +4004 +283 +248 +1217 +34 +4005 +137 +2581 +176 +4006 +19 +4007 +845 +89 +2463 +337 +1529 +4008 +4009 +373 +4010 +1386 +4011 +4012 +4013 +188 +4014 +303 +2500 +337 +349 +303 +586 +4015 +10 +4016 +379 +4017 +337 +4018 +882 +213 +519 +4019 +77 +32 +20 +1942 +386 +4020 +180 +12 +2140 +845 +4021 +4022 +3745 +4023 +4024 +4025 +2593 +180 +4026 +4027 +4028 +20 +1234 +1291 +4029 +155 +4030 +34 +303 +4031 +4032 +32 +4033 +14 +4034 +19 +4035 +70 +4036 +43 +137 +155 +9 +4037 +25 +272 +4038 +4039 +3351 +4040 +57 +4041 +4042 +4043 +4044 +4045 +4046 +2721 +4047 +4048 +9 +4049 +9 +2 +1817 +137 +286 +4050 +590 +4051 +2924 +3959 +4052 +99 +1961 +286 +4053 +57 +4054 +4055 +4056 +4057 +4058 +4059 +4060 +4061 +142 +43 +188 +1710 +4062 +15 +4063 +1018 +57 +38 +4064 +4065 +89 +4066 +861 +4067 +4068 +19 +4069 +4070 +4071 +53 +4072 +1800 +3317 +4073 +4074 +299 +4075 +4076 +2347 +4077 +248 +43 +4078 +1710 +1604 +721 +4079 +4080 +2012 +4081 +4082 +12 +4083 +4084 +4085 +4086 +32 +4087 +4088 +4089 +57 +4090 +188 +4091 +4092 +1637 +4093 +4094 +4095 +4096 +4097 +283 +4098 +519 +597 +3310 +9 +4099 +4100 +4101 +43 +4102 +4103 +22 +4104 +4105 +19 +4106 +4107 +4108 +1100 +4109 +915 +4110 +4111 +597 +2471 +4112 +43 +16 +4113 +60 +4114 +4115 +4116 +188 +1048 +20 +4117 +4118 +4119 +305 +4120 +4121 +4122 +4123 +1502 +16 +14 +716 +4124 +4125 +4126 +1655 +4127 +1292 +4128 +20 +4129 +671 +286 +1749 +2019 +12 +4130 +4131 +4132 +4133 +2157 +4134 +317 +4135 +4136 +4137 +415 +4138 +4139 +809 +317 +9 +25 +4140 +4141 +286 +4142 +915 +4143 +4144 +4145 +4146 +4147 +4148 +4149 +70 +4150 +4151 +4152 +43 +4153 +4154 +4155 +4156 +764 +1021 +411 +14 +4157 +286 +4158 +4159 +4160 +4161 +446 +4162 +4163 +4164 +15 +4165 +3003 +4166 +4167 +4168 +4169 +4170 +1698 +4171 +4172 +15 +4173 +19 +4174 +200 +4175 +4176 +4177 +44 +4178 +279 +4179 +15 +4180 +1655 +4181 +20 +2347 +4182 +4183 +942 +19 +4184 +4185 +4186 +4187 +4188 +4189 +4190 +57 +66 +4191 +1513 +317 +707 +4192 +4193 +815 +4194 +4 +1223 +4195 +19 +4196 +4197 +188 +4198 +112 +4199 +9 +4200 +22 +19 +43 +43 +1559 +4201 +286 +155 +4202 +4203 +9 +4204 +4205 +4206 +1710 +415 +208 +4207 +4208 +196 +1224 +4209 +3711 +141 +668 +4210 +4211 +4212 +4213 +1606 +4214 +4215 +43 +4216 +4217 +48 +3376 +1228 +4218 +77 +4219 +20 +4220 +4221 +4222 +354 +43 +4223 +178 +4224 +15 +20 +15 +4225 +15 +4226 +1900 +2043 +197 +4227 +4228 +4229 +20 +19 +4230 +369 +2061 +4231 +46 +4232 +561 +4233 +39 +188 +3790 +77 +4234 +286 +4235 +43 +14 +4236 +4237 +317 +4238 +4239 +4240 +597 +4241 +4242 +1011 +4243 +2762 +4244 +4245 +4246 +4247 +4248 +2330 +4249 +188 +213 +32 +379 +4250 +4251 +20 +284 +3055 +19 +4252 +20 +4253 +4254 +4255 +4256 +4257 +4258 +4259 +32 +3350 +4028 +4260 +4261 +145 +15 +4262 +4263 +1291 +4264 +337 +971 +32 +1961 +4265 +4266 +741 +4267 +1513 +4268 +238 +686 +4269 +4270 +2577 +213 +249 +1112 +4271 +694 +4272 +1889 +4273 +4274 +2043 +57 +4275 +4276 +4277 +4278 +4279 +4280 +3059 +66 +1015 +2039 +178 +337 +665 +237 +25 +2804 +4281 +303 +57 +60 +4282 +2476 +484 +4283 +25 +337 +4284 +237 +4285 +43 +1889 +3417 +4286 +4287 +179 +4288 +4289 +4290 +687 +19 +4291 +2855 +554 +4292 +4293 +20 +188 +1234 +4294 +20 +4295 +1220 +3406 +1364 +4139 +4296 +4297 +4298 +43 +201 +4299 +1955 +4300 +2982 +648 +4301 +188 +4302 +4 +170 +4303 +4304 +4305 +4306 +4307 +284 +35 +3055 +4308 +533 +4309 +4310 +1415 +4311 +286 +34 +4312 +379 +4313 +536 +1374 +1562 +303 +707 +4314 +554 +4315 +4316 +4317 +43 +4318 +15 +4319 +2195 +4320 +4321 +4322 +4323 +4324 +1244 +4325 +4326 +4327 +4328 +4329 +4330 +1508 +915 +4 +2764 +4331 +4332 +4333 +4334 +4335 +4336 +43 +736 +4337 +4338 +179 +317 +1149 +736 +4339 +4340 +4341 +4342 +4343 +416 +4344 +43 +19 +1673 +4345 +4346 +4347 +354 +4348 +4349 +4350 +4351 +2764 +4352 +180 +4353 +4354 +4355 +4 +286 +43 +286 +4356 +317 +4357 +4358 +4359 +3 +43 +15 +971 +20 +4360 +1018 +12 +4361 +4362 +14 +4363 +3553 +4364 +269 +554 +3055 +4346 +4365 +15 +57 +4366 +4180 +4367 +4368 +861 +176 +179 +114 +3 +4369 +4370 +188 +57 +4371 +4372 +4373 +4374 +4375 +2797 +2577 +4344 +4376 +1042 +1425 +201 +4377 +4378 +4379 +29 +4380 +4381 +19 +4382 +4383 +155 +1559 +586 +484 +4384 +4385 +4386 +4387 +1879 +4280 +4388 +4389 +15 +3543 +1384 +57 +4 +4390 +4391 +1559 +14 +174 +4392 +4393 +4394 +1870 +201 +4395 +4396 +4397 +4398 +554 +3300 +849 +4399 +4400 +4401 +19 +4402 +9 +4403 +2026 +586 +4404 +4405 +1533 +416 +4406 +4407 +4408 +4409 +4410 +4411 +9 +4 +4412 +4413 +270 +15 +4414 +2782 +4415 +4416 +4417 +39 +4418 +1234 +4419 +2164 +4420 +4421 +1481 +4422 +1710 +2040 +4423 +4424 +4425 +2060 +4426 +4427 +4428 +70 +4429 +2166 +4430 +4431 +2836 +4432 +4433 +4434 +4435 +1559 +4436 +33 +1851 +4437 +1605 +34 +15 +4438 +19 +1688 +4439 +1992 +249 +89 +4440 +57 +4441 +4442 +4443 +4444 +2836 +10 +14 +57 +4445 +176 +4446 +48 +57 +4447 +4448 +176 +4449 +4450 +915 +411 +4451 +4452 +59 +4453 +4454 +4455 +4456 +19 +4457 +3256 +4458 +4459 +4460 +43 +4461 +4462 +29 +2619 +4463 +2260 +1531 +57 +484 +4464 +35 +1426 +286 +4465 +43 +4466 +4467 +185 +2683 +4468 +586 +4469 +4470 +4471 +4472 +4473 +4474 +43 +2769 +4475 +43 +4476 +4477 +4478 +286 +4479 +915 +1605 +2 +4480 +20 +4481 +484 +872 +4482 +4483 +20 +141 +15 +3354 +15 +665 +990 +4484 +4485 +4486 +4487 +4488 +345 +43 +4489 +4490 +9 +4491 +1688 +573 +4492 +19 +57 +1120 +4493 +398 +4494 +4495 +4496 +4497 +4498 +4499 +2064 +4500 +4501 +4502 +142 +201 +345 +4503 +43 +4504 +1232 +4505 +4506 +3 +4507 +352 +2804 +349 +4508 +4509 +4510 +2728 +155 +15 +43 +4511 +4033 +4512 +4513 +4514 +4515 +586 +4516 +1716 +4517 +4518 +179 +1149 +48 +4519 +4520 +4521 +2113 +4522 +29 +4523 +165 +4524 +43 +4525 +4526 +4527 +4528 +4529 +43 +4530 +77 +9 +4531 +4532 +1244 +4533 +4534 +4535 +761 +4536 +4537 +140 +4538 +4539 +4540 +155 +4541 +4542 +4543 +4544 +9 +57 +4545 +155 +286 +4546 +4547 +1562 +4548 +4549 +4550 +2485 +4551 +3491 +250 +4552 +4553 +4554 +3003 +4555 +4556 +270 +4557 +282 +4558 +4559 +4560 +4561 +4562 +1768 +22 +4563 +15 +4564 +1834 +3335 +1262 +4565 +4566 +4567 +237 +4568 +4569 +4570 +4571 +4572 +57 +4573 +43 +4574 +345 +4575 +4576 +4577 +4578 +60 +2770 +4579 +4580 +4581 +301 +57 +15 +4582 +4583 +4584 +19 +15 +2347 +1604 +2954 +4585 +815 +4586 +1112 +4587 +4588 +4589 +4590 +14 +317 +53 +4591 +271 +4592 +4116 +4593 +4594 +4595 +17 +1021 +9 +4596 +48 +4597 +15 +4598 +19 +4599 +4600 +1605 +19 +342 +4601 +4602 +2476 +4603 +4317 +1824 +583 +201 +4604 +57 +3 +20 +4605 +4606 +4607 +2795 +402 +57 +916 +3984 +4608 +4609 +43 +4610 +915 +4611 +4612 +745 +57 +4613 +4614 +3061 +4615 +4616 +4617 +1234 +4618 +4619 +4620 +564 +4621 +4622 +4547 +4623 +32 +4624 +3626 +138 +936 +4625 +1710 +4626 +354 +4627 +4628 +379 +57 +4629 +1812 +4630 +4631 +4632 +43 +1689 +4633 +4634 +4635 +15 +4636 +4637 +4638 +4639 +4640 +9 +9 +155 +4641 +915 +4642 +4643 +59 +4644 +4645 +2770 +4646 +942 +2561 +4647 +4648 +32 +4649 +430 +4088 +531 +4650 +4651 +4652 +686 +57 +4653 +155 +4654 +9 +1524 +4655 +4656 +342 +237 +2029 +4657 +4658 +4659 +1880 +4660 +613 +4661 +57 +4662 +4663 +164 +43 +43 +4664 +4665 +694 +4587 +4666 +4667 +4668 +4669 +665 +484 +3958 +4670 +4671 +4672 +4673 +4674 +4675 +2136 +3287 +4676 +4677 +4678 +1668 +2489 +4679 +125 +4680 +4681 +4682 +4683 +57 +4684 +4685 +4686 +259 +665 +586 +4687 +4688 +464 +4689 +4690 +4691 +4692 +4693 +19 +4694 +4695 +4696 +32 +4697 +4698 +4699 +4700 +573 +4701 +249 +213 +1834 +2341 +4702 +45 +493 +665 +284 +32 +4703 +4704 +4705 +1444 +4706 +849 +677 +4707 +35 +153 +4708 +4709 +213 +4710 +4711 +4712 +4713 +4714 +68 +43 +4715 +4716 +4717 +586 +4718 +57 +22 +4719 +4720 +4721 +248 +915 +4722 +809 +15 +213 +4723 +4724 +259 +4725 +14 +1790 +4726 +4727 +4728 +2431 +4729 +2 +4730 +4731 +178 +4732 +4733 +4734 +2009 +19 +4735 +19 +4736 +14 +694 +4737 +1720 +4738 +2739 +4739 +284 +4740 +572 +4741 +317 +9 +4742 +251 +303 +4743 +4744 +4745 +4746 +57 +2619 +303 +4747 +4748 +1300 +19 +845 +4749 +43 +4750 +19 +19 +4751 +345 +4752 +4753 +4754 +201 +4755 +4756 +4757 +77 +286 +48 +4758 +238 +4759 +10 +4760 +3353 +4761 +4762 +4012 +4763 +19 +736 +861 +440 +4764 +1743 +4765 +4766 +1779 +4767 +4768 +43 +4769 +4770 +4771 +4413 +248 +4772 +4773 +764 +4774 +4775 +464 +4776 +2902 +4777 +1090 +222 +4778 +1047 +2591 +694 +32 +15 +845 +354 +4779 +1181 +43 +4780 +4781 +3842 +3 +4782 +286 +4783 +4784 +4785 +303 +2998 +4786 +4787 +4788 +4789 +4790 +4791 +4792 +4793 +4794 +4042 +4795 +4796 +616 +14 +4797 +1116 +4798 +4799 +1529 +4800 +790 +769 +32 +4801 +4802 +4803 +155 +4804 +57 +764 +3745 +4805 +536 +4806 +416 +4807 +4808 +4809 +4810 +3382 +4811 +20 +22 +77 +249 +4812 +2015 +43 +4813 +4814 +1377 +915 +4815 +4816 +57 +1889 +4817 +4818 +4819 +1559 +4820 +9 +4821 +354 +10 +4822 +4823 +357 +137 +4824 +4825 +4826 +4827 +4828 +180 +4829 +32 +4830 +14 +2459 +286 +19 +705 +345 +152 +14 +48 +15 +4831 +4832 +1112 +4833 +19 +19 +764 +648 +4834 +25 +4835 +736 +4836 +32 +491 +554 +4837 +4838 +22 +1543 +4839 +4840 +20 +4841 +4842 +286 +4843 +4844 +3946 +4845 +4846 +4847 +2274 +1234 +4848 +4849 +4850 +4790 +4851 +4852 +741 +4853 +2131 +201 +4854 +4855 +4856 +4857 +379 +4858 +4859 +2668 +4860 +9 +1612 +3601 +4861 +4174 +43 +4862 +4863 +4864 +4865 +464 +590 +791 +4866 +3300 +4867 +4868 +3278 +4869 +4870 +3354 +4871 +4872 +4873 +4874 +4875 +4876 +4877 +4878 +4716 +4879 +140 +101 +4880 +4881 +4882 +4050 +4883 +15 +155 +586 +4803 +4884 +19 +201 +19 +188 +4885 +4886 +1604 +4887 +4888 +4889 +2012 +595 +4890 +15 +4891 +943 +57 +4892 +10 +15 +4893 +4894 +4346 +4895 +4896 +43 +4897 +4898 +4899 +4900 +4901 +2125 +4902 +4903 +4904 +4905 +4906 +4907 +2 +279 +4908 +4909 +19 +665 +677 +176 +1425 +4910 +4911 +2316 +15 +4912 +4913 +4914 +1364 +4915 +4916 +1051 +3353 +349 +77 +286 +1169 +770 +4917 +4918 +20 +201 +4919 +1612 +48 +4920 +4921 +4922 +4923 +4924 +4925 +14 +4926 +22 +4927 +671 +597 +4264 +4928 +4929 +4930 +32 +692 +4931 +4932 +4933 +2009 +4934 +4935 +57 +4936 +4937 +4938 +4939 +1217 +4940 +4941 +14 +4942 +4943 +4944 +4945 +1212 +2113 +4946 +4947 +237 +4948 +915 +4949 +2349 +228 +286 +4950 +1295 +19 +436 +4 +4951 +43 +178 +4952 +22 +4953 +4954 +1124 +4955 +4956 +4957 +176 +1529 +89 +4958 +4959 +4 +4960 +104 +4961 +4624 +4962 +19 +4963 +4964 +4965 +3160 +4966 +4967 +1695 +15 +4968 +43 +4969 +4970 +2260 +3995 +4971 +178 +15 +4972 +1364 +4973 +4974 +1696 +665 +2 +4975 +4976 +4977 +4824 +248 +237 +2260 +19 +4978 +4979 +201 +4980 +1021 +4981 +1533 +4982 +4983 +4984 +4985 +4986 +4987 +4988 +4989 +647 +15 +4990 +4991 +2476 +337 +4992 +4993 +14 +4994 +4995 +4996 +4997 +4998 +4999 +155 +707 +213 +665 +248 +1060 +5000 +1710 +9 +5001 +337 +5002 +5003 +43 +5004 +5005 +2356 +5006 +5007 +5008 +5009 +22 +5010 +2537 +1710 +5011 +5012 +237 +5013 +337 +665 +19 +57 +284 +3743 +5014 +15 +9 +5015 +213 +4406 +5016 +303 +213 +5017 +5018 +5019 +3698 +5020 +3353 +5021 +5022 +5023 +5024 +2668 +5025 +2588 +5026 +5027 +5028 +5029 +22 +115 +15 +845 +5030 +5031 +2619 +19 +5032 +4344 +5033 +15 +188 +5034 +5035 +5036 +14 +43 +2356 +303 +5037 +5038 +9 +5039 +1465 +5040 +915 +1961 +32 +5041 +1531 +303 +5042 +5043 +5044 +43 +5045 +20 +5046 +2316 +32 +5047 +43 +16 +189 +915 +5048 +286 +4716 +342 +57 +57 +5049 +48 +5050 +5051 +5052 +15 +5053 +5054 +20 +5055 +305 +5056 +5057 +14 +4856 +5058 +32 +5059 +2040 +20 +109 +10 +15 +5060 +5061 +15 +178 +5062 +5063 +5064 +5065 +5066 +278 +707 +548 +57 +43 +269 +5067 +5068 +5069 +5070 +1236 +5071 +5072 +4859 +2009 +5073 +32 +1109 +436 +32 +10 +57 +5074 +5075 +1011 +5076 +5077 +2330 +5078 +5079 +5080 +5081 +3743 +3192 +32 +77 +448 +358 +5082 +5083 +5084 +57 +180 +286 +5085 +5086 +5087 +5088 +5089 +15 +5090 +5091 +178 +373 +5092 +358 +57 +57 +19 +317 +57 +201 +5093 +303 +5094 +3816 +738 +20 +5095 +3139 +222 +1109 +1013 +519 +5096 +5097 +5098 +5099 +5100 +5101 +5102 +5103 +5104 +22 +5105 +3544 +48 +25 +5106 +57 +5107 +258 +3408 +5108 +60 +554 +32 +5109 +5110 +1107 +19 +5111 +109 +43 +5112 +5113 +11 +14 +2594 +3480 +2446 +1612 +5114 +155 +276 +4 +57 +358 +3367 +5115 +265 +5116 +201 +5117 +43 +15 +984 +5118 +5119 +861 +2405 +927 +5120 +2694 +5121 +5122 +5123 +2314 +20 +2449 +5124 +3330 +5125 +20 +5126 +5080 +5127 +5128 +5129 +1228 +5130 +2135 +104 +20 +5131 +5132 +5133 +5134 +540 +2064 +4808 +5135 +910 +338 +5136 +5137 +5138 +2040 +5139 +5140 +43 +5141 +303 +416 +5142 +5143 +5144 +5145 +193 +5146 +25 +5147 +5148 +222 +43 +5149 +5150 +5151 +5152 +115 +5153 +5154 +5155 +831 +5156 +936 +5157 +4128 +5158 +5159 +5160 +213 +5161 +286 +379 +9 +5162 +5163 +5164 +1120 +5165 +5166 +2064 +1612 +19 +213 +337 +5167 +188 +213 +35 +5168 +5169 +5170 +5171 +597 +5172 +3842 +5173 +201 +337 +416 +5174 +301 +5175 +43 +3999 +5176 +5177 +5178 +5169 +5179 +873 +32 +201 +5180 +32 +5181 +222 +5182 +703 +424 +5183 +590 +10 +201 +188 +5184 +2045 +397 +5185 +5186 +303 +5187 +5188 +5189 +115 +57 +15 +5190 +764 +5191 +5192 +379 +3553 +104 +197 +5193 +5194 +643 +910 +480 +5195 +1696 +15 +5196 +915 +25 +357 +5197 +5198 +16 +5199 +5200 +5201 +5202 +5203 +5204 +14 +303 +5205 +15 +337 +317 +272 +337 +1655 +5206 +5207 +5208 +43 +5209 +5210 +5211 +43 +1870 +5212 +155 +9 +15 +5213 +5214 +1698 +3553 +648 +5215 +44 +176 +4562 +3289 +337 +5216 +519 +5217 +597 +5218 +14 +5219 +138 +5220 +352 +5221 +5222 +5223 +5224 +5225 +5226 +34 +5227 +5228 +5229 +5230 +5231 +3874 +703 +4485 +43 +5232 +5233 +5234 +5235 +548 +303 +5236 +14 +15 +5237 +5238 +1356 +5239 +5240 +5241 +1529 +5242 +5243 +5244 +5245 +2769 +5246 +5247 +1083 +5248 +5249 +1559 +3745 +303 +179 +5250 +5251 +5252 +46 +4461 +566 +15 +1300 +1112 +598 +5253 +5254 +5255 +5256 +2792 +5257 +1710 +5258 +15 +57 +861 +5259 +5260 +32 +5261 +19 +14 +5262 +5263 +3209 +1364 +597 +57 +5264 +5265 +5266 +586 +1864 +5267 +2794 +2264 +1291 +1559 +1765 +5268 +104 +5269 +5270 +345 +5271 +514 +5272 +3755 +3055 +5273 +5274 +122 +703 +1710 +2517 +5275 +57 +1169 +842 +5276 +5277 +5278 +5279 +5280 +5281 +185 +4907 +5282 +5283 +5284 +5285 +15 +5286 +613 +5287 +5288 +5289 +861 +46 +379 +3287 +10 +5290 +5291 +5292 +5293 +5080 +1710 +1122 +3407 +5294 +5295 +5296 +5297 +5298 +5299 +32 +32 +5084 +5300 +3732 +5301 +5302 +5303 +5304 +5305 +1710 +43 +349 +29 +5306 +5307 +822 +5308 +3421 +155 +178 +5309 +815 +5310 +5311 +4487 +5312 +5313 +5314 +5315 +5316 +5317 +5318 +5319 +5320 +398 +5321 +5322 +19 +5323 +849 +57 +5324 +57 +5325 +5326 +2341 +155 +597 +5327 +5328 +5329 +5330 +379 +1091 +1287 +5331 +5332 +5333 +5334 +77 +15 +9 +2427 +5335 +5336 +323 +554 +5337 +5338 +5339 +5340 +249 +15 +5341 +25 +5342 +5343 +44 +5344 +2561 +5345 +5346 +1889 +123 +14 +114 +1222 +20 +804 +5347 +22 +9 +178 +5348 +345 +19 +5080 +5349 +5350 +5351 +5352 +5353 +2728 +15 +5354 +5355 +57 +2694 +25 +3685 +10 +5356 +5357 +43 +5358 +540 +5359 +4502 +5360 +1182 +358 +5361 +1244 +46 +5362 +5363 +2158 +2540 +5364 +1847 +5365 +2921 +165 +5366 +2593 +172 +1992 +5367 +201 +57 +5368 +484 +43 +19 +63 +19 +5369 +5370 +48 +14 +5371 +4061 +5372 +16 +5373 +5374 +5375 +2770 +707 +1870 +5376 +5153 +5377 +5378 +43 +5150 +5379 +586 +5380 +301 +2849 +9 +5381 +5382 +5383 +5384 +10 +5343 +3110 +1012 +5385 +43 +345 +5386 +5387 +5388 +29 +5389 +2540 +2502 +5390 +5391 +5392 +5393 +5394 +123 +5395 +983 +5396 +278 +237 +363 +5397 +155 +10 +5398 +5399 +5400 +3984 +1503 +5401 +5402 +5403 +1559 +764 +20 +15 +5404 +2859 +5405 +5406 +15 +5407 +109 +554 +104 +5408 +57 +5409 +5410 +5411 +249 +509 +5412 +3599 +5413 +5344 +5414 +1710 +5415 +5416 +5417 +213 +19 +22 +1870 +936 +910 +5418 +43 +3160 +19 +1139 +5419 +5420 +5421 +5422 +20 +1812 +2260 +5423 +665 +20 +5424 +5425 +5426 +5427 +5428 +115 +5429 +5430 +43 +2764 +5431 +9 +519 +15 +5432 +248 +337 +5433 +14 +1559 +1508 +5434 +5435 +20 +22 +1514 +5436 +98 +5437 +5438 +1300 +5439 +5440 +286 +694 +19 +5441 +20 +5442 +284 +5443 +345 +5444 +4752 +5445 +1710 +815 +5446 +5447 +5448 +5449 +3241 +379 +57 +815 +15 +2135 +14 +2502 +864 +5450 +272 +5451 +989 +5452 +5453 +5454 +43 +5455 +5456 +416 +22 +910 +4586 +910 +179 +5293 +5457 +179 +178 +4116 +5458 +5459 +1630 +22 +272 +5460 +5461 +5462 +5463 +5464 +5465 +5466 +22 +20 +1388 +5467 +5468 +1244 +43 +5469 +5470 +248 +5471 +5472 +176 +5473 +5474 +5475 +5476 +5477 +5478 +5479 +5480 +29 +5481 +5482 +19 +5483 +345 +1905 +10 +936 +32 +364 +5484 +5485 +5486 +3796 +700 +5487 +213 +1529 +5488 +5489 +14 +3599 +1244 +5490 +5491 +14 +5492 +5493 +5494 +3034 +165 +43 +5495 +5496 +213 +5497 +5498 +4631 +22 +19 +5499 +1175 +5500 +10 +57 +5501 +15 +842 +5502 +5503 +5504 +4061 +5505 +9 +19 +4 +845 +345 +7 +2015 +15 +5506 +286 +1425 +554 +5075 +286 +705 +1307 +284 +3548 +5507 +2213 +286 +89 +57 +5508 +5509 +3353 +5510 +5511 +358 +14 +5512 +4364 +5513 +179 +25 +178 +5514 +1222 +5515 +736 +5516 +9 +439 +5517 +2500 +201 +5518 +5519 +15 +2243 +57 +77 +5520 +3422 +22 +5521 +5522 +5523 +77 +1508 +915 +19 +349 +25 +5524 +213 +188 +3316 +5525 +331 +5526 +5527 +32 +43 +5528 +5529 +1743 +5530 +5531 +5532 +5533 +5534 +354 +5535 +5536 +5537 +5538 +3698 +3 +5539 +5540 +5541 +5542 +178 +5543 +25 +484 +1867 +5544 +5545 +57 +483 +15 +5546 +9 +5547 +5548 +5549 +5550 +5551 +5552 +5553 +5554 +5555 +5556 +5557 +5558 +2259 +5559 +5560 +5561 +4791 +5562 +5563 +99 +713 +10 +26 +4160 +1026 +464 +5564 +5565 +5566 +5567 +5568 +66 +5569 +5570 +5571 +5572 +5573 +286 +1862 +115 +1100 +5574 +5575 +5576 +3161 +5577 +791 +57 +5578 +2616 +5579 +284 +5580 +5581 +1944 +5582 +5583 +57 +1665 +1710 +5584 +248 +15 +5585 +5586 +1100 +5587 +2406 +284 +5588 +5589 +5590 +155 +5591 +213 +20 +19 +5592 +5593 +248 +5594 +19 +337 +5595 +5596 +5597 +5598 +5599 +5600 +5025 +213 +1900 +5601 +5602 +5603 +5604 +15 +3598 +5605 +5606 +5607 +349 +5608 +2577 +1481 +1236 +1415 +4 +57 +5609 +5610 +32 +2124 +2043 +5611 +5612 +5512 +3569 +5613 +5614 +5615 +5616 +10 +873 +5617 +317 +15 +10 +2314 +3599 +5618 +57 +5619 +15 +32 +60 +5620 +5621 +5622 +19 +5623 +5624 +436 +5625 +2601 +32 +5626 +5627 +5628 +5629 +471 +5630 +5631 +5632 +5633 +5634 +19 +15 +5635 +89 +5636 +22 +19 +4982 +15 +201 +5637 +213 +201 +278 +741 +15 +19 +345 +984 +5638 +14 +554 +179 +270 +5639 +5640 +2085 +5641 +707 +5642 +900 +4285 +5643 +1310 +2811 +5644 +3626 +5645 +19 +5646 +53 +5647 +32 +1352 +9 +5648 +5649 +196 +2260 +5650 +5651 +5652 +610 +5653 +5654 +5655 +597 +5656 +5657 +5658 +43 +5659 +5660 +5661 +237 +1531 +14 +77 +5662 +1425 +15 +22 +188 +648 +201 +5169 +19 +5663 +57 +1765 +15 +647 +5664 +1425 +237 +357 +5665 +5666 +5667 +3055 +5668 +3376 +5669 +5670 +2728 +5671 +5672 +586 +352 +5673 +155 +178 +5674 +5675 +2958 +15 +5676 +5677 +5678 +12 +2 +5679 +142 +915 +5680 +5681 +1531 +5682 +5683 +5684 +5685 +9 +736 +5686 +155 +57 +5687 +66 +1870 +137 +5688 +5689 +2619 +5690 +14 +14 +5691 +1012 +5692 +5693 +5694 +57 +14 +32 +5695 +943 +15 +286 +5696 +5697 +586 +1234 +2318 +554 +815 +5698 +9 +5699 +2 +2124 +57 +5700 +5701 +5702 +5703 +34 +32 +369 +3431 +5704 +5705 +5706 +5707 +5708 +5709 +5710 +1559 +5711 +5712 +270 +5713 +5714 +15 +5715 +4714 +238 +5716 +5717 +3 +15 +57 +5718 +5719 +5720 +5721 +5722 +2477 +936 +5723 +5724 +3899 +2913 +5725 +5252 +3626 +5726 +43 +66 +5727 +5728 +5729 +5730 +5731 +687 +5732 +5733 +5623 +5273 +554 +5734 +677 +5735 +4155 +5736 +5737 +1514 +5738 +10 +5739 +5740 +60 +5741 +43 +1465 +5742 +5743 +2260 +5744 +66 +5745 +5746 +5747 +817 +5748 +5749 +5750 +5751 +1168 +201 +5752 +501 +5753 +648 +5754 +35 +5755 +1549 +5756 +48 +5757 +5758 +5759 +5760 +14 +5761 +3252 +22 +5762 +115 +5763 +5764 +5765 +5766 +5767 +14 +5768 +5769 +48 +5770 +5771 +5772 +484 +1291 +104 +5773 +540 +32 +5774 +5775 +5776 +2772 +5777 +5778 +104 +5779 +14 +5780 +5781 +5782 +5783 +5784 +5785 +5786 +5787 +554 +1716 +141 +554 +210 +5788 +5789 +250 +5790 +32 +3 +1542 +5791 +5792 +77 +5793 +5794 +57 +43 +43 +5795 +5796 +5629 +5797 +4961 +1226 +399 +5798 +5799 +2336 +5800 +48 +5801 +2724 +57 +5802 +5803 +5804 +2619 +286 +5805 +5806 +5807 +5808 +248 +15 +15 +5809 +1203 +1047 +5810 +17 +248 +5811 +5812 +495 +5813 +1232 +5814 +89 +5815 +32 +5816 +337 +5817 +5818 +20 +5819 +5820 +1647 +5821 +48 +19 +15 +586 +19 +32 +337 +764 +19 +5822 +299 +5823 +5824 +5825 +248 +20 +3466 +5826 +5827 +337 +303 +213 +213 +5828 +5829 +5830 +5831 +5832 +345 +5833 +57 +345 +5834 +15 +5835 +5836 +5837 +5838 +5839 +9 +3 +284 +2619 +303 +48 +19 +1021 +5840 +5841 +5842 +10 +15 +5843 +5844 +5845 +5846 +5847 +5848 +19 +15 +5849 +4124 +3755 +5850 +5851 +554 +5852 +303 +1425 +19 +5853 +1562 +22 +5854 +1637 +5855 +20 +2 +5856 +1384 +5857 +5858 +713 +5859 +713 +152 +5860 +5861 +5862 +5863 +861 +5864 +1018 +1885 +5865 +176 +5866 +5867 +5868 +5285 +286 +4281 +5869 +5870 +14 +5871 +32 +5872 +67 +4757 +249 +5873 +910 +77 +694 +43 +5874 +3729 +10 +5875 +4907 +60 +20 +1765 +20 +416 +5876 +1991 +19 +5877 +2314 +597 +15 +32 +176 +5878 +5879 +5880 +5881 +5882 +868 +5883 +3743 +5884 +292 +57 +5885 +57 +5886 +43 +5887 +5888 +20 +5889 +5890 +4 +5891 +188 +416 +882 +2 +5892 +286 +5856 +5130 +5893 +5894 +5895 +5896 +2314 +5897 +43 +77 +5898 +141 +5899 +5900 +57 +5901 +5902 +5903 +5904 +5905 +817 +34 +5906 +5907 +57 +1018 +5908 +12 +15 +5909 +57 +5780 +5910 +5911 +554 +1425 +5912 +5913 +5914 +15 +19 +2260 +20 +15 +5915 +270 +213 +5916 +286 +2999 +756 +5917 +4 +1808 +5918 +5919 +492 +1442 +5920 +152 +228 +484 +5921 +19 +43 +2260 +25 +5922 +1300 +2794 +276 +519 +5923 +196 +14 +5924 +5925 +5926 +5927 +19 +5928 +5929 +201 +222 +4364 +305 +1224 +213 +5930 +25 +318 +1384 +123 +213 +337 +2697 +5931 +15 +5932 +5933 +5934 +5935 +5936 +5937 +5938 +1401 +915 +67 +5939 +5940 +733 +5941 +15 +222 +2035 +5942 +5943 +19 +43 +509 +5944 +19 +1112 +5945 +1291 +272 +5946 +5947 +5512 +4606 +67 +5948 +5949 +357 +5950 +5951 +352 +5952 +5953 +4364 +1021 +4028 +14 +188 +5954 +161 +248 +20 +1465 +5955 +5956 +1696 +1749 +5957 +5958 +5080 +337 +57 +415 +57 +57 +337 +5959 +5960 +5961 +358 +5962 +1806 +5963 +5964 +43 +5965 +2239 +5966 +5967 +225 +57 +398 +5968 +5969 +5970 +137 +5971 +3841 +142 +1710 +19 +22 +5972 +5973 +5974 +1160 +5975 +5976 +32 +5977 +4247 +5978 +278 +20 +337 +2899 +5979 +933 +5980 +5981 +317 +5982 +1172 +4035 +3476 +1604 +2540 +248 +286 +5983 +5984 +1021 +5985 +196 +5986 +5987 +3777 +1232 +738 +22 +5988 +5989 +5990 +2728 +5991 +5992 +5993 +5994 +5995 +3 +5996 +5997 +5998 +5999 +358 +286 +764 +3059 +19 +861 +14 +514 +6000 +6001 +6002 +1245 +6003 +3484 +3486 +6004 +6005 +411 +6006 +6007 +19 +248 +6008 +6009 +6010 +1082 +6011 +6012 +1529 +284 +323 +6013 +6014 +6015 +15 +3291 +4897 +15 +6016 +6017 +15 +213 +284 +910 +201 +849 +5287 +6018 +358 +6019 +213 +15 +188 +6020 +2135 +14 +12 +6021 +6022 +6023 +354 +317 +6024 +6025 +6026 +573 +6027 +2043 +6028 +6029 +6030 +2835 +665 +1083 +6031 +849 +6032 +6033 +303 +57 +6034 +6035 +6036 +6037 +1018 +6038 +1245 +6039 +4677 +6040 +6041 +6042 +6043 +337 +34 +57 +6044 +1234 +6045 +6046 +6047 +3743 +6048 +5785 +6049 +237 +493 +3055 +6050 +6051 +6052 +2577 +248 +6053 +6054 +6055 +6056 +712 +6057 +201 +3546 +6058 +6059 +178 +67 +354 +290 +647 +4364 +15 +5780 +6060 +6061 +568 +338 +2 +6062 +1021 +1026 +24 +6063 +6064 +6065 +910 +15 +25 +2129 +6066 +6067 +6068 +554 +6069 +337 +6070 +6071 +152 +4088 +9 +6072 +1291 +6073 +10 +6074 +6075 +6076 +22 +286 +6077 +1066 +6078 +6079 +185 +32 +3202 +6080 +19 +6081 +303 +19 +6082 +6083 +2591 +6084 +2 +6085 +861 +6086 +6087 +6088 +6089 +201 +32 +3345 +317 +155 +6090 +1870 +6091 +99 +6092 +303 +43 +6093 +6094 +741 +19 +14 +597 +57 +416 +815 +6095 +873 +6096 +43 +6097 +6098 +1612 +6099 +213 +179 +5498 +15 +354 +19 +19 +5561 +6100 +43 +416 +6101 +6102 +6103 +3310 +6104 +694 +493 +6105 +616 +3503 +849 +6106 +6107 +4146 +245 +1122 +2694 +4627 +345 +6108 +248 +6109 +1044 +495 +491 +6110 +6111 +2286 +6112 +15 +6113 +178 +6114 +77 +9 +1716 +228 +48 +861 +6115 +6116 +6117 +155 +6118 +6119 +6120 +6121 +2140 +6122 +6123 +6124 +6125 +6126 +2314 +9 +6127 +6128 +6129 +6130 +48 +6131 +2064 +15 +6132 +6133 +3544 +89 +5780 +936 +14 +345 +6134 +6135 +514 +25 +6136 +6137 +6138 +6139 +6140 +248 +6141 +6142 +1234 +179 +188 +2728 +25 +6143 +6144 +3978 +286 +6145 +1571 +284 +1332 +6146 +6147 +15 +22 +6148 +6149 +77 +15 +6150 +6151 +155 +284 +337 +349 +6152 +9 +6153 +6154 +248 +337 +6155 +6156 +6157 +1021 +15 +20 +6158 +6159 +6160 +6161 +6162 +284 +48 +6163 +6164 +2971 +6165 +16 +6166 +6167 +5649 +6168 +6169 +337 +6170 +6171 +671 +6172 +19 +6173 +46 +201 +43 +2576 +237 +77 +6174 +6175 +2998 +2356 +9 +6176 +6177 +6178 +6179 +6180 +6181 +1668 +6182 +22 +5780 +6183 +6184 +6185 +6186 +337 +6187 +2902 +248 +6188 +6189 +1834 +683 +6190 +6191 +1684 +6192 +6193 +6194 +6195 +6196 +6197 +6198 +6199 +6200 +5904 +6201 +32 +6202 +6203 +541 +6204 +6205 +6206 +6207 +6208 +303 +57 +6209 +566 +358 +6210 +4 +6211 +2324 +6212 +1776 +14 +4007 +6213 +286 +701 +6214 +60 +6215 +6216 +6217 +3395 +6218 +6219 +6220 +6221 +20 +48 +1502 +14 +6222 +6223 +25 +6224 +6225 +6226 +6227 +5803 +6228 +6229 +2347 +6230 +6231 +3062 +1232 +196 +6232 +6233 +1189 +2580 +6234 +6235 +2410 +57 +6236 +6237 +222 +6238 +43 +6239 +493 +57 +6240 +2728 +3 +751 +6241 +3709 +6242 +6243 +6244 +6245 +6246 +222 +1425 +4315 +14 +32 +6247 +6248 +2566 +6249 +1574 +19 +6250 +179 +6251 +415 +6252 +178 +32 +6253 +6254 +3172 +77 +6255 +6256 +6257 +694 +6258 +3989 +6259 +6260 +6261 +6262 +155 +104 +6263 +57 +6264 +1502 +6265 +6212 +6266 +788 +6267 +6268 +270 +751 +6269 +6270 +6271 +6272 +6273 +6274 +5542 +1775 +6275 +6276 +19 +1710 +484 +6277 +6278 +1112 +6279 +6280 +16 +6281 +6282 +6283 +6284 +6285 +6286 +597 +402 +1542 +6287 +6288 +6289 +6290 +6291 +6292 +6293 +6294 +6295 +6296 +9 +2260 +6297 +6298 +178 +6299 +6300 +4839 +398 +6301 +514 +77 +6302 +22 +6303 +9 +6304 +6305 +417 +6306 +6307 +6308 +19 +6309 +6310 +3375 +6311 +6312 +6313 +6314 +6315 +6316 +2368 +6317 +6318 +3525 +6319 +6320 +6321 +6322 +3252 +6323 +6324 +6325 +6326 +6327 +3 +6328 +6329 +9 +176 +6330 +57 +1531 +272 +6331 +25 +6332 +6333 +815 +4952 +3104 +6334 +6335 +1512 +6336 +4280 +5127 +6337 +6338 +6339 +2 +67 +446 +6340 +179 +66 +6289 +6341 +6342 +43 +5780 +6343 +20 +32 +32 +6344 +2197 +6345 +6346 +6347 +6348 +6349 +2015 +6350 +6351 +188 +4405 +6352 +6353 +6354 +694 +6355 +345 +822 +354 +6356 +2907 +19 +6357 +6358 +597 +6359 +514 +6360 +6361 +6362 +185 +6363 +6364 +22 +6365 +6366 +286 +6367 +48 +6368 +3777 +3466 +6369 +687 +6370 +6371 +6372 +67 +6373 +564 +6374 +6375 +19 +15 +6376 +317 +201 +693 +1287 +6377 +2 +6378 +6379 +6380 +6381 +155 +6382 +43 +6383 +6384 +43 +6385 +6386 +6387 +6175 +6388 +5837 +2064 +6389 +6390 +2 +15 +6391 +14 +411 +286 +4088 +5856 +6392 +19 +1244 +43 +514 +222 +2316 +6393 +1100 +701 +861 +6394 +2262 +6395 +4627 +142 +6396 +6397 +32 +4900 +671 +6398 +3406 +1291 +6399 +15 +286 +6400 +6401 +6402 +6403 +57 +155 +4128 +155 +6404 +3307 +1710 +6405 +6406 +1961 +6407 +286 +6408 +1245 +6409 +2320 +14 +6410 +15 +815 +6411 +6054 +15 +6412 +6413 +6414 +48 +15 +713 +76 +14 +6415 +5856 +228 +6416 +6417 +6418 +19 +1465 +6419 +1870 +6420 +6421 +6422 +6423 +6424 +6425 +5780 +6426 +6427 +1105 +6428 +345 +6429 +2019 +1245 +286 +6430 +188 +3870 +14 +6431 +15 +6432 +19 +1502 +399 +141 +6433 +1047 +6434 +6435 +6436 +3725 +6437 +6438 +6439 +597 +6440 +989 +6441 +6442 +3061 +6443 +4 +6444 +6445 +179 +6446 +6447 +15 +6341 +3406 +3 +25 +36 +6448 +4647 +6449 +6450 +6451 +286 +6452 +6453 +6454 +411 +6455 +6456 +5856 +1808 +3055 +6457 +6458 +6459 +554 +2341 +6460 +6461 +6462 +6463 +4141 +745 +231 +491 +6464 +6465 +286 +43 +845 +9 +6466 +4 +815 +6467 +6468 +6469 +6470 +6471 +6472 +178 +114 +6473 +317 +3943 +417 +6474 +6475 +29 +3198 +6476 +5013 +270 +6477 +6478 +1386 +6479 +19 +6480 +6481 +6482 +6071 +1829 +6483 +6484 +14 +6485 +209 +6486 +1961 +6487 +3317 +6488 +6289 +6489 +6490 +6491 +1169 +2040 +6492 +1834 +6493 +6494 +6495 +6496 +228 +299 +4 +179 +6497 +665 +10 +6498 +2264 +19 +57 +6412 +790 +1920 +6499 +185 +20 +6500 +6501 +6502 +6503 +3050 +6504 +6505 +270 +237 +6506 +57 +265 +6507 +354 +6508 +6509 +57 +645 +6510 +5780 +6511 +6512 +6513 +6514 +448 +586 +6515 +6516 +6517 +6518 +6519 +10 +6520 +1384 +6521 +6522 +6523 +3309 +179 +6524 +399 +6525 +6526 +1956 +6527 +16 +57 +22 +6528 +6529 +6530 +6531 +6532 +6533 +286 +5856 +4028 +176 +3829 +2835 +6534 +14 +6535 +14 +6536 +6537 +6538 +6539 +1428 +4 +6540 +6541 +6542 +6543 +788 +6544 +6545 +6546 +176 +6547 +5780 +15 +6548 +6549 +6550 +6551 +6552 +77 +201 +540 +493 +4672 +6553 +6554 +137 +196 +184 +6555 +25 +6556 +6557 +6558 +57 +15 +6559 +6560 +6561 +6562 +6563 +5127 +6564 +19 +694 +1021 +6565 +34 +6566 +48 +1715 +15 +60 +491 +6567 +6568 +5856 +4512 +9 +237 +6569 +480 +892 +25 +6570 +345 +6571 +201 +34 +32 +6572 +6573 +6574 +1744 +6575 +6576 +6577 +9 +6578 +533 +6579 +43 +6580 +1019 +6581 +6582 +15 +6583 +6584 +6585 +6586 +6587 +15 +43 +331 +39 +6588 +665 +3376 +6589 +164 +6590 +331 +6591 +15 +6592 +6593 +1249 +6594 +6595 +6596 +2502 +1415 +20 +6597 +6598 +6599 +5895 +464 +6600 +2913 +155 +415 +57 +6601 +1716 +272 +6602 +1542 +736 +558 +6603 +2356 +9 +14 +6604 +15 +1172 +279 +15 +60 +3978 +349 +6605 +3814 +379 +6606 +25 +6607 +6608 +6609 +6610 +6611 +6612 +1438 +338 +6613 +6614 +16 +3946 +1961 +1718 +707 +1047 +6615 +6616 +6617 +5856 +10 +20 +436 +6618 +6619 +2164 +15 +6620 +6621 +86 +417 +6622 +751 +6623 +6624 +15 +6625 +1920 +6626 +1668 +1100 +6627 +345 +6628 +6629 +57 +6630 +6631 +6632 +6633 +10 +6634 +286 +32 +2329 +721 +493 +6412 +1605 +1768 +3241 +349 +19 +1374 +6635 +6636 +1942 +6637 +6638 +1698 +6639 +598 +6640 +138 +6641 +6642 +6643 +345 +764 +57 +6644 +6645 +272 +5298 +1481 +3213 +6646 +10 +6647 +89 +6648 +32 +6649 +274 +286 +6650 +6651 +22 +3 +43 +1567 +180 +4128 +1966 +815 +6652 +19 +9 +6653 +1011 +6654 +4 +936 +6655 +305 +1010 +6656 +6657 +32 +1120 +43 +286 +188 +6658 +34 +15 +14 +6659 +1232 +6660 +6661 +6662 +6663 +6664 +6665 +22 +6666 +3005 +19 +2427 +533 +6667 +1889 +6668 +825 +1867 +1710 +6669 +43 +3104 +6670 +57 +331 +1245 +6671 +1442 +1808 +6672 +694 +861 +6673 +3 +6674 +6675 +14 +6676 +2546 +4441 +6289 +201 +6677 +6678 +6679 +6680 +6681 +677 +5202 +1920 +6682 +6683 +2776 +6684 +57 +15 +6685 +12 +1765 +6686 +248 +6687 +32 +6688 +1169 +6689 +1824 +6289 +5780 +15 +6690 +286 +6691 +2208 +815 +6692 +6693 +6694 +6695 +22 +1743 +6696 +6697 +398 +213 +6698 +6699 +138 +231 +6700 +6701 +6702 +6703 +6704 +2318 +197 +6705 +6706 +19 +6707 +6708 +20 +2734 +6709 +6710 +6711 +6712 +6713 +286 +43 +6714 +2836 +6715 +1082 +6716 +6289 +26 +137 +6717 +43 +5564 +6718 +6719 +6720 +6721 +6722 +6723 +6724 +6725 +345 +4 +6726 +5780 +34 +6727 +831 +6086 +6728 +6729 +6730 +6731 +6732 +6733 +6734 +20 +155 +6735 +2043 +89 +331 +15 +237 +57 +1217 +16 +6736 +6737 +43 +48 +6738 +6739 +2619 +6740 +6741 +514 +286 +6742 +345 +6743 +6744 +6745 +6746 +6747 +15 +99 +6748 +6749 +6750 +6751 +6752 +6753 +6754 +6755 +751 +6756 +32 +20 +6757 +6758 +48 +6759 +278 +648 +6760 +6761 +6762 +20 +6763 +6289 +6764 +6412 +2260 +96 +201 +6765 +1232 +19 +6766 +6767 +564 +6768 +6769 +57 +373 +417 +6770 +2260 +6771 +112 +6772 +6773 +337 +484 +6774 +6775 +4364 +6776 +1913 +6777 +32 +6778 +10 +3192 +122 +270 +1508 +22 +5856 +392 +6779 +1716 +6780 +6781 +6782 +6783 +6784 +6785 +6786 +2561 +654 +6787 +6788 +6789 +6790 +6728 +11 +6791 +342 +6792 +286 +6793 +14 +6794 +6795 +6796 +6797 +6798 +6799 +2694 +6800 +99 +6801 +34 +2318 +6802 +15 +6803 +5314 +6804 +6805 +48 +6806 +19 +6807 +1465 +6808 +112 +6809 +6810 +15 +155 +34 +4745 +484 +6811 +6812 +6813 +89 +6814 +5659 +6480 +1172 +6164 +2913 +6815 +1559 +1559 +6816 +284 +6817 +6818 +6819 +566 +48 +14 +845 +15 +6820 +6821 +6822 +286 +1133 +345 +3055 +703 +6823 +32 +6824 +6825 +6826 +665 +16 +43 +6827 +4026 +6828 +1900 +6829 +5734 +286 +6830 +237 +6831 +4388 +1383 +6832 +6833 +6834 +2029 +6835 +6836 +6837 +6838 +369 +6839 +6840 +57 +1875 +554 +155 +1012 +6841 +4 +6842 +43 +2197 +354 +6843 +736 +3995 +6844 +1465 +1172 +6845 +6846 +4765 +6847 +6848 +4263 +284 +1107 +3 +6849 +736 +6850 +303 +6851 +2849 +6852 +6853 +32 +286 +6854 +6855 +6856 +48 +6857 +303 +357 +554 +6858 +15 +6859 +659 +696 +6860 +6861 +141 +6862 +1637 +4398 +6863 +5561 +2561 +6864 +6865 +514 +6866 +701 +6867 +6868 +1172 +6869 +4002 +6870 +1637 +6871 +2302 +6872 +6873 +491 +6874 +286 +155 +2978 +6875 +6876 +155 +6877 +586 +5169 +15 +647 +1870 +6878 +6879 +6880 +6881 +6882 +6883 +38 +6884 +6885 +6886 +6887 +5008 +6412 +6888 +22 +6889 +60 +323 +6890 +2790 +6891 +6892 +6893 +6894 +6895 +2289 +6896 +6897 +284 +303 +6898 +3981 +1223 +6899 +6900 +1559 +3543 +152 +6901 +1604 +397 +213 +48 +6902 +5304 +4859 +6903 +741 +6904 +6905 +6906 +5825 +6907 +17 +19 +6908 +6909 +1612 +6910 +6911 +248 +765 +4139 +915 +6912 +4487 +6913 +1808 +6914 +6915 +910 +6916 +6917 +299 +286 +19 +48 +3594 +6918 +6919 +1961 +4709 +6920 +6921 +6922 +6923 +6095 +6924 +2260 +597 +369 +15 +1956 +6925 +6926 +751 +3367 +6927 +284 +5780 +6928 +57 +43 +284 +3054 +6929 +6595 +284 +861 +6930 +6931 +6932 +566 +6900 +6933 +349 +6934 +6935 +209 +4425 +6936 +20 +2591 +484 +531 +5111 +583 +509 +6937 +355 +613 +6938 +6939 +6940 +57 +6941 +6942 +2770 +2356 +592 +6943 +39 +885 +201 +6944 +15 +6945 +6946 +6947 +179 +6948 +6949 +286 +2482 +6950 +6951 +6952 +6953 +2502 +5780 +955 +32 +573 +6954 +398 +201 +6955 +6956 +6957 +337 +694 +6958 +597 +6959 +6960 +1512 +6961 +6962 +284 +6963 +6964 +6965 +1249 +6966 +6967 +6968 +6969 +1157 +6970 +57 +9 +6971 +6972 +57 +165 +6973 +6974 +345 +9 +713 +6975 +6976 +1829 +248 +6977 +6978 +6979 +6980 +6981 +2733 +6982 +6533 +6983 +6984 +6985 +2410 +15 +6986 +4425 +6987 +6988 +6989 +845 +471 +6990 +699 +6991 +6992 +3905 +222 +6993 +237 +6994 +6995 +6996 +6997 +6998 +6999 +7000 +7001 +7002 +2136 +892 +19 +43 +7003 +7004 +197 +842 +15 +7005 +7006 +7007 +2477 +809 +7008 +7009 +7010 +9 +648 +89 +1961 +228 +721 +910 +7011 +15 +7012 +7013 +331 +3849 +1684 +7014 +7015 +7016 +7017 +7018 +7019 +7020 +7021 +7022 +19 +3647 +616 +5537 +32 +25 +1112 +3 +7023 +7024 +7025 +4 +4616 +1244 +3519 +7026 +7027 +57 +7028 +7029 +7030 +20 +7031 +112 +2260 +19 +25 +210 +43 +3640 +7032 +7033 +5556 +7034 +7035 +7036 +7037 +345 +7038 +9 +7039 +3534 +7040 +284 +2804 +7041 +1867 +7042 +7043 +7044 +440 +7045 +3599 +2064 +1965 +7046 +15 +7047 +272 +7048 +7049 +4855 +1364 +7050 +303 +2697 +7051 +7052 +15 +43 +5308 +597 +1346 +590 +7053 +7054 +7055 +4760 +7056 +7057 +694 +7058 +7059 +7060 +7061 +4518 +7062 +7063 +7064 +2841 +436 +2431 +201 +323 +7065 +15 +201 +7066 +2944 +7067 +7068 +7069 +936 +7070 +2314 +1612 +1415 +14 +7071 +7072 +6289 +7073 +7074 +7075 +665 +15 +7076 +7077 +464 +19 +7078 +286 +10 +7079 +7080 +4139 +190 +7081 +7082 +7083 +20 +1013 +2591 +7084 +738 +7085 +7086 +32 +1768 +7087 +7088 +19 +2694 +597 +10 +7089 +7090 +3553 +7091 +7092 +200 +7093 +5320 +7094 +1051 +57 +7095 +7096 +4634 +48 +1508 +430 +7097 +19 +15 +842 +373 +7098 +1010 +20 +7099 +713 +815 +7100 +284 +155 +7101 +57 +1021 +7102 +7103 +3417 +7104 +5700 +1566 +7105 +7106 +1047 +155 +7107 +7108 +7109 +22 +1090 +665 +1021 +7110 +887 +554 +7111 +15 +20 +597 +2561 +284 +6878 +3296 +869 +7112 +7113 +172 +7114 +32 +7115 +7116 +337 +7117 +43 +7118 +415 +7119 +7120 +7121 +9 +872 +1364 +7122 +3455 +32 +7123 +492 +7124 +99 +7125 +7126 +7127 +16 +1867 +9 +586 +1415 +7128 +7129 +7130 +22 +7131 +7132 +7133 +7134 +7135 +7136 +59 +7137 +989 +7138 +2593 +2925 +7139 +48 +7140 +345 +7141 +1124 +354 +7142 +1172 +34 +7143 +721 +7144 +7145 +57 +43 +7146 +6916 +7147 +7148 +7149 +19 +1531 +14 +7150 +32 +7151 +7152 +10 +7153 +7154 +7155 +1364 +7156 +1531 +20 +7157 +20 +7158 +7159 +57 +7160 +7161 +19 +7162 +7163 +7164 +7165 +7166 +493 +7167 +3317 +7168 +1356 +7169 +7170 +15 +7171 +1738 +286 +7172 +7173 +15 +1531 +3902 +815 +2593 +3852 +99 +7174 +7175 +7176 +610 +867 +7177 +7178 +109 +7179 +7180 +7181 +648 +9 +7182 +7183 +7184 +7185 +43 +7186 +7187 +495 +7188 +7189 +4634 +16 +7190 +7191 +7192 +7193 +317 +7194 +7195 +364 +1364 +14 +7196 +155 +7197 +2 +10 +1208 +7198 +7199 +295 +7200 +3216 +7201 +7202 +7203 +98 +1710 +677 +7204 +7205 +7206 +7207 +5780 +7208 +2040 +7209 +7210 +5659 +7211 +358 +402 +155 +7212 +89 +213 +7213 +7214 +7215 +6057 +7216 +16 +7217 +1154 +7218 +7219 +1502 +2415 +815 +15 +707 +185 +4574 +7220 +6731 +7221 +7222 +2175 +7223 +19 +7224 +331 +7225 +7226 +7227 +19 +7228 +3050 +20 +1149 +1710 +201 +7229 +279 +378 +188 +15 +7230 +2254 +2550 +861 +7231 +647 +20 +7232 +7233 +7234 +3978 +7235 +7236 +7237 +2281 +7238 +46 +2988 +7239 +3376 +43 +96 +1932 +19 +7240 +478 +533 +7241 +993 +7242 +7243 +15 +7244 +7245 +7246 +7247 +7248 +43 +7249 +966 +7250 +7251 +745 +57 +7252 +2289 +76 +7253 +7254 +248 +7255 +7256 +15 +15 +533 +7257 +22 +104 +60 +7258 +7259 +15 +7260 +7261 +317 +4088 +19 +872 +3908 +286 +286 +590 +7262 +437 +586 +201 +32 +7263 +2040 +7264 +7265 +7266 +7267 +7268 +43 +7269 +2 +7270 +7271 +7272 +7273 +7274 +7275 +317 +7276 +22 +2009 +48 +7277 +3059 +1425 +7278 +4950 +7279 +7280 +178 +7281 +7282 +571 +5623 +4411 +7283 +5251 +4411 +7284 +3598 +7285 +7286 +7287 +398 +7288 +6382 +7289 +7290 +2040 +7291 +45 +7292 +2564 +7293 +7294 +3599 +7295 +7296 +7297 +597 +7298 +533 +7299 +1465 +57 +7300 +7301 +201 +7302 +2009 +7303 +7304 +7305 +1513 +751 +7306 +7307 +5254 +2593 +77 +7308 +137 +7309 +4026 +7310 +1052 +15 +7311 +7312 +7313 +271 +712 +7314 +1675 +7315 +1710 +7316 +9 +7317 +7318 +7319 +7320 +7321 +323 +7322 +7323 +7324 +178 +7325 +284 +7326 +7327 +7328 +7329 +1293 +178 +5923 +248 +25 +7330 +7331 +11 +345 +6505 +7332 +6412 +10 +7333 +7334 +764 +7335 +7336 +7337 +827 +1386 +303 +237 +7338 +7339 +7340 +583 +32 +694 +3 +4 +7341 +19 +7342 +4053 +286 +7343 +1454 +1817 +176 +2314 +7344 +7345 +7346 +7347 +7348 +15 +6928 +20 +7349 +7350 +7351 +379 +7352 +25 +155 +7353 +270 +7354 +7355 +201 +7356 +19 +1531 +7357 +32 +7358 +6505 +7359 +3599 +22 +19 +7360 +7361 +7362 +201 +7363 +2974 +7364 +7365 +282 +178 +7366 +7367 +7368 +7369 +5203 +7370 +7371 +1224 +248 +4185 +57 +2176 +25 +3172 +554 +19 +910 +7372 +7373 +15 +14 +7374 +242 +7375 +3759 +15 +14 +7376 +7377 +155 +7378 +1112 +7379 +7380 +20 +7381 +1749 +248 +7382 +7383 +317 +373 +7384 +14 +25 +7357 +19 +648 +2029 +7385 +7386 +7387 +7388 +19 +7389 +915 +7390 +7391 +7392 +7393 +7394 +99 +1244 +32 +7395 +7396 +7397 +1364 +7398 +7399 +7400 +478 +3055 +7401 +1200 +7402 +399 +7403 +15 +3104 +4364 +19 +7404 +20 +19 +7405 +7406 +2728 +7407 +656 +7408 +7409 +1834 +2029 +7410 +7411 +399 +228 +7412 +7413 +284 +7414 +34 +20 +7415 +7416 +77 +213 +48 +19 +155 +7417 +7418 +2289 +415 +7419 +7420 +6501 +7421 +7422 +43 +164 +4 +7315 +345 +7423 +1834 +7424 +1900 +7425 +7426 +2979 +19 +337 +7427 +2913 +32 +533 +564 +7428 +7429 +1107 +7430 +7431 +7432 +2368 +337 +358 +7433 +7434 +1508 +19 +7435 +1232 +7436 +5265 +7437 +15 +7438 +284 +7439 +188 +364 +77 +7440 +9 +5780 +3148 +972 +155 +7441 +7442 +1465 +7443 +4 +7444 +7445 +7446 +7447 +1992 +323 +32 +7448 +7449 +7450 +43 +1222 +5780 +7451 +7452 +7453 +7454 +345 +1079 +7455 +7456 +7457 +7458 +7459 +2314 +7460 +15 +416 +7461 +536 +286 +269 +7462 +201 +20 +7463 +3202 +7464 +190 +7465 +7466 +7467 +7369 +3599 +7468 +22 +7469 +7470 +7471 +7472 +7473 +7474 +7475 +7476 +188 +7477 +34 +7478 +7479 +7480 +915 +5326 +7481 +2387 +1944 +286 +829 +22 +586 +66 +7482 +1112 +6289 +5839 +15 +7483 +7484 +7485 +7486 +7487 +7488 +77 +7489 +7490 +32 +415 +7491 +7492 +7493 +4364 +7494 +43 +7495 +3858 +7496 +7497 +7498 +3981 +3078 +345 +3465 +3543 +7499 +6518 +7500 +7501 +4598 +7502 +7503 +3515 +1823 +5629 +7504 +197 +1220 +7505 +15 +2347 +7506 +9 +2694 +7507 +7508 +7509 +7510 +3470 +7511 +7512 +15 +7513 +7514 +19 +7515 +845 +7516 +7517 +7518 +7519 +3959 +7520 +213 +57 +7521 +5908 +1401 +7522 +7523 +7524 +337 +7525 +213 +7526 +519 +7527 +7528 +7529 +7530 +7531 +7532 +736 +7533 +7534 +5780 +7535 +7536 +7276 +7137 +5552 +7537 +7538 +373 +7539 +19 +2356 +5336 +337 +4414 +7540 +7541 +15 +2260 +7542 +7543 +3914 +7544 +7545 +303 +7546 +7547 +303 +7548 +493 +573 +7549 +206 +7550 +7551 +19 +7552 +1046 +7553 +540 +720 +1517 +286 +7554 +7555 +299 +1352 +7556 +2429 +60 +7557 +213 +7558 +1870 +7559 +861 +7560 +6617 +1840 +20 +7561 +7562 +7563 +303 +4263 +7564 +7565 +25 +7566 +7567 +7568 +357 +4155 +7569 +7570 +15 +573 +19 +7571 +7572 +3999 +7573 +7574 +7575 +7576 +7577 +373 +7578 +7579 +2253 +7580 +19 +7581 +7582 +15 +7583 +7584 +43 +19 +4884 +7585 +7586 +849 +7587 +7588 +7589 +2902 +7590 +7591 +955 +828 +694 +7592 +486 +7593 +7594 +7595 +237 +464 +5521 +3 +1357 +2135 +2697 +12 +7596 +7597 +7598 +7599 +7600 +2 +586 +7601 +7602 +7289 +7603 +694 +7604 +43 +1918 +2577 +7605 +4963 +201 +2787 +2804 +7606 +5601 +286 +7607 +7608 +7609 +2316 +7610 +6518 +7611 +7612 +2762 +7613 +7614 +7615 +7616 +1955 +7617 +7618 +7619 +6449 +7620 +7621 +7622 +43 +7623 +558 +7624 +1799 +7625 +828 +7626 +7627 +354 +7628 +484 +32 +317 +7629 +6716 +7630 +7631 +43 +1710 +303 +7632 +209 +7633 +738 +43 +197 +16 +34 +7634 +7635 +7636 +1425 +2034 +7637 +7638 +15 +7639 +416 +7640 +201 +57 +7641 +317 +1364 +7642 +7643 +7644 +3354 +7645 +19 +373 +7646 +915 +7647 +345 +201 +77 +493 +7648 +7649 +7650 +115 +648 +77 +7651 +7652 +845 +5689 +1021 +7653 +1160 +7654 +7655 +2166 +7656 +7657 +2471 +7658 +597 +7659 +7660 +504 +25 +7661 +7236 +7662 +7663 +57 +7664 +201 +7665 +1425 +1710 +7666 +89 +7667 +721 +7668 +7669 +7670 +7671 +7672 +7673 +7674 +7675 +7676 +7677 +5623 +3553 +7678 +7679 +6289 +43 +7680 +7681 +7682 +7683 +2537 +20 +7684 +7685 +201 +43 +7686 +1160 +7687 +791 +7688 +7689 +5949 +4512 +7690 +417 +3353 +7691 +2129 +7692 +7693 +1153 +9 +19 +7694 +57 +43 +286 +1812 +7695 +1343 +2253 +6518 +7696 +5204 +345 +7697 +1696 +7698 +4028 +1710 +5780 +2782 +7699 +2769 +349 +10 +2615 +7700 +915 +7701 +4598 +12 +19 +354 +14 +6305 +89 +345 +7702 +201 +14 +15 +1116 +7703 +4634 +7704 +7705 +7706 +464 +4 +7707 +5312 +7708 +4905 +3999 +39 +7709 +4024 +7710 +5990 +286 +43 +19 +248 +317 +845 +3503 +3645 +7711 +7712 +66 +17 +7713 +7714 +7715 +57 +6463 +158 +7716 +7717 +7718 +7719 +7720 +7721 +2163 +29 +248 +303 +7722 +337 +7723 +20 +7724 +2849 +4048 +15 +7725 +284 +43 +6187 +14 +7726 +7727 +7728 +7729 +337 +7730 +237 +4075 +7731 +7732 +7733 +7734 +7735 +7736 +694 +736 +1352 +29 +272 +1559 +57 +248 +665 +7737 +7738 +20 +2879 +5340 +134 +7739 +1169 +4677 +7740 +7741 +7742 +7743 +7744 +7745 +416 +845 +225 +7746 +248 +7747 +200 +7748 +43 +43 +7749 +7750 +7751 +7752 +7577 +412 +7753 +155 +7754 +11 +7755 +4 +5326 +7756 +7757 +7758 +5556 +7442 +19 +7759 +7760 +43 +7761 +7762 +114 +2140 +20 +7763 +1169 +1011 +7764 +178 +278 +5731 +7765 +3844 +7766 +1011 +14 +317 +237 +7767 +7768 +519 +7769 +7770 +201 +7771 +7772 +7773 +7774 +7775 +7776 +7777 +7778 +188 +2314 +7779 +317 +7780 +7781 +7782 +7783 +703 +1784 +7784 +7785 +7786 +7787 +7788 +822 +7789 +936 +7790 +7791 +7792 +3976 +7793 +7794 +7795 +32 +7796 +7797 +495 +20 +5601 +7798 +7799 +7800 +7137 +7801 +7802 +7803 +7804 +7805 +4925 +7806 +7807 +7808 +7809 +7810 +7811 +7812 +1083 +764 +1105 +7364 +7813 +7814 +7815 +7816 +345 +7817 +7818 +7819 +15 +7820 +7821 +3906 +7822 +279 +7823 +14 +228 +357 +3059 +7824 +354 +7825 +7826 +7827 +7828 +377 +7829 +1112 +228 +597 +7830 +7831 +210 +3467 +7832 +7833 +1580 +7834 +694 +7835 +7836 +7837 +7838 +7839 +7840 +7841 +170 +7842 +7843 +7844 +7845 +48 +7846 +43 +7847 +10 +57 +7848 +5700 +7849 +7850 +7851 +7852 +7853 +7854 +694 +3376 +7855 +35 +7856 +7857 +7858 +7859 +201 +5243 +7860 +7861 +7862 +500 +7863 +7864 +7865 +7866 +7867 +4855 +1808 +7868 +7869 +5022 +7870 +7871 +2006 +7872 +43 +15 +7873 +7874 +2320 +7875 +7876 +1696 +7877 +213 +7878 +7879 +7880 +554 +7881 +7882 +248 +7883 +7884 +16 +7885 +303 +7886 +337 +2770 +7887 +7888 +1112 +610 +176 +7889 +7890 +10 +345 +15 +7891 +7892 +3546 +7893 +2949 +16 +303 +7894 +349 +7895 +7896 +7897 +1940 +201 +7898 +1710 +16 +7899 +7900 +284 +303 +7901 +5584 +303 +15 +7902 +7903 +7904 +7905 +7906 +1089 +7907 +3598 +7908 +7909 +15 +7910 +7911 +7912 +270 +19 +7913 +2029 +7914 +5075 +7915 +269 +10 +43 +411 +7916 +7917 +1612 +1425 +491 +2694 +859 +7918 +7919 +7920 +43 +741 +7921 +3465 +271 +15 +7922 +7923 +43 +7924 +7925 +4301 +7926 +7927 +248 +7928 +286 +647 +7929 +7930 +4907 +5065 +7931 +3 +7932 +7933 +9 +6950 +7934 +7935 +7936 +741 +99 +7937 +7938 +7939 +7940 +3148 +7941 +7942 +3095 +7943 +7944 +7945 +10 +7946 +6071 +7947 +7948 +892 +7949 +7531 +299 +14 +2546 +1172 +7950 +337 +7951 +3 +7952 +549 +703 +7953 +7954 +7955 +7956 +7835 +7957 +7958 +7959 +6439 +7960 +7961 +7962 +1262 +1021 +286 +7963 +7964 +15 +1089 +484 +7965 +19 +7966 +213 +7842 +7967 +32 +7968 +284 +464 +1470 +213 +22 +7969 +725 +7970 +7971 +7956 +398 +7972 +1456 +1637 +554 +317 +213 +7973 +7974 +337 +2700 +7975 +7976 +286 +7977 +7978 +533 +112 +15 +7979 +1955 +694 +7980 +7981 +7982 +7983 +1082 +2325 +7984 +6468 +22 +7985 +7986 +1765 +7987 +7988 +7989 +7990 +7991 +345 +6439 +3004 +7992 +3844 +21 +7993 +337 +2243 +196 +7994 +7995 +7270 +15 +7996 +1562 +179 +7997 +284 +1121 +7998 +915 +342 +586 +43 +892 +4634 +22 +7999 +2040 +8000 +342 +8001 +8002 +8003 +8004 +213 +446 +19 +8005 +1445 +2449 +317 +188 +317 +8006 +8007 +8008 +8009 +1112 +8010 +8011 +2 +8012 +8013 +20 +528 +4634 +8014 +57 +6915 +1356 +8015 +8016 +14 +8017 +6304 +8018 +647 +99 +5448 +34 +32 +22 +8019 +178 +8020 +8021 +201 +2804 +378 +270 +8022 +6490 +8023 +248 +8024 +8025 +15 +8026 +8027 +19 +8028 +8029 +8030 +2197 +694 +8031 +5780 +8032 +915 +8033 +8034 +8035 +323 +8036 +8037 +8038 +8039 +8040 +8041 +1655 +8042 +1513 +989 +15 +8043 +20 +32 +2694 +8044 +5976 +155 +8045 +8046 +1320 +249 +7215 +8047 +647 +8048 +8049 +8050 +8051 +7522 +5780 +8052 +7565 +3168 +8053 +104 +305 +1710 +4441 +1559 +8054 +4762 +416 +4028 +533 +8055 +2577 +222 +8056 +3669 +8057 +8058 +201 +8059 +8060 +292 +8061 +8062 +8063 +8064 +2993 +7522 +8065 +8066 +8067 +4053 +213 +8068 +8069 +8070 +8071 +14 +114 +815 +4227 +32 +242 +8072 +89 +8073 +179 +8074 +8075 +3 +8076 +19 +8077 +179 +8078 +8079 +8080 +8081 +4261 +14 +8082 +8083 +8084 +19 +1160 +115 +8085 +8086 +8087 +99 +279 +8088 +1889 +8089 +8090 +8091 +4 +8092 +1542 +303 +303 +416 +8093 +201 +102 +109 +8094 +3038 +5764 +8095 +337 +8096 +8097 +8098 +2836 +8099 +8100 +8101 +1071 +228 +8102 +493 +8103 +8104 +8105 +4747 +4390 +112 +8106 +869 +8107 +8108 +8109 +34 +8110 +7027 +8111 +8112 +8113 +8114 +8115 +8116 +8117 +1808 +8118 +415 +8119 +1502 +8120 +249 +8121 +910 +8122 +8123 +8124 +8125 +67 +8126 +8127 +8128 +8129 +57 +1551 +8130 +8131 +137 +8132 +19 +8133 +8134 +8135 +8136 +8137 +8138 +8139 +493 +8140 +8141 +8142 +1710 +286 +8143 +8144 +8145 +528 +8146 +286 +6533 +417 +8147 +77 +815 +1578 +8148 +8149 +8150 +57 +8151 +8152 +8153 +6627 +491 +16 +1453 +1021 +8154 +8155 +8156 +8157 +25 +1989 +8158 +5172 +8159 +8160 +8161 +8162 +2043 +8163 +8164 +8165 +253 +1252 +43 +8166 +5071 +1655 +2043 +8167 +2330 +19 +57 +337 +22 +12 +416 +228 +8168 +8169 +48 +8170 +8171 +8172 +3354 +8173 +8149 +8174 +8175 +8176 +8177 +586 +8178 +1224 +14 +8179 +8180 +8181 +8182 +8183 +8184 +8185 +8186 +646 +2872 +80 +8187 +8188 +8189 +8190 +8191 +751 +8192 +8193 +284 +491 +270 +8194 +5465 +8195 +20 +237 +8196 +15 +8197 +484 +8198 +493 +22 +179 +284 +1637 +4155 +8199 +5992 +8200 +232 +5846 +703 +8201 +8202 +8203 +5623 +2410 +8204 +8205 +8206 +10 +8207 +8208 +6161 +5130 +5080 +8209 +8210 +1249 +6505 +8211 +8212 +665 +5780 +2794 +43 +286 +8213 +5297 +665 +357 +8214 +8151 +2136 +8215 +8216 +8217 +8218 +2 +8219 +57 +2117 +8220 +8221 +331 +519 +8222 +8223 +3 +237 +1684 +8224 +845 +20 +22 +3844 +8225 +15 +35 +1710 +1824 +8226 +8227 +77 +8228 +43 +8229 +4173 +5773 +8230 +8231 +7768 +1817 +8232 +590 +8233 +8234 +8235 +8236 +8237 +286 +8238 +99 +8239 +416 +8240 +104 +8241 +9 +4227 +8242 +8243 +8244 +8245 +178 +137 +22 +8246 +8247 +8248 +213 +8249 +8250 +8251 +3061 +8252 +8253 +8254 +8255 +1042 +8256 +8257 +8258 +8259 +3976 +5838 +4 +1019 +2694 +8260 +5969 +3465 +8261 +1502 +8262 +8263 +8264 +6741 +15 +19 +8265 +270 +8266 +8267 +7522 +1562 +5614 +43 +3055 +8268 +15 +8269 +305 +8270 +2913 +1105 +8271 +176 +104 +8272 +164 +317 +1133 +15 +8273 +1710 +1812 +8274 +8275 +8276 +8277 +303 +8278 +57 +8279 +8280 +4961 +178 +8281 +98 +8282 +15 +484 +6505 +2 +32 +16 +8283 +8284 +5780 +8285 +8286 +12 +8287 +213 +8288 +8289 +8290 +8291 +1533 +398 +8292 +8293 +15 +5202 +1531 +8294 +4752 +19 +8295 +20 +8296 +140 +1354 +1383 +8297 +741 +8298 +8299 +8300 +8301 +8302 +8303 +616 +8304 +703 +1047 +8305 +8306 +8307 +2993 +19 +8308 +1018 +43 +43 +3407 +8309 +8310 +8311 +8312 +1364 +77 +5904 +8313 +8314 +8315 +8316 +8317 +616 +2953 +8318 +57 +8319 +8320 +1013 +590 +342 +8321 +8322 +209 +10 +8323 +4280 +1717 +1425 +8324 +3698 +715 +8325 +1710 +2804 +8326 +541 +8327 +8328 +8329 +8330 +317 +8331 +32 +8332 +8333 +8334 +8335 +662 +398 +8336 +77 +14 +4487 +8337 +8338 +2 +15 +2015 +286 +8339 +155 +286 +2477 +8340 +1738 +815 +8341 +140 +369 +4677 +178 +665 +658 +8342 +8343 +125 +2260 +8344 +354 +8345 +8346 +8347 +989 +436 +43 +22 +8348 +8349 +16 +8350 +8351 +8352 +299 +8353 +15 +15 +2733 +6335 +4422 +817 +8354 +8355 +8356 +74 +1234 +8357 +586 +8358 +8359 +8360 +8361 +5039 +1779 +8362 +8363 +598 +8364 +8365 +57 +317 +586 +57 +15 +12 +8366 +8367 +8368 +8369 +2060 +8370 +8371 +411 +8372 +125 +8373 +8374 +8375 +8376 +1710 +22 +8377 +8378 +43 +15 +8379 +8380 +172 +8381 +14 +6883 +7270 +8382 +413 +8115 +8383 +3626 +8384 +8385 +180 +8386 +57 +8387 +554 +8388 +2988 +671 +19 +5780 +178 +8389 +32 +8390 +8391 +284 +8392 +8393 +213 +8394 +5968 +8395 +8396 +43 +8397 +8398 +764 +6070 +8399 +176 +8400 +284 +303 +8401 +284 +305 +745 +8402 +8403 +8404 +2253 +32 +20 +8405 +2029 +43 +561 +8406 +34 +8407 +337 +8408 +411 +10 +3 +8409 +8410 +8411 +1426 +8412 +8413 +701 +3743 +25 +8414 +8415 +8416 +337 +8417 +8418 +5512 +3514 +861 +1692 +464 +1955 +8419 +57 +22 +8420 +8421 +8422 +5022 +8423 +1513 +411 +155 +8424 +197 +60 +188 +8425 +3732 +8426 +415 +8427 +57 +1153 +8428 +8429 +8430 +60 +8431 +8432 +8433 +8434 +317 +8435 +8436 +176 +6225 +8437 +8438 +624 +8439 +2982 +6736 +8440 +586 +8441 +8442 +7408 +1502 +176 +8443 +286 +8444 +8445 +8446 +213 +8447 +7743 +8448 +554 +703 +1310 +22 +822 +791 +8449 +57 +201 +8450 +6214 +7137 +8451 +15 +8448 +76 +8452 +19 +8453 +842 +2439 +936 +14 +8454 +1364 +8455 +8456 +19 +8457 +8458 +713 +8459 +15 +586 +8460 +8461 +8462 +8463 +8464 +8465 +3543 +8407 +2802 +597 +6400 +8466 +8467 +8468 +8469 +882 +17 +20 +2537 +8470 +8471 +8472 +4461 +10 +8473 +8474 +416 +8475 +8476 +19 +99 +357 +8477 +8478 +8479 +8480 +15 +1727 +8481 +301 +9 +9 +8482 +8483 +19 +248 +4024 +272 +8484 +8485 +8486 +317 +15 +4278 +19 +2762 +2347 +1049 +8487 +156 +15 +8488 +8489 +22 +8490 +8491 +1310 +8492 +178 +8493 +8494 +8495 +8496 +8497 +22 +528 +8498 +436 +8499 +751 +2253 +8500 +8501 +741 +694 +766 +345 +8502 +356 +8503 +8504 +8505 +8506 +137 +8507 +8508 +8509 +8510 +8511 +8512 +8513 +270 +8514 +8515 +4359 +8516 +8517 +8518 +357 +178 +8519 +8520 +1291 +8521 +8522 +740 +370 +2728 +8523 +1956 +764 +8524 +15 +3594 +8525 +8526 +8527 +8528 +8529 +8530 +349 +8531 +10 +3504 +8532 +7896 +200 +586 +700 +8533 +1559 +89 +19 +1401 +8534 +8535 +8536 +8537 +8538 +5561 +3369 +345 +178 +8539 +8540 +8541 +6335 +8542 +8543 +5780 +8544 +8545 +155 +8546 +8547 +2316 +8548 +915 +8549 +8550 +1481 +337 +8551 +8552 +155 +8553 +19 +137 +1109 +8554 +354 +8555 +2459 +1018 +8556 +8557 +15 +910 +8558 +178 +8559 +8560 +1401 +8561 +8562 +8563 +8564 +8565 +1169 +3182 +14 +971 +1574 +6071 +8566 +213 +8567 +9 +272 +8568 +10 +533 +5169 +331 +8569 +8570 +15 +402 +8571 +8572 +8573 +248 +2405 +8574 +114 +8575 +213 +43 +8576 +8577 +284 +8578 +8579 +8580 +8581 +1071 +8582 +8583 +3382 +8584 +8585 +966 +8586 +2289 +5078 +14 +8587 +32 +303 +1385 +900 +915 +8588 +15 +1502 +15 +8589 +8590 +43 +8591 +8592 +8593 +8594 +8595 +3148 +1668 +8596 +8597 +8598 +48 +20 +8599 +3026 +8600 +17 +15 +8601 +8602 +8603 +15 +8604 +541 +8605 +14 +8606 +8607 +873 +8608 +20 +8609 +1082 +1425 +8610 +8611 +119 +8612 +1109 +22 +8613 +3559 +5782 +8614 +89 +8615 +2924 +15 +3729 +8616 +8617 +2427 +60 +989 +597 +15 +303 +8618 +7661 +32 +8619 +8620 +7154 +8621 +2770 +115 +738 +501 +6505 +8622 +8623 +20 +8624 +6581 +4441 +8625 +1018 +8626 +8627 +19 +6010 +8628 +8629 +318 +8630 +7176 +248 +8631 +305 +416 +185 +8632 +10 +8633 +77 +8634 +1232 +8635 +15 +8636 +3251 +8637 +303 +19 +14 +2029 +19 +1100 +43 +8638 +8639 +8640 +4278 +8641 +4855 +19 +399 +16 +8642 +390 +337 +357 +1232 +1021 +6532 +8643 +188 +597 +8644 +8645 +1749 +8646 +915 +32 +1696 +354 +8647 +3055 +15 +983 +6987 +284 +2009 +4388 +8648 +15 +8649 +282 +20 +958 +8650 +270 +8651 +8652 +8653 +1314 +99 +8654 +4116 +8655 +915 +8656 +8657 +8658 +25 +213 +337 +8659 +303 +694 +14 +8660 +8661 +8662 +6761 +1566 +7830 +8663 +8664 +8665 +32 +8666 +8667 +8668 +213 +8669 +15 +8670 +331 +248 +284 +8671 +8672 +8673 +286 +8674 +4387 +8675 +8676 +8677 +8678 +2349 +8679 +8680 +8681 +8682 +8683 +8684 +8685 +8686 +1401 +323 +188 +8687 +8688 +1388 +5585 +2347 +8689 +3908 +8690 +305 +8256 +15 +8691 +8692 +8693 +8694 +8695 +8696 +8697 +8698 +8699 +8700 +8701 +534 +8702 +3279 +8703 +152 +48 +8704 +8705 +15 +8706 +8707 +845 +357 +8708 +152 +8709 +2537 +8710 +8711 +8712 +12 +8713 +8714 +8715 +741 +8716 +936 +8717 +509 +8718 +1513 +3553 +8719 +1515 +8720 +9 +8721 +8722 +1920 +8723 +845 +8724 +8725 +8726 +815 +6070 +676 +8727 +6654 +2009 +1765 +1790 +337 +43 +1234 +8728 +8729 +598 +8730 +57 +8731 +7379 +8732 +8733 +57 +8734 +8735 +43 +6035 +10 +286 +8736 +8737 +8738 +8739 +892 +20 +8740 +8741 +15 +1563 +8742 +4 +398 +665 +694 +284 +8743 +5211 +8744 +8745 +8746 +357 +8747 +8171 +15 +861 +8748 +19 +8749 +4354 +8750 +590 +831 +8751 +8752 +8753 +8754 +8755 +176 +6371 +225 +8756 +8757 +8758 +3 +491 +8759 +8760 +8761 +8762 +8763 +20 +8764 +8765 +2537 +1502 +8766 +1992 +8767 +1234 +484 +1112 +6594 +8768 +8769 +7479 +2446 +2234 +22 +3626 +597 +415 +8770 +1012 +4650 +1244 +8771 +111 +817 +8772 +15 +8773 +284 +1571 +349 +67 +738 +279 +225 +19 +317 +8774 +138 +2139 +8775 +493 +8776 +8777 +8778 +8779 +22 +248 +8780 +8781 +8782 +7675 +8783 +43 +15 +67 +768 +8784 +8785 +506 +8786 +8787 +8788 +1232 +1563 +19 +3598 +4650 +8789 +4070 +8790 +8791 +322 +8792 +19 +170 +8793 +8794 +137 +32 +225 +8795 +8796 +8797 +8798 +8799 +2338 +8800 +7836 +8280 +3828 +8801 +8802 +4298 +8803 +8804 +8805 +8806 +4406 +323 +8807 +10 +1166 +3553 +7176 +32 +8808 +8809 +8810 +33 +6441 +178 +8811 +8812 +915 +15 +286 +791 +8813 +8814 +3790 +6602 +665 +15 +3317 +8815 +8816 +2410 +303 +15 +8817 +8818 +1010 +210 +19 +3559 +4677 +8819 +15 +3252 +8820 +8821 +3827 +8822 +10 +8823 +8824 +8825 +3054 +104 +248 +2308 +213 +8826 +2619 +237 +8827 +1829 +2338 +597 +8828 +2619 +8829 +286 +2537 +2988 +152 +303 +8830 +8831 +800 +138 +8832 +9 +8833 +5780 +303 +501 +32 +8834 +15 +1834 +3739 +7105 +8835 +8836 +892 +8837 +8838 +34 +457 +5780 +8839 +8840 +354 +7139 +8841 +8842 +8843 +8844 +8845 +1965 +8846 +1364 +8847 +155 +8848 +4 +180 +1415 +8849 +5780 +8850 +1200 +2692 +8851 +8852 +487 +286 +155 +8853 +2694 +155 +8854 +8855 +15 +8856 +15 +3 +8857 +8858 +8859 +4283 +8860 +8861 +4954 +8862 +15 +8863 +8864 +8865 +8866 +8867 +8868 +4624 +8869 +1364 +8870 +8871 +2260 +179 +1026 +8872 +5080 +8873 +8874 +8875 +8876 +464 +8877 +6161 +6412 +8878 +8879 +16 +873 +5780 +8880 +5825 +6214 +8881 +1217 +48 +222 +8882 +8883 +345 +8884 +8885 +201 +137 +16 +2347 +1262 +8886 +8887 +57 +43 +8888 +8889 +415 +8890 +57 +8891 +2728 +8892 +19 +464 +8893 +8894 +8895 +8896 +8897 +386 +3029 +349 +872 +4430 +8898 +8899 +8900 +170 +8901 +8902 +4512 +3726 +8903 +1047 +1169 +8904 +8905 +8906 +701 +8907 +8908 +8909 +8910 +8911 +8912 +8913 +8914 +8915 +8916 +8917 +8918 +8919 +8920 +8921 +1870 +8922 +3559 +1287 +5820 +8923 +6878 +140 +188 +8924 +2841 +15 +32 +1870 +8925 +3976 +8926 +19 +8927 +8928 +541 +6304 +8929 +1744 +48 +8930 +1384 +915 +2347 +8931 +43 +8932 +8933 +694 +164 +8934 +8935 +741 +8936 +8937 +9 +43 +8938 +2260 +8939 +1232 +8940 +4685 +303 +2540 +8941 +554 +284 +15 +1257 +8942 +8943 +8944 +1856 +8945 +8946 +8947 +8948 +8949 +3553 +8950 +8951 +8952 +8953 +2476 +8954 +665 +142 +8955 +936 +155 +8956 +5912 +8957 +15 +137 +284 +286 +495 +57 +22 +8958 +8959 +8960 +14 +8961 +4012 +1870 +8962 +43 +8963 +8964 +8965 +8966 +15 +15 +3829 +3743 +6796 +8967 +519 +8968 +703 +648 +57 +232 +5650 +8969 +8970 +8971 +1847 +8972 +8973 +1465 +8974 +8975 +8976 +2849 +8977 +665 +8978 +4490 +8979 +274 +112 +286 +8980 +8981 +1907 +8982 +8983 +32 +8984 +8985 +20 +8986 +4422 +8987 +1575 +1149 +8988 +514 +8989 +8990 +2341 +15 +109 +323 +3930 +8991 +8992 +43 +14 +8993 +8994 +8995 +415 +8996 +19 +8997 +536 +2728 +32 +8998 +8999 +9000 +15 +9001 +3466 +9002 +9003 +2 +155 +286 +5304 +9004 +9005 +6260 +9006 +15 +8645 +15 +554 +9007 +9008 +9009 +9010 +179 +402 +4907 +43 +77 +9011 +10 +1907 +20 +9012 +123 +57 +9013 +9014 +9015 +303 +9016 +9017 +1606 +9018 +398 +9019 +201 +237 +337 +9020 +201 +9021 +15 +6518 +89 +9022 +284 +9023 +12 +984 +4963 +9024 +77 +8110 +9025 +9026 +9027 +5992 +9028 +892 +1956 +9029 +9030 +98 +43 +9 +647 +345 +3 +9031 +20 +15 +9032 +2314 +4297 +5770 +9033 +337 +9034 +179 +9035 +9036 +25 +301 +736 +19 +5731 +9037 +345 +464 +692 +9038 +9039 +9040 +9041 +9042 +19 +493 +1465 +9043 +616 +9044 +9045 +4693 +270 +9046 +916 +9047 +416 +9048 +1013 +9049 +9050 +9051 +1984 +9052 +416 +9053 +373 +9 +9054 +9055 +9056 +9057 +2349 +286 +19 +5780 +9058 +1426 +9059 +19 +9060 +2824 +1655 +9061 +317 +9062 +9063 +9064 +9065 +915 +9066 +9067 +9068 +3205 +9 +57 +9069 +501 +178 +9070 +9071 +1514 +5285 +1425 +9072 +1900 +32 +9073 +19 +9074 +19 +32 +9075 +2835 +15 +9076 +1955 +104 +9 +4364 +416 +9077 +9078 +9079 +9080 +9081 +533 +9082 +14 +9083 +2865 +9084 +9085 +5313 +9086 +1834 +9087 +225 +9088 +15 +4278 +286 +9089 +284 +7716 +9090 +43 +9091 +35 +9092 +2625 +284 +284 +9093 +1100 +38 +89 +6595 +248 +2000 +9094 +5780 +9095 +9096 +9097 +2770 +9098 +270 +9099 +9100 +9101 +237 +7969 +1674 +248 +2790 +9102 +9103 +9104 +9105 +9106 +43 +9107 +1716 +1559 +5614 +9108 +1817 +7982 +249 +9109 +180 +9110 +9111 +9112 +9113 +9114 +9115 +104 +25 +3406 +8146 +586 +3543 +2323 +9116 +586 +9117 +9118 +9119 +9120 +4873 +484 +9121 +738 +345 +4634 +331 +9122 +9123 +9124 +9125 +9126 +9127 +416 +9128 +357 +286 +9129 +5217 +9130 +2824 +694 +9131 +9132 +57 +286 +9133 +9134 +3601 +9135 +58 +176 +19 +9136 +9137 +7154 +7108 +9138 +9139 +1612 +1169 +736 +9140 +9141 +892 +32 +9142 +1082 +5908 +9143 +9144 +9145 +865 +2577 +4198 +57 +9146 +357 +9147 +9148 +43 +303 +201 +9149 +9150 +1531 +15 +5415 +57 +586 +270 +9151 +3279 +9152 +3745 +15 +9153 +9154 +46 +9155 +6513 +1232 +15 +815 +831 +9156 +9157 +2559 +491 +9158 +9159 +3330 +14 +9160 +9161 +19 +1013 +566 +9162 +9163 +9164 +9165 +4088 +9166 +9167 +4850 +399 +286 +57 +15 +415 +9168 +22 +9169 +9170 +9171 +694 +713 +9172 +32 +244 +9173 +8297 +2427 +7030 +493 +9174 +9175 +9176 +9177 +89 +533 +60 +9178 +9179 +15 +66 +9180 +448 +10 +9181 +9182 +46 +9183 +5780 +43 +927 +586 +8444 +19 +764 +9184 +9185 +6877 +9186 +213 +15 +9187 +9188 +910 +9189 +9190 +2018 +9191 +337 +9192 +972 +9193 +20 +115 +22 +201 +9194 +9195 +5780 +6372 +9196 +209 +9197 +14 +2806 +57 +416 +104 +303 +665 +741 +9198 +9199 +1357 +1961 +5825 +188 +9200 +492 +817 +436 +9201 +43 +99 +112 +1401 +9202 +248 +9203 +9204 +57 +9205 +9206 +9207 +9208 +2706 +99 +9209 +43 +9210 +379 +9211 +9212 +9213 +9214 +3328 +9215 +9216 +9217 +1817 +446 +7014 +9218 +9219 +9220 +4512 +213 +872 +9221 +9222 +817 +15 +179 +4012 +22 +9223 +745 +9224 +9225 +342 +3376 +9226 +9227 +9228 +9229 +1224 +464 +9230 +1364 +1710 +9231 +9232 +2356 +9233 +286 +665 +9234 +48 +248 +9235 +1310 +9236 +1987 +9237 +284 +9238 +8566 +9239 +9240 +248 +9241 +9242 +5908 +4070 +7072 +70 +2015 +5623 +1077 +9243 +5938 +248 +284 +248 +15 +4230 +9244 +9245 +12 +9246 +9247 +9248 +43 +9249 +9250 +9251 +586 +416 +9252 +213 +9 +7595 +303 +9253 +9254 +5797 +9255 +9256 +4963 +1720 +9257 +9258 +9259 +9260 +141 +9261 +9262 +77 +213 +9263 +2446 +616 +269 +9264 +9265 +237 +9266 +284 +6965 +32 +484 +9267 +9268 +137 +9269 +34 +9270 +237 +9271 +9272 +7746 +9273 +9274 +9275 +9276 +9277 +5702 +7666 +9278 +402 +9279 +519 +9280 +9281 +9282 +8091 +616 +9283 +9284 +9285 +9286 +9287 +9288 +1160 +9289 +9290 +7276 +9291 +9292 +20 +9293 +509 +9294 +9295 +43 +9296 +9297 +9298 +2625 +5601 +1574 +19 +379 +9 +8455 +22 +3055 +20 +9299 +4915 +9300 +9301 +228 +9302 +9303 +554 +15 +9304 +9305 +540 +9306 +3233 +9307 +9308 +9309 +9310 +842 +1870 +208 +741 +9311 +9312 +19 +9313 +5410 +9314 +9315 +12 +5780 +9005 +111 +9316 +9317 +7194 +15 +7610 +1300 +9318 +9319 +9320 +9321 +3978 +9322 +1580 +15 +20 +1655 +9323 +5299 +1775 +9324 +597 +19 +20 +9325 +9326 +32 +5825 +35 +9327 +22 +9328 +9329 +9330 +9331 +9332 +1637 +9333 +8778 +1470 +9334 +9335 +77 +9336 +1212 +57 +14 +9337 +286 +348 +1912 +114 +286 +9338 +745 +7350 +9339 +9340 +1425 +9341 +48 +172 +9342 +493 +57 +415 +9343 +9344 +9345 +9346 +9347 +345 +9348 +9349 +9350 +9351 +248 +9352 +9353 +9354 +284 +9355 +9356 +7429 +9357 +9358 +357 +9359 +178 +242 +9360 +9361 +9362 +9363 +697 +9364 +397 +493 +9365 +1169 +9366 +9367 +770 +15 +9368 +9123 +20 +9369 +665 +32 +9370 +9371 +15 +9372 +9373 +9374 +9375 +248 +1364 +9376 +9377 +707 +5627 +357 +1944 +5780 +9378 +67 +9039 +9379 +9380 +1001 +8351 +849 +2043 +14 +9381 +9382 +2157 +3172 +9383 +9384 +4551 +9385 +4294 +910 +1875 +14 +1356 +9386 +43 +9387 +9388 +48 +9389 +248 +1234 +5780 +1529 +9390 +305 +6741 +17 +14 +43 +249 +9391 +43 +9392 +43 +9393 +9394 +476 +8946 +9395 +9396 +9397 +4982 +22 +9398 +9399 +9400 +7743 +317 +32 +20 +9401 +2206 +671 +9402 +590 +1612 +9403 +9404 +77 +9405 +9406 +43 +9407 +9408 +16 +9409 +337 +402 +9410 +43 +9411 +915 +9412 +977 +9413 +9414 +9415 +303 +9416 +671 +201 +5431 +9417 +283 +583 +9418 +15 +9419 +9420 +3417 +671 +209 +9421 +861 +9422 +317 +248 +9423 +9424 +33 +303 +9425 +2419 +568 +48 +9426 +1401 +19 +9427 +9428 +9429 +57 +9430 +416 +354 +3128 +9431 +22 +1377 +9432 +9433 +9434 +2944 +9435 +9436 +5582 +15 +9437 +286 +15 +10 +9438 +9439 +1470 +9440 +201 +9441 +2318 +1291 +286 +9442 +9443 +9444 +827 +9445 +9446 +178 +9395 +3944 +9447 +9448 +3964 +15 +9449 +9450 +19 +484 +9451 +9452 +4634 +9453 +1927 +19 +9454 +9455 +15 +1364 +9456 +9457 +9458 +9459 +15 +3599 +9460 +9461 +5344 +9462 +25 +9463 +245 +1840 +178 +9464 +9465 +1584 +4317 +2824 +9466 +9467 +354 +9468 +751 +792 +9469 +9470 +5218 +9471 +2841 +43 +430 +2128 +9472 +9473 +32 +9474 +9475 +48 +1710 +9476 +9477 +1377 +9478 +9479 +9480 +9481 +9482 +9483 +9484 +185 +2619 +9485 +9486 +9487 +20 +1562 +2911 +9488 +586 +5877 +9395 +9 +3330 +9489 +9490 +9491 +67 +9492 +2944 +134 +9493 +15 +9494 +5654 +892 +2047 +1710 +3030 +201 +19 +597 +25 +1961 +9495 +14 +4278 +9496 +648 +9497 +9498 +9499 +225 +19 +22 +9500 +3743 +354 +9501 +983 +2835 +9502 +9503 +9504 +249 +9505 +15 +4518 +9506 +9507 +43 +9508 +3852 +9509 +9510 +1425 +1604 +9511 +3961 +9512 +9513 +9514 +9515 +9516 +4583 +9517 +9518 +10 +209 +1100 +9519 +9520 +9521 +9522 +9523 +4012 +9524 +32 +9525 +1051 +9526 +7291 +9527 +9528 +9529 +1021 +189 +286 +3442 +9530 +6384 +303 +337 +2410 +197 +9531 +9532 +4388 +9533 +3148 +9534 +22 +9535 +9536 +9537 +554 +9538 +9539 +1232 +4439 +554 +597 +4426 +4 +9540 +155 +9541 +9542 +33 +9543 +9544 +930 +514 +109 +861 +1282 +402 +554 +357 +2764 +9545 +9546 +3599 +9547 +19 +730 +12 +9548 +164 +586 +9549 +1559 +3417 +7238 +9550 +791 +9551 +10 +4070 +271 +9552 +15 +9553 +9554 +9555 +9556 +5299 +415 +1027 +415 +237 +9557 +9558 +9559 +57 +249 +25 +9560 +2697 +822 +9561 +9562 +6505 +352 +9563 +671 +9564 +22 +363 +1116 +548 +9565 +501 +34 +57 +9566 +9567 +9568 +1743 +9569 +379 +9570 +5208 +9571 +416 +7137 +8653 +9572 +179 +9573 +9574 +415 +3525 +9575 +14 +5820 +736 +9576 +178 +176 +914 +2764 +9577 +681 +9578 +15 +597 +213 +338 +9579 +9580 +213 +533 +416 +303 +25 +9395 +4714 +9581 +9395 +4506 +1172 +9395 +9582 +9583 +9584 +1295 +15 +66 +6086 +32 +15 +1710 +315 +19 +9585 +9395 +32 +9586 +303 +5623 +5039 +936 +554 +738 +9587 +9588 +9589 +9590 +1234 +9591 +1513 +7032 +9592 +9593 +178 +9594 +9595 +9596 +1010 +2728 +9597 +32 +9598 +4042 +9395 +9395 +9599 +58 +9600 +188 +1927 +22 +9601 +9602 +9603 +9604 +9605 +9606 +9607 +8465 +1212 +9608 +9395 +9395 +1710 +1540 +274 +114 +5923 +222 +9609 +9395 +9610 +270 +9611 +1606 +936 +9612 +22 +9613 +9614 +398 +248 +9615 +9616 +9617 +4419 +9618 +9619 +9620 +9621 +9622 +9323 +3964 +9623 +9624 +9625 +178 +3508 +9626 +1710 +9627 +188 +9628 +9629 +155 +2841 +284 +6612 +4165 +25 +4764 +9630 +9631 +337 +9632 +1637 +9633 +9634 +15 +284 +9635 +8414 +9636 +9637 +9638 +9639 +248 +9640 +317 +1262 +7429 +9641 +2026 +248 +9642 +925 +9643 +9644 +9645 +484 +9646 +761 +9647 +9648 +9649 +286 +16 +9650 +9651 +8653 +9652 +3427 +10 +9653 +43 +9654 +9655 +249 +3968 +4 +9656 +416 +9657 +43 +8297 +9658 +9659 +5400 +9660 +2309 +9661 +15 +5007 +286 +242 +9662 +464 +9663 +1514 +9664 +9665 +249 +9666 +4982 +317 +43 +9667 +48 +9668 +9669 +284 +9670 +9671 +9672 +540 +373 +7014 +9395 +9673 +9674 +179 +134 +43 +9675 +43 +377 +9676 +20 +15 +9677 +9678 +411 +9679 +8348 +19 +5577 +1386 +9395 +9680 +1018 +9681 +305 +686 +9210 +640 +9682 +3291 +9395 +9395 +9683 +9684 +842 +892 +9395 +9685 +1293 +9 +9686 +9687 +713 +9688 +5908 +9395 +9689 +9395 +1867 +1442 +9690 +1716 +9691 +25 +9692 +9693 +9694 +22 +1502 +9695 +2694 +9696 +713 +9697 +5326 +20 +9698 +9699 +9395 +15 +9 +9700 +9701 +9702 +19 +9119 +92 +9395 +9395 +9703 +9395 +9 +9395 +9704 +20 +2787 +15 +9705 +14 +484 +19 +299 +4 +3481 +9706 +9707 +225 +9708 +373 +3330 +9709 +2591 +9710 +1425 +43 +4364 +2694 +9711 +19 +9712 +9713 +9714 +9715 +9716 +9717 +2944 +9718 +9719 +14 +2694 +15 +9720 +9721 +1291 +43 +9722 +9723 +14 +9724 +9725 +2260 +648 +9395 +1083 +9726 +9727 +802 +237 +5080 +9728 +2430 +5780 +1808 +707 +2694 +2787 +5780 +9729 +9730 +9731 +15 +9732 +9395 +9733 +9395 +9395 +9734 +9395 +554 +9735 +9736 +9737 +9738 +303 +9739 +19 +9740 +9741 +1870 +3296 +1300 +9742 +3 +9743 +210 +15 +9744 +2029 +249 +357 +337 +2709 +57 +2 +4764 +416 +9745 +9746 +9747 +66 +32 +9748 +43 +20 +4042 +15 +9749 +9395 +9750 +9 +9751 +9752 +9753 +10 +736 +9754 +9755 +9756 +301 +114 +9757 +9758 +9759 +2430 +9760 +9761 +35 +201 +9762 +354 +9763 +9764 +9765 +9766 +9767 +98 +8320 +9768 +201 +19 +286 +19 +10 +192 +8249 +9769 +3514 +9395 +3034 +554 +9770 +337 +14 +9771 +464 +9772 +9773 +9774 +4714 +9775 +9776 +3958 +9777 +9395 +484 +32 +9778 +10 +9779 +5451 +354 +9780 +3995 +9395 +597 +22 +248 +14 +4269 +9781 +9782 +9783 +337 +398 +9784 +140 +9785 +9786 +178 +9787 +9395 +9788 +9789 +303 +3989 +15 +2289 +9790 +9791 +9792 +179 +9793 +822 +9794 +9795 +1502 +6616 +4855 +9796 +9395 +9797 +201 +153 +4 +9798 +9799 +317 +554 +493 +32 +694 +9800 +5837 +1655 +9801 +4 +9802 +9803 +9804 +43 +14 +668 +9020 +9805 +155 +16 +89 +32 +8685 +272 +357 +9806 +9807 +1808 +9808 +5169 +9809 +9810 +2243 +16 +9811 +9812 +9813 +32 +286 +15 +9814 +9815 +9816 +7137 +9817 +9818 +9819 +35 +9820 +9821 +185 +9822 +8344 +9823 +9824 +9825 +2403 +9826 +5900 +9827 +15 +9828 +9829 +1710 +14 +9830 +1790 +286 +48 +9831 +9832 +248 +6364 +9395 +248 +9833 +249 +9834 +764 +9835 +9836 +9837 +3100 +9838 +9839 +9840 +9841 +9842 +9843 +141 +9395 +2697 +9844 +9845 +9395 +9395 +9846 +9847 +9848 +9849 +286 +9850 +9851 +337 +98 +9395 +2 +9852 +9853 +2971 +9395 +9854 +415 +9855 +703 +115 +9856 +9857 +14 +9858 +32 +892 +213 +9859 +9860 +57 +9861 +9862 +9863 +9864 +9395 +337 +9865 +2919 +43 +9866 +188 +9867 +168 +9868 +9869 +3302 +9870 +9871 +6594 +9872 +692 +9780 +9873 +32 +9874 +4388 +9875 +6445 +4631 +1542 +15 +9876 +9877 +1013 +43 +1637 +9878 +34 +9879 +9880 +138 +9881 +249 +4855 +9882 +155 +9883 +9884 +7343 +9395 +5198 +57 +694 +43 +9395 +9885 +286 +9886 +3407 +238 +286 +9887 +2697 +9888 +9889 +3698 +15 +9890 +9891 +9395 +1082 +213 +9892 +14 +303 +9 +705 +9893 +9894 +9895 +2157 +9896 +8889 +9395 +9897 +7600 +9898 +9899 +9900 +2035 +9901 +9902 +1360 +9903 +9904 +9905 +9395 +35 +9906 +5792 +15 +1605 +248 +9907 +9908 +9909 +57 +3978 +9910 +2655 +9911 +9912 +9395 +201 +554 +1015 +9913 +57 +484 +9914 +9915 +179 +9916 +9917 +286 +43 +286 +9918 +9919 +9920 +345 +9921 +9922 +8853 +222 +3491 +694 +3055 +35 +9923 +32 +9924 +1710 +9925 +791 +3421 +9926 +9927 +270 +9395 +7580 +5314 +9928 +9929 +9930 +98 +99 +15 +9931 +15 +9932 +22 +590 +9395 +933 +2049 +25 +9309 +4747 +7183 +9933 +9934 +1026 +9935 +25 +9936 +9 +10 +8053 +176 +155 +15 +14 +5774 +1364 +9937 +9938 +9939 +9940 +178 +9941 +180 +9942 +6850 +12 +9943 +15 +19 +1230 +9944 +9945 +2849 +6771 +9946 +4982 +32 +9947 +8282 +9948 +125 +5127 +303 +9949 +9950 +9951 +9952 +5791 +9953 +354 +9954 +9955 +188 +9956 +9957 +9958 +274 +9959 +4075 +9960 +671 +9961 +411 +4028 +9962 +20 +9963 +1232 +222 +35 +155 +19 +9964 +9965 +9395 +303 +9966 +9 +872 +694 +237 +1513 +9967 +6029 +22 +9968 +5022 +286 +164 +1710 +9969 +9970 +2 +89 +9971 +115 +9972 +597 +8670 +9973 +178 +9974 +2619 +464 +9975 +9976 +9977 +24 +9978 +115 +9979 +9980 +9981 +9982 +827 +1870 +9983 +286 +3790 +9984 +2619 +9985 +3406 +1464 +9986 +647 +9987 +9988 +9989 +248 +284 +8437 +9990 +213 +337 +9991 +9992 +9993 +9994 +8602 +4185 +9995 +4 +9996 +9997 +9998 +9999 +10000 +10001 +2668 +15 +15 +179 +10002 +9395 +1987 +10003 +10004 +464 +32 +10005 +15 +176 +20 +286 +10006 +10 +10007 +2289 +10008 +10009 +2824 +10010 +484 +2356 +10011 +2009 +14 +9396 +6559 +10012 +10013 +10014 +736 +3407 +10015 +10016 +19 +10017 +7376 +10018 +1395 +10019 +10020 +10021 +10022 +10023 +10024 +8783 +9 +10025 +10026 +15 +10027 +648 +32 +1021 +57 +15 +286 +15 +10028 +10029 +286 +10030 +10031 +272 +10032 +10033 +331 +9395 +9074 +4278 +20 +10034 +1425 +19 +3353 +248 +10035 +10036 +10037 +15 +3251 +8367 +10038 +10039 +1559 +10040 +10041 +2834 +5780 +2035 +701 +20 +213 +19 +248 +10042 +10043 +10044 +10045 +284 +32 +10046 +10047 +10048 +1300 +7276 +109 +155 +2770 +10049 +1655 +10050 +10051 +10052 +1531 +694 +1026 +3507 +89 +10053 +10054 +389 +2471 +125 +10055 +10056 +10057 +10058 +3104 +10059 +10060 +14 +10061 +10062 +10063 +2924 +10064 +10065 +10066 +10067 +10068 +43 +10069 +10070 +10071 +250 +1716 +10072 +10073 +14 +10074 +10075 +1705 +77 +10076 +1710 +10077 +10078 +10079 +10080 +10081 +10082 +10083 +2309 +10084 +10085 +1169 +514 +3 +15 +10086 +213 +242 +152 +10087 +10088 +1604 +305 +10089 +10090 +9395 +1536 +10091 +10092 +10093 +10094 +248 +286 +10095 +16 +6496 +16 +9 +10096 +10097 +7835 +398 +10098 +379 +5900 +10099 +242 +10100 +337 +213 +10101 +10102 +10103 +178 +337 +201 +1364 +9395 +10104 +43 +10105 +10106 +10063 +10107 +20 +10108 +10109 +10110 +648 +9095 +271 +3055 +10111 +6243 +10112 +705 +3139 +305 +10113 +643 +10114 +484 +15 +284 +10115 +7531 +10116 +10117 +861 +10118 +2449 +10119 +10120 +15 +10121 +1382 +10122 +10123 +892 +10124 +10125 +10126 +10127 +10128 +10129 +12 +10130 +10131 +915 +10132 +57 +10133 +1710 +464 +10134 +7183 +10135 +10136 +10137 +1026 +1508 +10138 +6050 +1513 +10139 +849 +12 +10140 +10141 +10142 +213 +303 +10143 +10144 +10145 +99 +57 +1529 +179 +19 +10146 +514 +10147 +15 +57 +10148 +10149 +19 +10150 +10151 +10152 +10153 +10154 +102 +10155 +10156 +5561 +337 +822 +1119 +10157 +859 +249 +10158 +1575 +2281 +10159 +10160 +2550 +9037 +1524 +10161 +4918 +10162 +10163 +10164 +15 +3818 +305 +4 +77 +2836 +501 +716 +10165 +415 +1425 +32 +286 +822 +10166 +10167 +249 +10168 +178 +9 +10169 +305 +9123 +10170 +176 +10171 +331 +10172 +10173 +10174 +10175 +10176 +5561 +10177 +6214 +301 +703 +10178 +10179 +10180 +428 +6513 +3059 +10181 +10182 +10183 +10184 +10185 +57 +14 +10186 +10187 +1885 +10188 +10189 +19 +616 +19 +15 +10190 +10191 +10192 +48 +10193 +10 +10194 +10195 +10196 +1710 +10197 +9011 +1529 +4 +10198 +10199 +317 +10200 +152 +178 +3858 +10201 +15 +152 +8724 +910 +10202 +15 +25 +703 +1529 +10203 +10204 +10205 +10206 +583 +413 +3787 +1001 +357 +98 +20 +1465 +10207 +491 +305 +10208 +10209 +76 +10210 +10211 +286 +721 +10212 +10213 +10214 +10215 +10216 +1392 +10217 +10218 +10219 +2865 +598 +10220 +10221 +4075 +10222 +10223 +790 +10224 +10225 +10226 +4278 +99 +48 +7835 +10227 +1696 +14 +10228 +19 +10229 +42 +6507 +10230 +6364 +2593 +1513 +57 +4702 +10231 +303 +80 +10232 +77 +910 +10233 +303 +9395 +43 +10234 +10235 +10236 +22 +10237 +9178 +10238 +554 +48 +1531 +284 +317 +10239 +1817 +6171 +5223 +1604 +345 +8605 +10240 +19 +58 +2015 +10241 +10242 +6644 +337 +10243 +284 +4 +10244 +10245 +415 +32 +10246 +16 +10247 +10248 +286 +10249 +10250 +10251 +1047 +10252 +10253 +284 +10254 +10255 +10256 +1533 +10257 +2260 +89 +213 +10258 +10259 +2449 +337 +10260 +10261 +694 +43 +10262 +10263 +286 +872 +32 +10264 +1718 +5990 +4061 +10265 +5216 +32 +10266 +936 +411 +10224 +10267 +77 +10268 +4422 +1749 +43 +32 +10269 +10270 +9 +1018 +43 +10271 +286 +43 +10272 +10273 +10274 +10275 +10276 +845 +8338 +10277 +10278 +10064 +10279 +1502 +10280 +379 +10281 +10282 +14 +10283 +1514 +10284 +286 +2135 +237 +10285 +32 +2064 +10286 +10287 +501 +1011 +4530 +10288 +651 +15 +10289 +250 +910 +10290 +12 +6179 +3 +373 +10291 +200 +10292 +5438 +8593 +10293 +16 +5022 +8053 +10294 +10295 +5410 +20 +1991 +10296 +10297 +1513 +19 +10298 +10299 +10300 +1172 +15 +519 +10301 +1444 +10302 +10303 +9382 +43 +448 +213 +590 +10304 +349 +10305 +10306 +493 +248 +57 +32 +10307 +10308 +10309 +77 +2019 +10310 +10311 +286 +845 +142 +10312 +1425 +10313 +10314 +10315 +284 +5326 +6359 +10316 +19 +10317 +10318 +10319 +10320 +48 +10321 +10322 +3238 +1364 +10323 +6915 +10 +10324 +1692 +10325 +10326 +2537 +305 +15 +284 +10327 +10328 +1100 +10329 +10330 +15 +5839 +564 +365 +10331 +7624 +10332 +15 +286 +357 +10333 +1012 +1867 +10334 +10335 +10336 +15 +10337 +10338 +10339 +10340 +4024 +10341 +10342 +92 +554 +19 +10343 +10344 +10345 +10346 +10347 +8230 +10348 +4452 +10349 +10350 +694 +3413 +10230 +411 +613 +15 +10351 +10352 +245 +15 +10353 +358 +10354 +9037 +10355 +1018 +1558 +10356 +99 +5601 +222 +10357 +484 +10358 +4048 +1212 +1800 +1956 +10359 +10360 +10361 +548 +10362 +10363 +10364 +10235 +3139 +179 +10365 +966 +554 +10366 +398 +915 +10367 +2526 +10368 +10369 +43 +10370 +484 +14 +286 +10371 +179 +10372 +10373 +464 +1529 +137 +10374 +8946 +10375 +10376 +10377 +337 +10378 +337 +10379 +10380 +10381 +15 +42 +213 +303 +10382 +2043 +4918 +10383 +1356 +10384 +3385 +9210 +4116 +10385 +77 +3127 +337 +10386 +77 +213 +10387 +337 +7032 +19 +1531 +10388 +3544 +2314 +10313 +10389 +10390 +4963 +3032 +5923 +736 +5773 +10391 +10392 +222 +586 +10393 +10394 +345 +10395 +10396 +10397 +2463 +10398 +19 +4108 +10399 +342 +7380 +2993 +248 +20 +5780 +10400 +6121 +345 +9837 +10401 +10402 +3178 +2135 +10403 +354 +10404 +10405 +10406 +10407 +10408 +1047 +10409 +2259 +2995 +573 +337 +4907 +10410 +10411 +10412 +112 +10413 +10414 +303 +10415 +10416 +464 +7379 +10417 +6289 +10418 +57 +484 +10419 +15 +7729 +1612 +337 +10420 +337 +10421 +16 +10422 +278 +10423 +66 +1052 +48 +2243 +286 +9144 +303 +10424 +10425 +35 +1668 +4317 +115 +10426 +514 +10427 +10428 +10429 +6920 +3061 +10430 +2526 +3225 +10431 +10432 +2427 +10433 +250 +10434 +77 +70 +10435 +4334 +10436 +10437 +1100 +2347 +10438 +20 +647 +2306 +178 +10439 +10440 +827 +10441 +3470 +1181 +10442 +10443 +10444 +10445 +66 +19 +270 +10446 +15 +188 +9583 +386 +10447 +10448 +14 +10449 +2724 +10450 +2325 +10451 +6962 +188 +10452 +2776 +3010 +10453 +1410 +10454 +10455 +10456 +10457 +10458 +323 +1829 +10459 +7600 +369 +10460 +20 +10461 +7442 +10462 +2627 +3055 +1149 +12 +464 +10463 +10464 +1425 +10465 +10466 +10467 +10468 +10439 +10469 +10470 +57 +278 +10471 +1149 +10472 +10473 +10474 +10475 +10476 +176 +10477 +10478 +10479 +357 +10480 +10481 +738 +10482 +397 +493 +8593 +845 +1596 +2971 +10483 +8508 +6543 +10484 +284 +741 +77 +10485 +10486 +179 +10487 +213 +10488 +10489 +7806 +10490 +337 +10491 +10463 +586 +3660 +337 +10492 +9 +5780 +15 +4032 +1912 +2804 +1710 +10493 +415 +303 +43 +10494 +10495 +15 +282 +446 +859 +67 +286 +305 +10496 +10497 +7968 +10498 +769 +2015 +77 +179 +317 +10499 +10500 +3842 +5990 +3978 +155 +1364 +8338 +225 +590 +5439 +60 +10501 +10502 +2397 +176 +936 +248 +10503 +32 +10504 +10505 +5869 +10506 +10507 +10508 +10509 +1234 +2577 +10510 +7908 +10511 +10512 +176 +1956 +1932 +10513 +10514 +2406 +284 +10515 +10516 +1853 +32 +10517 +354 +2653 +809 +10518 +10519 +10520 +43 +683 +10521 +286 +1605 +10522 +10523 +242 +10524 +10525 +10526 +10527 +248 +10528 +80 +10529 +14 +10530 +10531 +1251 +861 +10532 +303 +10533 +284 +5717 +176 +10534 +248 +10535 +10536 +57 +10537 +331 +10538 +910 +10539 +248 +10540 +32 +2 +10541 +736 +10542 +10543 +1808 +10544 +9148 +2988 +8392 +9 +317 +10545 +176 +10546 +10547 +10548 +1580 +10549 +3709 +6122 +10550 +10551 +303 +10552 +278 +10553 +10554 +646 +38 +14 +4631 +820 +10555 +10556 +10557 +201 +6110 +10558 +10559 +57 +964 +874 +5006 +5797 +10560 +4075 +10561 +10562 +2577 +10563 +10564 +5316 +10565 +10566 +286 +57 +48 +14 +2768 +7357 +10567 +317 +10568 +12 +10569 +10570 +1529 +10571 +10572 +25 +1021 +10573 +3660 +10574 +10575 +331 +10576 +282 +10577 +1100 +671 +270 +142 +10578 +566 +586 +1382 +10579 +10580 +1291 +10581 +10582 +1364 +5261 +10583 +10584 +10585 +301 +10586 +10587 +10588 +15 +5880 +10589 +10590 +6317 +931 +32 +34 +10591 +9395 +5629 +12 +10592 +1083 +10593 +1234 +10594 +10595 +10596 +8532 +10597 +741 +2347 +32 +586 +188 +213 +10598 +213 +155 +10599 +32 +5291 +10600 +19 +337 +98 +10601 +745 +303 +10602 +493 +10603 +1481 +77 +10604 +248 +6822 +369 +19 +10605 +10606 +10607 +10608 +32 +10609 +464 +10610 +10611 +10612 +4 +10613 +5153 +4856 +10614 +10615 +10616 +10617 +10618 +10619 +2197 +10620 +357 +1533 +92 +936 +10621 +514 +2035 +10622 +303 +3447 +185 +48 +10623 +861 +303 +354 +7419 +3523 +540 +357 +1775 +10624 +2804 +10625 +943 +19 +5145 +14 +10626 +10627 +694 +10628 +3546 +10629 +1401 +1012 +10630 +14 +3055 +8685 +10631 +17 +10632 +10633 +10634 +10635 +10636 +10637 +10638 +57 +10639 +4624 +48 +873 +10640 +10641 +10642 +10643 +947 +10644 +10645 +19 +10646 +10647 +15 +1364 +10648 +3964 +10649 +10650 +2 +284 +10651 +279 +4606 +2195 +9 +10652 +34 +10653 +2743 +3067 +363 +10654 +10655 +552 +99 +14 +213 +34 +70 +10656 +10657 +10658 +3406 +8853 +10659 +10660 +10661 +3978 +14 +6343 +337 +10662 +484 +4491 +249 +478 +104 +10663 +43 +10664 +3369 +5326 +10665 +10666 +70 +10667 +4269 +22 +10668 +3484 +10669 +10670 +57 +10671 +10672 +248 +10673 +5780 +10674 +14 +43 +9497 +10675 +32 +10676 +2764 +5803 +6507 +10677 +2733 +10678 +303 +10679 +57 +10680 +598 +10681 +10682 +4982 +10683 +10684 +10685 +286 +10686 +484 +10687 +303 +357 +237 +271 +10688 +4278 +10689 +10690 +305 +10691 +10692 +89 +10693 +8555 +4 +4388 +15 +10694 +57 +10695 +70 +8208 +10696 +4018 +248 +10697 +284 +165 +10698 +2314 +10699 +1364 +284 +10700 +1021 +10701 +337 +10702 +10703 +10704 +303 +10705 +66 +436 +10706 +10707 +3601 +10708 +4820 +10709 +3902 +2135 +10710 +32 +10711 +10712 +10713 +10714 +10715 +10716 +10717 +5946 +7014 +10718 +10719 +10720 +10721 +10722 +48 +10723 +354 +10724 +10725 +10726 +10727 +48 +701 +1710 +10728 +7137 +10729 +345 +10730 +10731 +10732 +10733 +10734 +10735 +10736 +155 +3764 +10737 +15 +10717 +9718 +237 +10738 +845 +8200 +10739 +10740 +10741 +677 +17 +694 +10742 +10743 +15 +10744 +10745 +43 +5217 +10746 +10747 +1244 +10748 +10749 +48 +10750 +1021 +713 +10751 +10752 +10753 +34 +10754 +10755 +4402 +1531 +910 +305 +7137 +1559 +10756 +1356 +22 +10757 +115 +15 +15 +10758 +2 +10759 +936 +411 +10760 +10761 +10762 +10763 +10764 +10765 +3553 +286 +10766 +9 +10767 +137 +741 +1021 +2052 +10768 +3599 +57 +284 +337 +7600 +10769 +284 +3645 +10770 +5202 +1107 +213 +10771 +1513 +10772 +345 +10773 +3 +10774 +2415 +10775 +10776 +10777 +179 +417 +931 +10778 +10779 +1745 +10780 +797 +10781 +213 +10782 +8142 +827 +10783 +10784 +201 +7137 +10785 +32 +331 +43 +10786 +10787 +10788 +10789 +778 +10790 +10791 +9 +10792 +10793 +703 +15 +155 +286 +10794 +7032 +10795 +10796 +10797 +2043 +10798 +15 +10799 +10800 +10801 +10802 +176 +10803 +669 +10286 +10804 +10805 +9201 +5022 +1710 +20 +1301 +337 +10806 +10807 +10808 +10809 +6420 +29 +43 +3492 +10810 +4812 +736 +22 +4461 +22 +10811 +10075 +1991 +10812 +337 +10813 +337 +10814 +648 +9 +6011 +1502 +354 +10815 +15 +10816 +917 +10 +10817 +10818 +10819 +1912 +1091 +1716 +10820 +112 +10821 +10822 +10823 +10824 +10825 +213 +10826 +32 +10827 +10828 +10829 +10830 +20 +7860 +10831 +1203 +10832 +15 +77 +14 +10833 +10834 +2811 +104 +10835 +10836 +10837 +10838 +1870 +237 +20 +3186 +43 +2058 +10839 +2197 +5860 +10840 +10841 +14 +43 +10842 +2777 +15 +10843 +10844 +5662 +43 +10845 +317 +10846 +10847 +10848 +2253 +10849 +10850 +10851 +43 +43 +10852 +6833 +5249 +476 +9395 +464 +10853 +89 +845 +730 +269 +10854 +10855 +10856 +57 +3 +10857 +20 +10858 +10859 +10860 +10861 +17 +10862 +764 +10863 +10864 +10865 +741 +10866 +10867 +952 +10868 +10869 +2009 +3055 +4631 +337 +10870 +284 +3976 +5326 +10871 +331 +10872 +357 +3842 +6010 +10873 +915 +1862 +5340 +4278 +179 +648 +10874 +284 +10875 +705 +10876 +248 +7137 +10877 +10878 +7811 +10879 +10880 +10881 +1502 +464 +2809 +493 +10882 +10883 +25 +8803 +10884 +665 +10 +237 +2762 +3908 +1745 +10885 +10886 +7801 +16 +57 +10887 +2849 +5561 +152 +10888 +10889 +10235 +12 +10890 +10891 +10892 +2406 +10893 +25 +10894 +10895 +4441 +1853 +10896 +610 +10897 +10898 +6317 +10899 +317 +10900 +10901 +10902 +10903 +10904 +1018 +10905 +284 +10906 +284 +337 +10907 +1817 +9504 +2202 +9560 +10908 +10909 +10910 +10911 +740 +936 +10912 +10913 +57 +10914 +10915 +10916 +43 +8050 +10917 +3472 +822 +1824 +57 +1808 +10918 +10919 +519 +10920 +2347 +10921 +10922 +10923 +10924 +10925 +10926 +2427 +1343 +10927 +10928 +43 +10929 +16 +10930 +43 +10 +707 +10931 +10932 +10933 +710 +10934 +10935 +10936 +15 +10 +10937 +10938 +10939 +14 +7543 +10940 +5780 +164 +910 +4906 +10 +3546 +677 +4023 +19 +8255 +1244 +10941 +10942 +10943 +10944 +10945 +201 +10946 +10947 +2040 +10948 +19 +613 +10782 +25 +4905 +10949 +10950 +10951 +43 +10952 +10953 +188 +10954 +10955 +357 +12 +115 +10956 +303 +70 +1307 +14 +213 +32 +10957 +303 +10958 +10959 +10960 +284 +43 +337 +10961 +10962 +10963 +15 +554 +286 +10964 +303 +10965 +43 +7480 +10966 +248 +14 +1710 +337 +10967 +249 +286 +10968 +464 +10969 +7137 +43 +1013 +10970 +1870 +201 +8342 +10971 +5553 +2083 +8994 +1224 +32 +4491 +10972 +415 +10973 +10974 +10975 +10976 +10977 +10978 +10979 +10980 +10981 +1047 +10982 +20 +6732 +16 +3332 +305 +10983 +301 +2213 +10984 +10985 +10986 +10987 +67 +378 +225 +10988 +10989 +712 +201 +10990 +16 +188 +10757 +10991 +10992 +10993 +4532 +10994 +10995 +501 +1109 +10996 +10997 +10998 +415 +5780 +10999 +43 +178 +1637 +11000 +14 +11001 +1912 +936 +210 +3354 +11002 +1867 +11003 +7283 +6303 +7137 +7357 +11004 +53 +3417 +11005 +11006 +4 +7104 +590 +1245 +11007 +15 +11008 +11009 +3732 +179 +11010 +815 +25 +11011 +11012 +11013 +248 +303 +2415 +11014 +11015 +15 +8583 +11016 +11017 +53 +11018 +11019 +2446 +671 +11020 +11021 +248 +337 +402 +337 +493 +193 +11022 +6741 +613 +11023 +11024 +104 +11025 +7683 +9738 +2476 +11026 +411 +11027 +11028 +104 +1739 +303 +305 +11029 +9 +11030 +11031 +11032 +11033 +861 +397 +11034 +11035 +48 +11036 +11037 +9796 +11038 +32 +11039 +11040 +15 +493 +140 +11041 +43 +5869 +11042 +11043 +703 +12 +11044 +11045 +11046 +176 +11047 +304 +2924 +11048 +11049 +11050 +11051 +8110 +11052 +398 +11053 +15 +10535 +5623 +1623 +11054 +11055 +1710 +11056 +11057 +303 +11058 +284 +10849 +11059 +2302 +284 +11060 +11061 +14 +11062 +11063 +43 +892 +1232 +11064 +9449 +248 +10621 +11065 +77 +11066 +32 +2136 +11067 +11068 +11069 +11070 +317 +398 +831 +11071 +3059 +6350 +19 +11072 +11073 +4075 +586 +5817 +11074 +2310 +11075 +11076 +11077 +11078 +11079 +43 +11080 +11081 +15 +11082 +416 +99 +11083 +176 +11084 +1345 +5780 +11085 +1382 +11086 +11087 +19 +317 +11088 +2382 +1705 +11089 +11090 +53 +11091 +11092 +11093 +11094 +6341 +9465 +10500 +564 +2537 +506 +317 +11095 +2591 +201 +8244 +533 +77 +8460 +345 +1647 +11096 +10720 +114 +11097 +11098 +11099 +11100 +11101 +11102 +2428 +345 +989 +2081 +1300 +14 +8755 +16 +2410 +286 +11103 +11104 +2776 +66 +11105 +11106 +5780 +11107 +11108 +11109 +9449 +5797 +11110 +457 +11111 +11112 +11113 +11114 +9660 +6294 +1514 +11115 +11116 +3470 +210 +331 +284 +9766 +4789 +11117 +286 +5540 +11118 +11119 +248 +11120 +337 +11121 +11122 +11123 +11124 +11125 +1083 +2045 +11126 +11127 +2135 +11128 +15 +15 +11129 +11130 +11131 +10947 +57 +249 +10338 +11132 +11133 +416 +11134 +1066 +1889 +1637 +11135 +10835 +11136 +11137 +305 +11138 +11139 +179 +11140 +170 +11141 +11142 +201 +77 +11143 +176 +11144 +11145 +671 +11146 +331 +9578 +648 +4116 +11147 +25 +11148 +228 +11149 +11150 +11151 +11152 +4 +7097 +19 +2040 +11153 +48 +11154 +11155 +19 +4793 +11156 +11157 +11158 +32 +11159 +11160 +57 +6341 +337 +11161 +9617 +48 +536 +2314 +11162 +11163 +11164 +1021 +887 +11165 +284 +11166 +11167 +3598 +11168 +222 +11169 +5523 +11170 +14 +11171 +11172 +142 +11173 +11174 +4031 +11175 +32 +11176 +15 +11177 +11178 +10016 +35 +3186 +1531 +20 +694 +11179 +11180 +358 +453 +646 +11181 +20 +11182 +11183 +15 +237 +2287 +11184 +1896 +4202 +5780 +14 +7137 +11185 +8724 +1824 +272 +11186 +11187 +331 +25 +11188 +188 +11189 +586 +43 +484 +11190 +11191 +43 +32 +188 +11192 +2 +11193 +11194 +554 +11195 +11196 +8718 +233 +3287 +11197 +11198 +11199 +10016 +11200 +12 +11201 +342 +337 +1739 +11202 +4855 +5324 +11203 +248 +11204 +386 +48 +446 +188 +57 +8297 +164 +2409 +11205 +11206 +11207 +11208 +11209 +286 +48 +14 +6012 +10016 +15 +11210 +11211 +248 +5438 +10393 +11212 +11213 +1066 +15 +43 +11214 +11215 +11216 +11217 +11218 +11219 +11220 +19 +11221 +43 +286 +22 +1812 +10822 +7357 +11222 +11223 +3 +11224 +4637 +11225 +8183 +3 +4028 +11226 +5601 +11227 +11228 +43 +11229 +11230 +11231 +11232 +11233 +11234 +11235 +32 +1232 +176 +11236 +586 +4765 +11237 +11238 +19 +15 +193 +11239 +11240 +11241 +1514 +43 +11242 +11243 +11244 +10280 +112 +10 +9293 +201 +9372 +25 +11245 +77 +5344 +248 +248 +5314 +11246 +11247 +19 +616 +11248 +11249 +1021 +11250 +11251 +11252 +248 +10359 +11253 +11148 +35 +231 +15 +1655 +11254 +11255 +4 +703 +1048 +249 +869 +5080 +15 +11256 +201 +11257 +1200 +11258 +9928 +9948 +19 +11259 +11260 +560 +11261 +11262 +11263 +4990 +703 +9020 +2195 +286 +11264 +11265 +398 +11266 +10993 +11267 +323 +11268 +11269 +48 +11270 +1224 +286 +1425 +2476 +2560 +5898 +493 +11271 +6284 +713 +11272 +178 +11273 +1017 +694 +15 +7137 +11274 +11275 +15 +11276 +317 +7031 +11277 +3 +559 +11278 +11279 +11280 +11281 +1291 +11282 +345 +8230 +272 +9913 +11283 +11284 +337 +11285 +11286 +1374 +730 +1232 +25 +11287 +15 +806 +11288 +53 +11289 +11290 +11291 +11292 +845 +11293 +60 +43 +8249 +114 +11294 +11295 +11296 +11297 +3732 +2882 +11298 +11299 +11300 +3867 +11301 +11302 +201 +4 +11303 +11304 +2700 +11305 +317 +3626 +19 +305 +11306 +11307 +1655 +32 +322 +11308 +11309 +15 +10 +11310 +11311 +11312 +305 +342 +2700 +11313 +11314 +11315 +3059 +345 +11316 +11317 +11318 +11319 +99 +66 +11320 +11321 +19 +11322 +11323 +914 +354 +178 +11324 +25 +11325 +5022 +19 +576 +205 +11326 +11327 +15 +11328 +11329 +43 +11330 +15 +11331 +1262 +1224 +11332 +402 +2769 +11333 +3828 +3055 +11334 +284 +11335 +464 +213 +11336 +11337 +11338 +11339 +11340 +270 +2134 +14 +176 +11341 +259 +4730 +11342 +57 +11343 +200 +11344 +11345 +15 +11346 +9313 +57 +11347 +305 +32 +11348 +5045 +6181 +11349 +15 +11350 +4364 +9066 +5780 +1559 +10 +20 +6894 +11351 +11352 +164 +11353 +11354 +357 +11355 +1291 +14 +11356 +11357 +11358 +345 +1604 +213 +112 +60 +11359 +11148 +11360 +19 +2804 +11361 +15 +11362 +213 +305 +11363 +11364 +11365 +11366 +11367 +11368 +11369 +646 +11370 +337 +286 +11371 +248 +237 +57 +1169 +11372 +11373 +155 +2728 +6994 +11374 +11375 +11376 +528 +11377 +2 +7739 +11378 +11379 +19 +11380 +272 +4278 +32 +11381 +5780 +11382 +6006 +192 +11383 +707 +11384 +11385 +10 +11386 +11387 +665 +11388 +647 +1169 +11389 +11390 +1790 +11391 +11392 +1048 +331 +19 +11393 +11394 +11395 +11396 +11397 +15 +11398 +22 +11399 +11400 +4304 +7502 +11401 +861 +1109 +11402 +3644 +11403 +354 +11404 +11405 +2836 +305 +364 +284 +11406 +1011 +4713 +1169 +11407 +11408 +10 +9713 +11409 +4028 +303 +566 +11410 +11411 +357 +137 +11412 +4192 +11413 +11414 +8042 +32 +11415 +11416 +11417 +299 +11418 +11419 +11420 +11421 +14 +11422 +764 +11423 +11424 +349 +11425 +11426 +11427 +11428 +11429 +11430 +11431 +43 +57 +2008 +11428 +43 +11432 +4677 +11433 +9112 +11434 +11435 +57 +11436 +989 +15 +11437 +11438 +11439 +11440 +11441 +14 +11442 +11443 +872 +11444 +303 +11148 +11445 +11446 +15 +11447 +10256 +9298 +11448 +11449 +3239 +20 +11450 +11451 +11452 +11453 +616 +11454 +412 +11455 +892 +11456 +323 +11457 +11458 +11459 +9 +11460 +11461 +1585 +11462 +305 +1232 +48 +11463 +9114 +10 +114 +11464 +156 +11465 +11466 +11467 +11468 +11469 +11470 +66 +11471 +7575 +4033 +213 +11472 +317 +8096 +11473 +11474 +1823 +43 +11475 +11476 +11477 +43 +11148 +3225 +11478 +4364 +11479 +11480 +4 +11481 +137 +11482 +686 +1513 +2537 +648 +3 +665 +369 +373 +43 +11483 +194 +4963 +484 +279 +1912 +659 +57 +425 +22 +57 +738 +10909 +11484 +1262 +11485 +228 +11486 +11487 +20 +48 +4808 +11488 +3066 +493 +11489 +11490 +11491 +484 +4116 +1655 +1224 +9560 +11492 +11493 +96 +5022 +286 +10583 +11494 +16 +11495 +60 +10946 +9939 +11496 +11497 +11498 +213 +11499 +7418 +11500 +2260 +2561 +2966 +11501 +11502 +205 +337 +11503 +11504 +303 +1169 +11505 +1425 +286 +188 +11506 +11507 +11508 +11509 +11510 +303 +242 +5993 +11511 +11512 +11513 +11514 +20 +286 +274 +873 +11515 +11516 +8257 +398 +1662 +11517 +11518 +11519 +19 +822 +11520 +791 +11521 +11522 +270 +1364 +11523 +11524 +19 +11525 +8427 +809 +11526 +19 +3599 +464 +11527 +3119 +305 +5649 +845 +533 +671 +11528 +11148 +19 +1425 +11529 +11530 +77 +1232 +791 +357 +11531 +11532 +11533 +11534 +11535 +349 +4028 +11536 +32 +11537 +15 +11538 +201 +11539 +11540 +9254 +11541 +11542 +5792 +11543 +11544 +11545 +815 +11546 +248 +48 +11547 +11548 +286 +284 +493 +4918 +25 +11549 +337 +284 +11550 +11551 +11552 +303 +9396 +11553 +11554 +3213 +1018 +11555 +323 +373 +11556 +11557 +11558 +11559 +11560 +11561 +43 +8783 +323 +2764 +11562 +11563 +11564 +11565 +8950 +11566 +11567 +48 +11568 +11188 +11321 +736 +373 +48 +14 +11569 +11570 +11571 +137 +11572 +822 +931 +11573 +11574 +1870 +11575 +11576 +11577 +11578 +11579 +11580 +5075 +11581 +11582 +15 +228 +201 +1531 +66 +1604 +11583 +8682 +11114 +11584 +213 +11585 +11586 +11587 +931 +248 +8832 +5229 +365 +11588 +464 +11589 +11590 +11591 +11592 +272 +11593 +3105 +916 +11594 +11595 +11596 +11597 +11598 +6439 +34 +358 +11599 +11600 +11601 +11602 +11603 +11604 +11605 +11606 +11607 +11608 +464 +11609 +11610 +11611 +11612 +11613 +1128 +11614 +2309 +11615 +15 +11616 +11617 +11598 +493 +554 +2406 +845 +48 +11618 +43 +11619 +201 +828 +15 +11620 +11621 +11622 +7071 +464 +114 +43 +1229 +48 +32 +15 +2591 +11623 +1364 +8263 +11624 +2770 +464 +955 +11625 +153 +694 +11626 +11627 +43 +14 +11628 +11629 +11114 +11630 +213 +2577 +179 +11631 +11632 +248 +2042 +357 +1508 +3944 +11633 +11114 +11634 +345 +15 +11635 +11636 +528 +16 +11637 +57 +99 +155 +303 +11638 +10318 +11639 +3 +6728 +11640 +741 +2195 +11641 +11642 +11643 +707 +11644 +11645 +11646 +237 +11647 +77 +11648 +305 +354 +11649 +43 +5080 +2 +1425 +5601 +11650 +11651 +11652 +11653 +736 +11654 +10 +11655 +3768 +2264 +6344 +11656 +11657 +5561 +11658 +11321 +11659 +19 +4684 +11660 +305 +15 +11661 +11662 +11663 +179 +21 +11664 +11665 +15 +11666 +2944 +5361 +6869 +248 +11667 +11668 +11669 +11670 +104 +11671 +573 +11672 +861 +379 +77 +11673 +11674 +493 +11675 +11676 +10 +873 +3 +11677 +11678 +3485 +11321 +179 +176 +17 +493 +4 +11679 +238 +665 +4538 +2733 +11680 +583 +665 +11681 +11682 +11683 +11684 +43 +43 +11685 +11686 +32 +11687 +8798 +11688 +11689 +9 +2619 +3559 +11690 +305 +586 +32 +9967 +4600 +2314 +11691 +11692 +11693 +11694 +1636 +528 +2513 +284 +11695 +3367 +11696 +586 +11697 +11698 +337 +11699 +11700 +2135 +11701 +11702 +11703 +11704 +11705 +9 +284 +11706 +303 +77 +12 +11707 +11708 +3569 +11709 +43 +109 +416 +104 +8297 +8210 +2935 +286 +11710 +11711 +9898 +2043 +519 +11712 +6110 +48 +284 +2882 +178 +11713 +29 +2015 +1889 +11714 +1605 +11715 +11716 +11717 +2 +822 +25 +1870 +8751 +15 +14 +43 +4023 +11718 +14 +357 +11719 +43 +4980 +2308 +3976 +284 +6106 +8255 +11188 +11720 +11721 +11722 +11723 +142 +11724 +11725 +32 +11726 +11727 +210 +43 +11728 +11729 +464 +11730 +5769 +11731 +9132 +11732 +11733 +11148 +15 +11734 +15 +11735 +11736 +6099 +11737 +915 +11738 +11739 +11740 +11741 +303 +248 +1013 +2 +11742 +11743 +11744 +493 +3316 +48 +15 +6915 +98 +11745 +272 +11746 +11747 +4081 +11748 +464 +8367 +11749 +2006 +11750 +1655 +337 +11751 +11752 +11753 +274 +1090 +354 +11754 +927 +2804 +3 +22 +11755 +5792 +5976 +201 +11756 +15 +11757 +484 +416 +11758 +11148 +11759 +554 +1956 +11760 +11761 +11762 +66 +11763 +11764 +3521 +11765 +3055 +248 +11766 +958 +248 +11767 +8724 +345 +11768 +337 +248 +34 +11769 +213 +8447 +5780 +11762 +14 +2213 +11770 +303 +11771 +11772 +11773 +11774 +11775 +1449 +11776 +2577 +989 +5912 +9 +9 +647 +2330 +624 +53 +11777 +11778 +2015 +11779 +11780 +14 +11781 +11782 +1091 +286 +11783 +25 +1674 +11784 +3354 +1604 +4182 +12 +305 +43 +9026 +11785 +3976 +2406 +528 +1112 +2045 +11786 +11787 +2787 +1026 +354 +9910 +32 +11788 +11789 +11790 +11791 +11792 +213 +6258 +6935 +741 +11793 +11794 +2 +11795 +11796 +770 +11797 +11798 +2136 +11799 +5627 +3317 +3406 +11800 +11114 +11801 +9526 +6507 +11802 +11803 +3553 +11804 +2477 +11805 +2029 +11806 +284 +48 +262 +5877 +586 +114 +11807 +1048 +11808 +237 +7891 +597 +713 +464 +57 +11419 +11809 +11810 +11811 +2042 +80 +11812 +5780 +2733 +11813 +34 +11814 +1169 +11815 +11816 +11817 +248 +286 +646 +248 +11818 +486 +66 +43 +11819 +411 +67 +1011 +1364 +11820 +337 +1232 +1291 +11821 +1169 +14 +15 +1458 +137 +809 +11822 +11823 +11824 +915 +11825 +11826 +48 +345 +11827 +213 +43 +11828 +11522 +14 +4907 +11829 +11830 +11831 +648 +1026 +32 +15 +2213 +11832 +11833 +11834 +5920 +11835 +2157 +48 +3172 +745 +11836 +345 +1674 +11837 +22 +48 +345 +11838 +6175 +11839 +11678 +6173 +11840 +1364 +4056 +826 +155 +2015 +11841 +10807 +213 +402 +11842 +4028 +15 +305 +983 +286 +7134 +11843 +179 +11844 +43 +11845 +741 +11846 +5747 +11847 +11848 +11849 +2314 +11850 +1679 +11851 +11852 +11853 +11854 +11855 +2561 +11856 +32 +11857 +1291 +791 +3213 +8042 +43 +11858 +286 +11859 +48 +222 +1013 +11860 +11861 +11862 +1364 +5 +286 +11863 +11864 +11865 +11866 +11867 +11868 +11869 +43 +11870 +176 +19 +11871 +10 +11872 +115 +11873 +464 +48 +11676 +4624 +15 +480 +11874 +345 +11875 +11876 +1514 +11877 +2 +57 +11878 +1684 +11879 +11880 +10256 +6310 +9 +5446 +11881 +11882 +11883 +11884 +11885 +1208 +11886 +1710 +1091 +11887 +305 +284 +8783 +11888 +11889 +665 +2403 +11890 +213 +11891 +11892 +11893 +493 +11894 +11895 +2561 +6035 +337 +331 +11734 +331 +11896 +11897 +3914 +1423 +357 +10500 +11898 +11899 +11900 +317 +4905 +46 +284 +11901 +11902 +284 +11903 +11904 +8297 +9289 +11905 +656 +11906 +11907 +10 +76 +1870 +11908 +11909 +942 +152 +57 +11910 +11911 +11912 +11913 +11914 +11915 +48 +5418 +8219 +213 +11916 +1091 +1013 +213 +11917 +11918 +248 +484 +11919 +1956 +11920 +648 +6661 +303 +213 +17 +9757 +11921 +11922 +1710 +11923 +354 +11924 +284 +188 +11925 +11926 +10973 +11927 +76 +1100 +11928 +11929 +11930 +11931 +11932 +4855 +11933 +19 +11934 +11935 +11936 +717 +2289 +11937 +2792 +11938 +2338 +11939 +11940 +104 +11941 +484 +11670 +104 +11942 +15 +179 +11943 +155 +11944 +9156 +11945 +317 +43 +11946 +10 +14 +77 +11947 +11948 +303 +10 +48 +14 +5041 +11949 +10117 +48 +11148 +43 +11148 +43 +4805 +11950 +11951 +11952 +5780 +317 +48 +11587 +11953 +5344 +77 +11954 +19 +25 +11955 +11956 +286 +1577 +11957 +16 +284 +6249 +11958 +1559 +11959 +42 +9 +11960 +11961 +11962 +3334 +11963 +284 +196 +741 +11964 +2314 +11965 +284 +842 +11966 +337 +281 +7483 +3978 +337 +1051 +464 +11967 +2537 +413 +48 +3852 +11968 +11969 +11970 +713 +14 +10363 +1956 +11971 +11972 +11973 +11974 +11975 +237 +11976 +3059 +57 +337 +43 +11977 +11978 +11979 +43 +284 +11980 +11981 +11982 +11983 +305 +11984 +11985 +339 +11986 +624 +184 +185 +10049 +11987 +48 +11988 +1232 +11989 +19 +9402 +9948 +11990 +11991 +249 +11992 +11993 +25 +11994 +43 +11995 +185 +11996 +15 +12 +11997 +11998 +11999 +12000 +12001 +12002 +12003 +12004 +12005 +57 +12006 +345 +12007 +317 +12008 +17 +12009 +12010 +817 +12011 +12012 +19 +179 +12013 +4 +7615 +12014 +12015 +12016 +43 +2314 +12017 +12018 +5186 +12019 +20 +12020 +12021 +12022 +48 +12023 +12024 +7291 +12025 +35 +11434 +14 +48 +14 +15 +554 +493 +12026 +12027 +213 +12028 +43 +4637 +12029 +248 +554 +12030 +213 +8230 +12031 +12032 +9 +12033 +12034 +12035 +439 +12036 +286 +337 +43 +12037 +12038 +213 +12039 +12040 +12041 +286 +12042 +357 +12043 +4278 +9 +14 +43 +15 +12044 +4855 +12045 +3978 +12046 +357 +12047 +1907 +43 +2 +12048 +12049 +415 +43 +104 +2561 +440 +464 +12050 +48 +12051 +12052 +12053 +10156 +457 +11822 +2330 +12054 +12055 +2136 +12056 +2213 +12057 +12058 +892 +337 +1154 +1112 +323 +9942 +1992 +963 +12059 +12060 +12061 +764 +303 +15 +1823 +1889 +284 +43 +12062 +19 +305 +4169 +7697 +12063 +303 +12064 +11808 +12065 +15 +43 +12066 +1423 +48 +34 +12067 +12068 +12069 +12070 +12071 +12072 +10 +576 +12073 +493 +1442 +9 +736 +137 +12074 +764 +8367 +398 +12075 +284 +104 +8261 +1082 +659 +284 +48 +12076 +558 +5543 +12077 +19 +14 +4012 +12078 +5791 +337 +8996 +12079 +12080 +12081 +12082 +10 +12083 +12084 +4217 +12085 +12086 +178 +12087 +12088 +12089 +1779 +12090 +25 +12091 +12092 +323 +12093 +12094 +12095 +43 +12096 +237 +12097 +7381 +12098 +284 +12099 +213 +12100 +12101 +43 +12102 +12103 +174 +12104 +964 +12105 +12106 +3503 +12107 +1889 +2356 +12108 +152 +3553 +12109 +486 +1311 +12110 +764 +43 +12111 +12112 +12113 +12114 +5208 +11942 +4964 +668 +2 +12115 +2911 +25 +12116 +2315 +305 +12117 +12118 +48 +1013 +3354 +48 +2260 +677 +12119 +4278 +12120 +990 +12121 +12122 +43 +12123 +873 +89 +12124 +5780 +12125 +6612 +4053 +1232 +2264 +12126 +12127 +1061 +12128 +12129 +8784 +213 +12130 +337 +11762 +4766 +12131 +43 +11963 +464 +299 +48 +12132 +12133 +12134 +12135 +12136 +104 +3252 +233 +12137 +7908 +303 +12138 +12139 +232 +12140 +184 +12141 +12142 +12143 +12144 +12145 +1056 +2 +10087 +12146 +15 +12147 +12148 +331 +43 +12149 +5253 +1559 +6480 +12150 +15 +303 +12151 +12152 +12153 +10 +12154 +12155 +345 +32 +12156 +12157 +14 +43 +12158 +892 +12159 +188 +12160 +284 +12161 +25 +12162 +354 +70 +6850 +103 +439 +1172 +43 +337 +12163 +248 +213 +373 +12164 +10767 +4285 +12165 +872 +213 +12166 +10300 +48 +14 +736 +104 +12167 +12168 +12169 +12170 +12171 +5780 +114 +12172 +8853 +11328 +14 +12173 +12174 +1172 +861 +11421 +12175 +345 +20 +514 +10933 +12176 +12177 +12178 +12179 +3989 +237 +12180 +249 +1513 +12181 +12182 +11321 +10136 +12183 +12184 +15 +14 +12185 +707 +12186 +43 +12187 +9402 +202 +2501 +5415 +501 +12188 +12189 +12190 +317 +12191 +12192 +12193 +2234 +915 +12194 +12195 +2135 +12196 +5561 +12197 +12198 +12199 +237 +337 +14 +213 +12200 +9465 +12201 +519 +2500 +112 +12202 +12203 +178 +554 +32 +4278 +5963 +8935 +12204 +12205 +12206 +272 +286 +237 +4364 +12207 +12208 +10614 +1291 +57 +554 +4278 +8789 +237 +15 +317 +43 +77 +12209 +11804 +12210 +12211 +213 +493 +12212 +12213 +43 +12214 +99 +12215 +12216 +12217 +4317 +248 +19 +12218 +237 +248 +2243 +4028 +7451 +303 +12219 +12220 +12221 +12222 +5319 +337 +12223 +10 +764 +337 +2433 +554 +1300 +286 +12224 +397 +12225 +12226 +8297 +2 +9 +12227 +12228 +1688 +4855 +12229 +12230 +1425 +12231 +12232 +12233 +237 +43 +140 +12234 +12235 +2298 +12236 +12237 +2697 +2799 +12238 +15 +232 +12239 +11 +12240 +184 +12241 +6341 +317 +12242 +305 +12243 +1465 +43 +1021 +720 +12244 +10313 +12245 +248 +10638 +19 +2308 +12246 +12247 +12248 +43 +12249 +14 +1384 +365 +10880 +11483 +12250 +17 +43 +12251 +5797 +1692 +10769 +936 +12252 +12253 +12254 +12255 +12256 +12257 +3743 +66 +12258 +14 +248 +12259 +12260 +48 +12261 +892 +6939 +4144 +12262 +48 +12263 +10516 +12264 +12265 +14 +4028 +3213 +9497 +12266 +3354 +3 +317 +10450 +43 +12267 +12268 +209 +12269 +12270 +12271 +210 +6483 +20 +48 +12272 +12273 +12274 +2501 +12275 +2865 +12276 +12277 +14 +48 +12278 +493 +399 +12279 +12280 +12281 +12282 +345 +345 +12283 +12284 +12285 +19 +11148 +12286 +12287 +12288 +493 +9245 +228 +12289 +48 +354 +2770 +12290 +12291 +1203 +282 +12292 +48 +12293 +4806 +12294 +4153 +12295 +12296 +892 +12297 +12298 +12299 +12300 +38 +43 +730 +12301 +12302 +22 +12303 +5601 +3337 +12304 +12305 +12306 +12307 +12189 +15 +464 +5912 +1124 +9582 +1236 +19 +12308 +345 +43 +6616 +12309 +12310 +12311 +8053 +12312 +237 +12313 +345 +12314 +179 +12315 +12316 +12317 +741 +12318 +12319 +12320 +60 +1364 +4 +12321 +357 +2 +12322 +12323 +1157 +12324 +12325 +9 +19 +12326 +12327 +12328 +1966 +12329 +12330 +3599 +377 +1961 +12331 +48 +1605 +53 +12332 +213 +12333 +25 +284 +12334 +185 +12335 +12336 +43 +809 +12337 +554 +12338 +303 +14 +1889 +345 +1655 +2234 +342 +14 +337 +12339 +15 +12340 +3626 +12 +12341 +12342 +12343 +48 +10179 +694 +1542 +1234 +15 +32 +12344 +2919 +43 +12345 +12346 +15 +43 +12347 +491 +10470 +6173 +38 +32 +2728 +12348 +519 +12349 +12350 +12351 +528 +12352 +43 +10256 +12353 +12354 +57 +8889 +354 +12355 +1224 +825 +8798 +7134 +12356 +19 +1927 +12357 +12358 +12359 +104 +12360 +43 +12361 +2136 +237 +12362 +12363 +815 +188 +2197 +12364 +2318 +12365 +464 +12366 +12367 +12368 +2694 +53 +57 +2841 +11675 +12369 +201 +43 +48 +1100 +12370 +8460 +2 +12371 +12372 +12373 +3 +519 +12374 +48 +12375 +1912 +12376 +14 +286 +12377 +140 +12378 +12379 +14 +12380 +1514 +10880 +6214 +48 +15 +464 +12381 +12382 +12383 +12384 +14 +11600 +12385 +4684 +12386 +12387 +12388 +3999 +519 +2446 +48 +12005 +10356 +12389 +14 +12390 +12391 +12392 +12393 +910 +12394 +43 +12395 +2135 +12396 +12397 +12398 +14 +12399 +656 +12400 +48 +188 +12401 +736 +12402 +11185 +12403 +48 +35 +12404 +77 +12405 +12406 +12407 +12408 +48 +1425 +12409 +12410 +2 +12411 +12412 +703 +12413 +12414 +12415 +11224 +12416 +12417 +1852 +12418 +12419 +12420 +76 +12421 +305 +12422 +12423 +43 +586 +2 +323 +411 +665 +43 +12424 +12425 +2035 +3908 +12426 +12427 +736 +554 +12428 +7522 +272 +140 +12429 +12430 +12431 +12432 +3003 +692 +12433 +12434 +12435 +58 +43 +12436 +12437 +3310 +232 +12438 +12439 +12440 +370 +1051 +8849 +305 +12441 +5780 +449 +14 +701 +12442 +12443 +12444 +272 +413 +48 +1232 +12445 +671 +12446 +436 +12447 +413 +12448 +12449 +249 +12450 +66 +286 +12451 +48 +43 +286 +152 +12452 +2650 +12453 +2847 +2694 +11148 +12454 +12455 +15 +12456 +1425 +12457 +491 +43 +12458 +14 +237 +12459 +12460 +57 +1604 +43 +12461 +12462 +764 +1047 +213 +303 +12463 +303 +6209 +12464 +345 +12465 +12466 +12467 +12468 +12469 +114 +98 +12470 +35 +12471 +12472 +5780 +57 +12473 +12474 +1442 +12475 +43 +9832 +12476 +586 +57 +11046 +1112 +16 +861 +249 +12477 +38 +12478 +12479 +12480 +12481 +48 +8020 +12482 +43 +703 +15 +8779 +12483 +12484 +2471 +9 +179 +12485 +12486 +12487 +12488 +122 +176 +12489 +12490 +12491 +12492 +12493 +237 +12494 +155 +12495 +357 +2260 +6479 +1727 +196 +48 +4803 +12496 +48 +1559 +12497 +12498 +185 +12499 +4055 +12500 +30 +12501 +137 +14 +248 +178 +43 +2988 +399 +303 +7624 +305 +12502 +12477 +2919 +2202 +12503 +66 +12504 +12505 +12506 +12507 +345 +12508 +3468 +12509 +12510 +1870 +586 +357 +573 +4187 +12511 +1546 +43 +80 +12512 +12513 +43 +2043 +493 +5780 +369 +7 +12514 +10299 +9363 +12515 +12516 +188 +12517 +5839 +904 +43 +43 +464 +12518 +11754 +12519 +12520 +12521 +12522 +12523 +12524 +703 +12525 +4430 +337 +6877 +880 +12526 +12527 +14 +179 +12528 +707 +4081 +48 +9 +694 +7208 +8724 +6398 +286 +1605 +12529 +10560 +43 +2409 +14 +2804 +1112 +2012 +1082 +12530 +10883 +12531 +671 +358 +9603 +10600 +14 +48 +493 +12532 +12533 +861 +48 +3287 +12534 +12535 +12536 +20 +14 +12537 +12538 +11551 +12539 +721 +12540 +12541 +12542 +10151 +305 +272 +10657 +12543 +1716 +12544 +12545 +345 +14 +140 +1364 +188 +1536 +453 +1224 +12546 +3711 +43 +12547 +2694 +8961 +12548 +12549 +32 +12550 +12551 +3543 +1543 +12552 +2064 +12553 +11353 +10880 +2042 +8037 +12554 +12555 +12556 +12557 +8779 +12558 +185 +1812 +12559 +12560 +12561 +12562 +12563 +43 +12564 +5808 +237 +12565 +43 +10310 +12566 +464 +305 +12567 +12568 +1165 +213 +213 +248 +9417 +12569 +12570 +14 +4606 +12571 +12572 +12573 +213 +43 +14 +12574 +12575 +12576 +12577 +303 +2499 +176 +1232 +764 +15 +4053 +3 +12578 +12579 +12580 +43 +12581 +357 +12 +736 +12582 +2093 +2764 +12583 +112 +3984 +25 +5990 +12584 +12585 +12586 +3 +11762 +464 +613 +6090 +12587 +12588 +10 +12589 +5577 +12590 +12591 +12592 +1244 +98 +12593 +12594 +12595 +43 +286 +12596 +12597 +19 +43 +12598 +6505 +2804 +12599 +12600 +12601 +11762 +12602 +12603 +3842 +2790 +284 +15 +201 +647 +12604 +43 +12605 +7045 +357 +331 +12606 +11754 +19 +237 +345 +43 +12607 +11483 +1942 +12034 +10 +1817 +12608 +337 +12609 +270 +12610 +4278 +12611 +2790 +303 +7276 +12612 +8724 +12613 +1048 +12614 +12615 +12616 +4 +12617 +12618 +12619 +272 +8297 +12620 +7855 +12621 +2764 +16 +12622 +12623 +2035 +12624 +43 +6527 +12625 +12626 +12627 +590 +3978 +237 +12628 +12629 +12630 +15 +57 +114 +32 +12631 +12632 +14 +12633 +3743 +12634 +48 +1251 +3238 +15 +57 +1169 +11960 +12635 +12636 +764 +12466 +8468 +4855 +10 +14 +12637 +114 +19 +32 +12638 +12639 +12640 +114 +3 +12641 +48 +43 +2 +12642 +15 +43 +12643 +57 +2234 +42 +12644 +2 +12645 +12646 +228 +43 +12647 +12648 +12649 +14 +12650 +345 +12651 +14 +713 +12652 +12653 +651 +29 +12654 +12655 +286 +12656 +48 +12657 +345 +12658 +155 +12241 +19 +1295 +2136 +12659 +43 +5418 +6480 +248 +12660 +12661 +12662 +209 +14 +5080 +6507 +337 +12663 +12664 +12665 +4116 +12666 +15 +12667 +213 +1157 +12668 +12669 +12203 +12670 +1665 +11966 +1696 +48 +12671 +12672 +647 +5990 +15 +12673 +12674 +12675 +493 +237 +12676 +12677 +2561 +4441 +12678 +12679 +185 +48 +12680 +179 +12681 +4 +12682 +484 +43 +242 +176 +12683 +67 +2975 +2 +11728 +25 +958 +4855 +12684 +14 +19 +736 +43 +1584 +12685 +6518 +1812 +970 +7357 +790 +4123 +43 +554 +2 +12686 +222 +12687 +12688 +19 +3543 +12689 +892 +12690 +3 +616 +57 +98 +43 +12691 +6741 +1049 +188 +5780 +464 +12692 +1812 +2 +12693 +137 +14 +10 +237 +331 +337 +10 +12694 +10 +12695 +43 +12696 +48 +9798 +303 +12697 +228 +14 +337 +12698 +12699 +248 +12700 +284 +446 +245 +48 +12701 +12702 +8867 +4 +741 +12703 +398 +484 +48 +3385 +12704 +2 +2406 +1626 +12705 +12706 +48 +9 +12707 +1224 +12708 +12709 +915 +12710 +43 +7291 +10 +12711 +9988 +12712 +20 +12713 +11754 +12714 +12715 +43 +342 +12716 +12717 +12718 +237 +10 +6054 +7855 +19 +2042 +48 +19 +1314 +12719 +12720 +12721 +178 +12722 +493 +12723 +8392 +822 +15 +1105 +12724 +12725 +9738 +12726 +12031 +12727 +12728 +12729 +12730 +4 +12351 +12731 +12732 +11822 +12733 +43 +248 +872 +7666 +12734 +12735 +284 +1100 +12736 +8098 +1251 +12737 +1232 +4075 +2320 +39 +272 +237 +12738 +1425 +12739 +12740 +12741 +12742 +14 +1203 +764 +10699 +10592 +3543 +12743 +12744 +5169 +12745 +48 +12746 +20 +43 +43 +12747 +12748 +12749 +14 +12750 +20 +14 +2061 +43 +72 +48 +43 +12751 +12752 +12753 +20 +369 +1217 +12754 +12755 +12756 +6839 +12757 +12758 +8163 +12759 +12760 +6106 +9 +2356 +12761 +12762 +43 +12763 +554 +6306 +491 +12764 +12765 +12716 +795 +12766 +20 +484 +12767 +43 +112 +1684 +379 +338 +12768 +237 +1533 +12769 +2865 +12770 +12771 +10557 +7521 +9497 +12772 +12773 +533 +12774 +286 +12775 +282 +12776 +43 +10 +12777 +741 +12778 +12779 +12780 +12781 +155 +286 +707 +12782 +809 +48 +1082 +12783 +3944 +3 +484 +12784 +42 +12785 +12786 +1082 +1220 +12787 +1710 +12788 +12789 +2 +12790 +10750 +2865 +43 +2239 +12791 +357 +1012 +43 +231 +12792 +2197 +43 +1605 +8517 +671 +196 +12793 +12794 +237 +43 +1224 +12795 +14 +12796 +12797 +7522 +736 +12798 +142 +915 +417 +3239 +9345 +14 +12799 +12800 +12801 +19 +12802 +970 +12803 +12804 +12805 +12806 +3 +11480 +12807 +12808 +43 +736 +457 +3 +12795 +338 +2488 +249 +12809 +1364 +12810 +1716 +286 +43 +25 +48 +12811 +3594 +365 +237 +12812 +14 +12813 +1829 +12814 +493 +12815 +43 +43 +9095 +4 +249 +210 +15 +1011 +12816 +646 +12817 +12818 +12819 +12820 +12821 +8724 +11489 +12822 +48 +2566 +1696 +671 +104 +357 +15 +12823 +4038 +12824 +12402 +12825 +6382 +12826 +48 +4487 +305 +12827 +19 +7259 +286 +112 +12828 +373 +14 +554 +373 +12543 +12829 +12830 +12831 +12832 +337 +32 +14 +12833 +12834 +1244 +12835 +12761 +12836 +43 +12837 +43 +12838 +2004 +4745 +4441 +12839 +12840 +1688 +10727 +43 +12841 +12842 +57 +12843 +6468 +12844 +3603 +3660 +12845 +12846 +48 +659 +2018 +12847 +12848 +12795 +12849 +14 +3172 +11754 +8896 +12850 +373 +4313 +11822 +12851 +12852 +647 +12853 +1955 +6701 +12854 +4441 +12855 +11400 +5601 +14 +12824 +4269 +446 +464 +12856 +12857 +12426 +14 +7355 +10 +12858 +176 +2239 +12859 +12110 +1503 +1817 +12860 +1425 +493 +12861 +12862 +12863 +48 +12864 +48 +12865 +12866 +12867 +12868 +284 +14 +43 +12869 +12795 +741 +564 +43 +12870 +12871 +337 +48 +1655 +213 +48 +286 +12872 +14 +48 +48 +12873 +237 +12874 +12875 +286 +8015 +43 +10418 +12876 +12877 +2694 +5650 +12878 +188 +12879 +6335 +12880 +43 +43 +43 +2459 +12881 +43 +2694 +12882 +14 +1765 +2064 +1710 +3543 +3 +237 +6400 +43 +12883 +12884 +11601 +141 +707 +6076 +48 +11762 +12885 +48 +5134 +317 +12886 +1001 +11482 +12887 +12888 +12889 +720 +12890 +209 +1547 +12891 +12892 +2064 +12893 +1262 +12894 +12895 +12896 +4002 +43 +9617 +9082 +284 +12897 +1425 +713 +3343 +12898 +265 +12899 +12900 +12901 +5627 +12902 +3239 +5751 +2593 +12903 +43 +11822 +12904 +12905 +4144 +8458 +12906 +10 +10 +10 +4483 +15 +19 +9 +8041 +12907 +32 +12908 +237 +188 +12909 +12910 +5293 +5780 +248 +237 +12911 +48 +6871 +12912 +1149 +14 +2 +12913 +14 +12914 +12915 +12916 +48 +283 +12917 +6618 +1364 +12621 +1817 +8249 +12918 +14 +43 +790 +3519 +1049 +12919 +3553 +89 +2 +12920 +11963 +12921 +2042 +12922 +548 +3317 +4028 +12923 +1956 +104 +2577 +12924 +1232 +14 +12925 +9999 +43 +1160 +12926 +237 +43 +10880 +43 +12927 +11762 +12928 +48 +5089 +59 +19 +12929 +12930 +616 +1011 +12931 +10 +12932 +12933 +14 +48 +2577 +43 +11085 +12934 +1232 +5134 +12935 +10908 +4899 +12936 +2686 +665 +11808 +12937 +1082 +12938 +12939 +237 +12940 +7836 +12941 +7945 +2356 +12942 +19 +2202 +12943 +1745 +12944 +436 +2 +16 +43 +915 +2577 +12945 +15 +43 +1223 +12946 +1082 +5614 +12947 +12948 +12949 +12950 +4125 +274 +272 +5410 +12951 +43 +14 +12952 +10880 +12953 +286 +12954 +4352 +379 +12955 +12956 +48 +48 +12957 +1451 +2804 +7357 +155 +1091 +5791 +12958 +12959 +12960 +43 +1513 +12961 +5860 +3755 +12962 +536 +6537 +272 +12963 +12964 +43 +185 +5963 +12965 +352 +12966 +12967 +12968 +48 +12969 +2264 +12970 +1051 +48 +114 +1425 +1090 +7419 +19 +12971 +12972 +12973 +9 +12974 +43 +12975 +379 +1749 +1154 +5769 +12976 +48 +12977 +493 +14 +12978 +554 +10880 +12979 +165 +12980 +12981 +12982 +9849 +12983 +12984 +12985 +12986 +12987 +12988 +2561 +15 +9749 +12989 +43 +12990 +647 +357 +12991 +2 +12992 +12993 +810 +576 +12994 +12995 +12067 +12996 +3743 +6285 +12997 +2009 +35 +272 +12998 +286 +809 +272 +1012 +2919 +1716 +237 +12999 +66 +357 +8297 +2314 +269 +586 +1425 +13000 +10 +365 +872 +13001 +13002 +13003 +13004 +272 +13005 +13006 +15 +43 +6718 +14 +13007 +2302 +48 +13008 +554 +1112 +13009 +13010 +493 +13011 +4789 +13012 +1655 +1051 +13013 +14 +5627 +13014 +155 +337 +13015 +13016 +13017 +13018 +2314 +13019 +213 +43 +13020 +357 +48 +13021 +4907 +13022 +43 +13023 +13024 +15 +13025 +32 +13026 +13027 +12067 +43 +317 +155 +184 +286 +13028 +48 +13029 +741 +12402 +1765 +2260 +13030 +2330 +305 +213 +4963 +10 +12684 +13031 +303 +13032 +43 +2764 +48 +13033 +764 +14 +43 +2314 +209 +491 +13034 +14 +712 +13035 +13036 +2045 +736 +13037 +2 +13038 +43 +48 +595 +7053 +13039 +2 +13040 +48 +14 +13041 +13042 +2463 +13043 +2459 +13044 +2499 +764 +13045 +2561 +5418 +13046 +13047 +237 +14 +5780 +99 +303 +43 +357 +13048 +13049 +43 +48 +13050 +13051 +707 +48 +974 +13052 +13053 +12195 +15 +13054 +14 +48 +13055 +13056 +10930 +13057 +286 +713 +12067 +13058 +14 +89 +788 +13059 +1961 +30 +60 +13060 +11787 +13061 +43 +303 +501 +237 +13062 +2957 +1437 +13063 +3 +13064 +13065 +13066 +210 +554 +13067 +237 +11754 +13068 +13069 +13070 +13071 +115 +13072 +13073 +237 +5780 +10 +9784 +237 +7256 +13074 +13075 +1051 +43 +13076 +13077 +43 +155 +13078 +43 +12005 +3561 +13079 +9395 +14 +13080 +13081 +349 +43 +14 +48 +1502 +48 +7208 +13082 +15 +6480 +13083 +6870 +13084 +13085 +4756 +48 +10 +286 +13086 +142 +3546 +13087 +5780 +19 +14 +3553 +48 +5679 +3546 +13088 +12987 +3480 +13089 +491 +13090 +13091 +349 +1364 +3553 +2314 +13092 +554 +2619 +4028 +1961 +1533 +19 +192 +16 +13093 +43 +10 +9713 +43 +48 +13094 +357 +19 +3 +48 +13095 +1021 +13096 +1018 +4982 +491 +43 +989 +2 +48 +416 +2395 +13097 +13098 +14 +2019 +349 +13099 +13100 +1901 +237 +9987 +13101 +694 +3543 +140 +13102 +13103 +4765 +2310 +14 +493 +13104 +1513 +43 +13105 +647 +19 +665 +4028 +188 +1817 +13106 +8249 +57 +13107 +303 +13108 +66 +13109 +13110 +12 +43 +13111 +2 +284 +741 +5780 +48 +237 +34 +14 +872 +48 +984 +57 +13112 +48 +2181 +974 +48 +1423 +13113 +2 +43 +1605 +13114 +13115 +13116 +13117 +48 +2 +872 +13118 +35 +613 +554 +48 +77 +4380 +13119 +15 +201 +11224 +14 +12987 +43 +13120 +13121 +35 +6484 +13122 +43 +13123 +48 +13124 +712 +6251 +137 +13125 +13126 +48 +32 +1765 +35 +12987 +14 +11702 +13127 +43 +13128 +43 +13129 +13130 +13131 +493 +5293 +1738 +13132 +12987 +77 +237 +13133 +13134 +13135 +225 +2733 +43 +48 +13011 +13136 +249 +13137 +4960 +2561 +13138 +237 +43 +2513 +13139 +13140 +9 +597 +13141 +43 +303 +10 +3 +13142 +13143 +411 +19 +303 +8867 +377 +305 +13144 +13145 +1232 +13146 +616 +13147 +13148 +1364 +43 +13149 +892 +13150 +43 +554 +13151 +43 +2463 +4461 +43 +13152 +317 +1612 +48 +1013 +14 +13153 +11498 +1224 +43 +14 +43 +14 +178 +13154 +13155 +188 +43 +2733 +13156 +849 +10365 +13157 +686 +936 +43 +13158 +43 +201 +13159 +13160 +464 +48 +13161 +13162 +13163 +13164 +5827 +48 +13165 +13166 +2697 +12893 +20 +13167 +13168 +13169 +5318 +196 +13170 +13171 +7449 +13172 +13173 +1051 +872 +13174 +13175 +13176 +89 +8248 +14 +1214 +13177 +13178 +1356 +2577 +5659 +48 +6595 +13179 +305 +741 +1384 +48 +43 +43 +13180 +43 +13181 +13182 +373 +1377 +2035 +11762 +13183 +13184 +13185 +13186 +13187 +348 +13188 +112 +13189 +14 +13190 +2 +13191 +741 +2064 +13192 +13193 +43 +1232 +13194 +9 +1823 +242 +11822 +1051 +13195 +20 +13196 +13197 +2356 +13198 +1120 +2835 +13199 +155 +13200 +13201 +13202 +741 +48 +464 +2239 +13203 +13204 +2593 +13205 +8849 +2239 +13206 +13207 +1335 +13208 +9232 +13209 +14 +13210 +4730 +2064 +209 +13211 +77 +13212 +741 +15 +13213 +13214 +12203 +10262 +3 +7595 +11428 +13215 +9 +2577 +43 +13216 +98 +20 +43 +1612 +286 +397 +13217 +14 +14 +6341 +5780 +13218 +46 +13219 +48 +13220 +3059 +5169 +13221 +13222 +4980 +35 +57 +692 +1559 +736 +13223 +32 +491 +13224 +7137 +13225 +845 +43 +13226 +13227 +1655 +43 +11482 +13228 +13229 +1428 +554 +99 +13230 +2 +5780 +1244 +14 +1229 +98 +915 +13231 +13232 +13233 +201 +1169 +13234 +872 +2919 +13235 +554 +48 +13236 +323 +13237 +13238 +13239 +13240 +48 +16 +13241 +741 +13242 +13243 +2414 +4536 +48 +12807 +554 +2 +11762 +32 +43 +11593 +13244 +3709 +13245 +13246 +13247 +13248 +12203 +35 +5833 +77 +13249 +35 +286 +13250 +14 +2131 +2042 +13251 +10 +250 +1559 +13252 +1296 +13253 +13254 +1091 +13255 +13256 +12987 +1018 +48 +13257 +14 +13258 +354 +13259 +13260 +43 +43 +43 +13261 +2064 +13262 +13263 +6874 +480 +5780 +5212 +1612 +590 +8367 +2769 +528 +104 +43 +13264 +692 +1013 +14 +209 +13265 +6123 +613 +13266 +43 +209 +13267 +248 +7855 +6732 +9 +14 +176 +13268 +213 +323 +43 +13269 +736 +48 +66 +373 +13270 +7032 +13271 +13272 +13273 +13274 +11754 +13275 +10239 +13276 +5780 +272 +48 +13277 +13278 +13279 +11754 +13280 +1817 +13281 +303 +14 +873 +4 +1217 +13282 +13283 +13284 +13285 +13286 +4851 +155 +185 +13287 +13288 +13289 +13290 +13291 +13292 +43 +32 +13293 +286 +5992 +48 +13294 +13295 +48 +185 +2865 +849 +155 +237 +736 +6400 +13296 +1310 +11754 +1425 +13297 +13162 +13298 +411 +14 +48 +13299 +248 +13300 +13301 +13302 +358 +48 +13303 +8297 +13304 +13305 +10 +15 +5806 +13306 +43 +14 +13307 +43 +10362 +13308 +13309 +13310 +188 +13311 +13312 +13313 +13314 +13315 +554 +13316 +13317 +13318 +2035 +8076 +2697 +303 +13307 +48 +43 +3480 +764 +13319 +43 +349 +770 +9364 +13320 +13321 +13322 +1376 +13323 +915 +13324 +19 +5169 +741 +13325 +12460 +48 +43 +357 +13326 +13327 +19 +284 +1251 +14 +155 +286 +2 +57 +43 +43 +43 +13328 +13329 +741 +9 +13330 +416 +13331 +2804 +22 +1112 +11961 +5316 +554 +10 +13332 +43 +13333 +13334 +558 +4441 +305 +647 +741 +337 +48 +1051 +43 +13335 +12987 +598 +3546 +43 +13336 +13337 +13338 +13339 +13340 +971 +13341 +13342 +1082 +43 +48 +48 +13343 +13344 +6877 +13345 +13346 +237 +13347 +2733 +13348 +43 +14 +1710 +48 +11607 +13175 +707 +822 +2 +3995 +286 +13349 +3543 +323 +686 +1743 +32 +10 +13350 +237 +1107 +13351 +13352 +2 +1107 +13353 +210 +80 +2 +1234 +13354 +19 +48 +13355 +13356 +48 +616 +3425 +1745 +1693 +112 +176 +210 +43 +13357 +188 +554 +1300 +13358 +8946 +13359 +13360 +1232 +10 +554 +425 +13361 +13362 +48 +7226 +9402 +13248 +13363 +14 +13364 +2561 +1927 +13365 +19 +43 +13366 +19 +707 +6950 +13367 +48 +2591 +237 +48 +22 +9237 +13368 +1542 +3546 +14 +530 +2 +2804 +1889 +43 +13369 +15 +13370 +1082 +741 +5192 +1232 +9 +48 +13371 +43 +6441 +13372 +1531 +43 +89 +13373 +155 +1287 +795 +13374 +10 +248 +13375 +1716 +43 +43 +13376 +15 +2591 +284 +3251 +19 +213 +7945 +176 +10899 +48 +48 +8392 +43 +43 +647 +13223 +19 +4963 +43 +2012 +43 +48 +303 +248 +66 +57 +1232 +13377 +48 +2804 +43 +43 +1371 +13378 +12402 +5781 +416 +13379 +1141 +14 +13380 +185 +1232 +48 +20 +2 +13381 +13382 +197 +13383 +741 +13384 +14 +6484 +2768 +13385 +6940 +22 +13386 +647 +286 +11754 +13387 +317 +2 +13388 +1920 +237 +13389 +13390 +13391 +13392 +13393 +43 +43 +1514 +48 +1335 +43 +13394 +13395 +741 +13396 +15 +1543 +13397 +7998 +736 +13398 +3 +3284 +1710 +32 +5211 +43 +13399 +13400 +201 +15 +9451 +12807 +12563 +222 +237 +12987 +13401 +13402 +13403 +43 +8448 +13404 +32 +13405 +11330 +284 +48 +1011 +13406 +13407 +15 +43 +13408 +19 +286 +13409 +13410 +2347 +240 +178 +32 +14 +13411 +9 +35 +188 +48 +741 +8151 +13412 +13413 +13414 +872 +13415 +590 +13416 +32 +1817 +13417 +3279 +2804 +13418 +10356 +13419 +14 +5022 +13420 +5065 +13421 +13422 +48 +590 +1051 +806 +282 +13423 +284 +5080 +464 +3406 +7739 +1384 +14 +2084 +13424 +8367 +43 +272 +1425 +1112 +13425 +43 +9258 +43 +13426 +43 +13427 +155 +13428 +560 +2 +1010 +13429 +12807 +13430 +13195 +13431 +13432 +13433 +13434 +13435 +209 +13436 +286 +3317 +48 +13437 +5780 +4055 +48 +323 +201 +13438 +22 +7855 +13439 +2 +13440 +13441 +3452 +13442 +13443 +5780 +342 +13444 +48 +486 +286 +13445 +171 +770 +13446 +13447 +2550 +48 +13448 +1577 +1399 +13449 +13450 +43 +1226 +13451 +48 +1051 +209 +43 +10 +989 +7836 +48 +48 +13452 +13453 +279 +13454 +286 +13455 +560 +43 +13456 +13457 +39 +3546 +13458 +4388 +12402 +3546 +1203 +109 +2330 +188 +179 +13459 +13460 +43 +4963 +15 +32 +13461 +13462 +4747 +736 +13463 +43 +2944 +1716 +13464 +13465 +5933 +491 +11817 +13466 +12372 +13467 +13468 +13469 +115 +19 +13470 +1847 +13471 +13472 +1232 +19 +971 +48 +32 +4257 +13473 +13474 +13475 +892 +10 +583 +590 +12926 +43 +14 +13476 +7208 +13477 +3066 +13478 +13479 +13480 +4806 +13481 +13482 +647 +13483 +2029 +13484 +13485 +48 +48 +13486 +13487 +13488 +13489 +11762 +1920 +8893 +32 +14 +43 +13490 +13491 +554 +43 +1112 +13492 +5318 +13493 +13494 +13394 +2 +43 +43 +1048 +13495 +7053 +13496 +13497 +1384 +188 +13498 +4716 +4313 +5659 +43 +13499 +13500 +13501 +11593 +13502 +13503 +13504 +179 +48 +48 +4020 +13505 +13506 +1765 +38 +4125 +2865 +13507 +13508 +1566 +43 +14 +10 +3546 +4934 +13509 +13510 +3 +10 +1425 +48 +13511 +13512 +13513 +237 +1481 +13514 +2165 +2427 +188 +464 +13515 +237 +13516 +13517 +13518 +1617 +188 +43 +13519 +13520 +58 +13521 +1232 +13522 +8244 +1562 +590 +13523 +13524 +1454 +484 +11238 +1244 +4 +4313 +13525 +36 +89 +19 +2896 +13526 +13527 +12310 +43 +286 +43 +4388 +13528 +48 +1021 +6990 +32 +1632 +43 +11822 +1696 +5780 +13529 +46 +2 +13530 +648 +43 +379 +2019 +4388 +7544 +379 +2593 +13531 +597 +184 +13532 +358 +13533 +13534 +13535 +13536 +193 +13537 +13538 +13539 +13540 +8188 +2136 +13541 +43 +10 +13542 +13543 +2577 +464 +66 +13544 +48 +13545 +2314 +677 +13546 +2913 +13547 +5780 +13548 +11483 +167 +13549 +1710 +13550 +284 +13551 +13552 +43 +248 +13553 +872 +14 +1559 +48 +3546 +14 +705 +14 +2463 +1107 +43 +733 +14 +48 +13554 +13555 +10280 +493 +13556 +1529 +13557 +2944 +4806 +284 +13558 +5009 +936 +155 +1425 +43 +13559 +272 +13560 +25 +213 +13561 +43 +13361 +13562 +2550 +3546 +43 +872 +13563 +48 +13564 +43 +32 +13565 +13566 +13567 +770 +10028 +2 +43 +10950 +237 +19 +13568 +13569 +43 +464 +8102 +13570 +799 +1901 +43 +14 +16 +13571 +12093 +13572 +112 +43 +210 +13573 +14 +790 +13574 +14 +1612 +48 +29 +1044 +484 +196 +770 +32 +155 +3408 +9948 +13575 +9 +13576 +2911 +10 +646 +13577 +1013 +12808 +13578 +57 +13579 +237 +2 +1415 +564 +8460 +11039 +184 +665 +43 +48 +43 +209 +13580 +13581 +3759 +736 +13582 +43 +13583 +5837 +14 +13584 +4762 +13585 +13586 +19 +48 +13587 +474 +209 +6188 +286 +1765 +48 +647 +43 +12372 +43 +210 +13588 +13589 +6776 +13590 +222 +7887 +13591 +13592 +43 +13593 +931 +828 +1514 +279 +6671 +647 +13594 +13595 +741 +13596 +48 +13597 +13598 +13599 +48 +2 +3354 +43 +2591 +13600 +13601 +14 +13602 +13603 +13604 +1920 +14 +13605 +369 +8230 +9633 +2053 +13606 +13607 +29 +4764 +43 +1100 +43 +15 +14 +13608 +1157 +43 +13609 +12788 +237 +13610 +248 +32 +13611 +397 +4677 +13612 +13613 +13614 +13615 +13616 +4028 +337 +13617 +14 +2 +11754 +13618 +11754 +6595 +13619 +48 +284 +2 +13620 +48 +736 +12299 +8569 +13621 +2919 +7048 +2251 +43 +13622 +303 +48 +13623 +20 +3732 +3546 +48 +13624 +237 +1655 +647 +48 +2954 +13625 +2213 +13626 +13627 +13628 +333 +8614 +13629 +708 +48 +13630 +272 +13631 +2560 +9560 +13632 +48 +188 +43 +6874 +4900 +66 +1870 +13633 +13634 +13635 +13636 +19 +48 +237 +3 +13637 +99 +48 +43 +13638 +2093 +188 +13639 +13640 +57 +13641 +13642 +6720 +3745 +533 +16 +646 +3546 +13643 +13644 +20 +397 +1529 +1961 +2040 +14 +15 +48 +48 +399 +13645 +14 +415 +188 +7291 +665 +13646 +13647 +1566 +13648 +13649 +201 +13650 +13651 +2577 +5780 +301 +14 +2 +9 +48 +13652 +4028 +13653 +13654 +1684 +13030 +10003 +48 +19 +1425 +14 +554 +741 +13655 +10880 +96 +1502 +1992 +3546 +43 +13656 +1765 +43 +13657 +13658 +13659 +7517 +13660 +48 +14 +13661 +1234 +19 +13662 +272 +43 +13663 +6214 +13664 +379 +13665 +13666 +201 +13667 +43 +48 +13668 +11482 +13669 +13670 +2790 +3546 +43 +13671 +13672 +14 +491 +4684 +13673 +13674 +3546 +13675 +13676 +3546 +354 +48 +13677 +13678 +764 +43 +4963 +3507 +13679 +48 +873 +13680 +10 +13681 +13682 +4028 +4028 +13683 +13684 +12987 +13685 +1559 +13686 +13687 +13688 +13689 +1538 +237 +1011 +2865 +861 +142 +13690 +1082 +616 +13691 +155 +13692 +43 +357 +5005 +1310 +13693 +4174 +32 +5577 +2260 +14 +616 +784 +13694 +11754 +12999 +12824 +2804 +185 +43 +48 +399 +9 +1364 +305 +1049 +286 +13179 +13695 +43 +11754 +1335 +48 +237 +13696 +48 +1066 +6095 +13697 +13698 +12479 +286 +2309 +43 +415 +13699 +1203 +764 +48 +155 +554 +13700 +4364 +861 +46 +15 +13701 +13702 +57 +14 +13703 +2804 +533 +104 +3546 +19 +48 +13390 +155 +48 +12987 +13704 +486 +13705 +19 +155 +6214 +3908 +10649 +13706 +14 +13707 +43 +11754 +13708 +14 +13709 +13710 +43 +493 +373 +13711 +57 +1578 +13712 +13713 +2 +43 +48 +1428 +13714 +2 +286 +13715 +286 +1655 +19 +564 +13716 +4313 +13717 +43 +13718 +13719 +19 +140 +1232 +2537 +3546 +13720 +2668 +3 +13721 +32 +48 +155 +13722 +317 +1765 +357 +13282 +13723 +11508 +13724 +13725 +43 +6950 +13726 +872 +77 +13727 +13728 +6222 +13729 +741 +17 +13730 +3354 +12987 +13731 +48 +48 +237 +1604 +13732 +80 +1562 +1577 +873 +32 +13733 +48 +9112 +554 +13734 +13735 +377 +43 +1920 +13566 +1514 +764 +12397 +13736 +13737 +13738 +13739 +13740 +3842 +892 +13741 +2769 +13742 +13743 +1013 +13744 +13745 +43 +2064 +48 +13746 +616 +2733 +8102 +13747 +650 +2 +43 +13748 +13749 +4 +1612 +142 +1051 +12067 +13750 +323 +188 +1425 +43 +13751 +19 +13752 +13733 +15 +237 +13753 +155 +13754 +2302 +7053 +19 +13755 +1091 +10 +703 +286 +13756 +13757 +13758 +2804 +4357 +3546 +14 +13759 +7276 +43 +43 +1026 +225 +33 +791 +13760 +4522 +286 +178 +11762 +13761 +13762 +13763 +7431 +9 +43 +237 +13764 +13760 +3546 +13765 +43 +13766 +13767 +13768 +943 +57 +11593 +14 +13769 +98 +43 +1112 +20 +179 +43 +1961 +464 +13770 +13771 +13772 +43 +13773 +3768 +43 +554 +176 +2309 +13774 +13775 +12932 +48 +13776 +13777 +13778 +1051 +2253 +13779 +958 +13780 +43 +13781 +13782 +1091 +12590 +98 +237 +616 +13783 +2 +13784 +13785 +13786 +464 +741 +13787 +185 +13788 +13789 +13790 +237 +7960 +13791 +43 +5780 +43 +20 +12407 +484 +13792 +13793 +13794 +7328 +5780 +43 +43 +3395 +237 +13795 +1543 +112 +915 +1154 +286 +286 +13796 +48 +22 +13797 +11362 +13798 +439 +13799 +1090 +228 +13800 +13801 +43 +25 +736 +35 +185 +1100 +9705 +12987 +3546 +43 +13311 +14 +13205 +741 +29 +1465 +13802 +237 +6182 +2 +57 +13803 +13804 +14 +13805 +237 +13806 +213 +48 +19 +13566 +13260 +237 +7855 +13807 +13808 +1012 +13809 +13810 +13811 +13812 +248 +2804 +1870 +13813 +48 +2310 +13814 +6915 +13802 +13815 +13816 +915 +2 +13817 +5438 +13818 +2 +337 +43 +4217 +305 +32 +1425 +12159 +248 +13819 +13820 +12596 +152 +213 +13393 +13821 +13822 +9 +13823 +14 +4943 +48 +6638 +13824 +13825 +43 +1920 +13826 +152 +43 +112 +14 +13827 +13828 +48 +13829 +2 +5780 +11158 +703 +4745 +1287 +43 +201 +13830 +20 +248 +13831 +48 +11670 +29 +554 +13832 +43 +554 +286 +7891 +13833 +13834 +13835 +3546 +5418 +13836 +249 +13837 +2 +13838 +15 +274 +7855 +36 +399 +13839 +402 +1217 +19 +7960 +741 +48 +358 +14 +12746 +8418 +209 +13840 +43 +13841 +13842 +2919 +13843 +43 +13844 +11754 +13845 +1224 +564 +48 +57 +12220 +6371 +13846 +554 +13847 +2 +43 +43 +43 +1384 +2804 +13848 +13849 +13850 +43 +13851 +13852 +152 +411 +237 +915 +13853 +48 +237 +13854 +13855 +2334 +286 +237 +7137 +43 +14 +188 +19 +22 +2694 +104 +14 +11762 +616 +213 +2697 +48 +4055 +10 +13856 +13857 +13858 +48 +237 +48 +4634 +14 +13859 +13643 +303 +10 +1224 +248 +397 +48 +12600 +237 +13860 +303 +554 +5780 +1112 +48 +13861 +13459 +32 +303 +303 +48 +13862 +137 +13863 +13864 +13865 +13866 +13867 +43 +13868 +590 +13869 +1502 +736 +554 +2029 +14 +13870 +13871 +1719 +13872 +915 +3546 +13873 +357 +43 +176 +13874 +43 +1224 +915 +3546 +13875 +13876 +13877 +13878 +1051 +13879 +1232 +13880 +915 +237 +3546 +13881 +3546 +1115 +77 +12642 +2 +495 +1442 +104 +2762 +19 +13882 +13883 +32 +13884 +13885 +286 +14 +7208 +2414 +11762 +827 +3066 +13886 +970 +323 +13887 +13888 +4963 +13889 +57 +13890 +13891 +14 +13892 +3415 +3003 +20 +48 +3 +822 +152 +1112 +57 +13893 +48 +13894 +32 +48 +3546 +13895 +43 +1513 +43 +155 +1011 +20 +13896 +155 +1700 +13897 +43 +16 +13898 +104 +720 +5601 +13899 +13900 +13901 +13902 +357 +13903 +13904 +13201 +13905 +286 +48 +13906 +10287 +2579 +35 +11800 +43 +13907 +741 +694 +32 +1517 +13908 +13909 +237 +237 +13910 +358 +20 +13911 +13912 +13913 +1716 +331 +647 +2314 +13914 +13915 +48 +13916 +8826 +14 +13917 +19 +13918 +48 +13919 +13920 +22 +1364 +1051 +43 +349 +13921 +104 +43 +1091 +13922 +1224 +554 +14 +624 +15 +299 +13923 +272 +14 +13924 +13925 +1091 +647 +2 +3546 +48 +13926 +616 +43 +11762 +13927 +13928 +188 +13929 +369 +1100 +13930 +13931 +19 +8392 +13932 +19 +13933 +3553 +8378 +14 +3973 +155 +14 +185 +13934 +43 +2430 +14 +8098 +43 +19 +1153 +13935 +13936 +373 +13937 +799 +237 +13938 +3546 +13939 +11907 +686 +13940 +13941 +3570 +43 +43 +33 +13942 +1753 +13943 +1514 +495 +590 +6505 +13944 +13945 +13946 +286 +1817 +13947 +13948 +4963 +165 +373 +3323 +155 +13949 +12120 +13950 +5202 +13951 +48 +1920 +57 +48 +13952 +13953 +13954 +15 +1229 +13955 +2463 +66 +5990 +43 +10642 +209 +43 +13956 +7855 +36 +13957 +48 +13958 +3546 +13959 +14 +7991 +48 +43 +1082 +1920 +333 +2694 +155 +43 +48 +13960 +13961 +13962 +1232 +43 +14 +1632 +6877 +1109 +43 +12267 +13963 +13964 +10 +11754 +398 +416 +13965 +13966 +13967 +13968 +19 +13969 +43 +2414 +13970 +3382 +583 +43 +43 +209 +12180 +48 +13733 +8867 +13971 +741 +14 +13972 +188 +13973 +43 +915 +2577 +13974 +14 +13975 +43 +6741 +12913 +43 +13976 +237 +48 +112 +2 +3439 +13977 +13978 +5601 +2314 +13979 +10880 +3421 +2 +13980 +13981 +13982 +5344 +14 +10 +14 +188 +13983 +13984 +14 +305 +10 +11341 +15 +13985 +13986 +1790 +43 +13987 +2561 +677 +25 +2 +12987 +14 +13988 +13989 +1513 +2213 +9738 +3546 +13990 +9 +13991 +57 +13992 +11754 +6785 +11308 +2733 +104 +237 +12987 +2891 +958 +1229 +11754 +1208 +14 +112 +46 +259 +13993 +237 +13179 +48 +48 +554 +14 +48 +1765 +4364 +188 +48 +13994 +7336 +112 +152 +13995 +3 +1232 +13996 +13997 +3916 +237 +286 +14 +43 +741 +13998 +554 +11762 +6766 +5973 +43 +13999 +278 +14000 +66 +1696 +365 +14001 +152 +14002 +10 +9739 +14003 +14004 +43 +14005 +14006 +43 +3279 +19 +14007 +1612 +14008 +2 +14 +14009 +2446 +48 +57 +15 +352 +14010 +14011 +48 +13464 +286 +14 +48 +1817 +42 +14012 +2 +43 +19 +14013 +14014 +14015 +2 +2 +1224 +14016 +14 +14017 +14018 +2733 +48 +741 +5780 +1203 +48 +14019 +14020 +14021 +13935 +14 +237 +4411 +2 +32 +323 +14022 +2457 +3406 +3250 +112 +43 +48 +751 +14023 +13935 +14024 +3546 +19 +6950 +13336 +2012 +48 +14025 +13325 +188 +14026 +14 +1224 +11754 +14027 +3452 +152 +1560 +379 +736 +14028 +610 +4227 +14029 +14030 +286 +741 +48 +48 +14031 +14032 +48 +14033 +3989 +14034 +14035 +7799 +13179 +9 +14036 +14037 +14038 +14039 +14040 +14041 +53 +430 +14042 +8512 +14043 +345 +1870 +286 +14044 +707 +13929 +989 +12402 +19 +237 +14 +19 +2153 +554 +14045 +14046 +14047 +6463 +278 +14048 +14049 +57 +14 +272 +43 +1364 +286 +446 +14050 +14051 +3958 +14052 +5981 +14053 +14054 +43 +14055 +15 +554 +14056 +1637 +439 +11471 +2944 +14057 +14058 +36 +971 +237 +237 +14059 +14060 +14061 +6054 +14062 +14063 +43 +3546 +14064 +14065 +14066 +14067 +5780 +48 +19 +14068 +305 +3484 +15 +3546 +14069 +19 +10230 +14070 +14071 +1012 +138 +10230 +14072 +5780 +104 +1991 +20 +43 +764 +14073 +57 +14074 +14075 +14076 +648 +3546 +14077 +48 +7835 +48 +2042 +2058 +14078 +43 +137 +14079 +3 +48 +14080 +2197 +14081 +14 +16 +14082 +349 +14083 +14084 +14085 +14086 +14 +13452 +2 +6518 +5627 +43 +590 +14087 +2694 +48 +48 +9410 +554 +3310 +57 +910 +137 +9543 +48 +14088 +14089 +43 +486 +14090 +14091 +14092 +17 +14093 +741 +43 +8727 +6776 +286 +648 +14094 +764 +3546 +4398 +5780 +872 +3 +196 +14 +43 +1220 +43 +3239 +176 +14095 +14096 +745 +14097 +245 +14098 +43 +14099 +14100 +14101 +1232 +14102 +1559 +142 +14103 +2577 +14104 +140 +14105 +2314 +354 +14106 +43 +14107 +14108 +14 +237 +14109 +237 +13843 +323 +4855 +14110 +14111 +2804 +1112 +14112 +14113 +1203 +14114 +14 +1821 +305 +43 +237 +14115 +286 +10880 +1100 +2430 +14 +4971 +14116 +13772 +57 +237 +14117 +12404 +14 +14118 +397 +137 +1566 +19 +12893 +1056 +14119 +19 +317 +43 +237 +373 +48 +491 +2988 +14120 +14121 +77 +14122 +7357 +764 +14123 +887 +1374 +14124 +495 +209 +1800 +14125 +5192 +20 +3287 +14126 +179 +11754 +14127 +5041 +19 +14128 +48 +7855 +14129 +1232 +14130 +5556 +14131 +28 +286 +48 +14132 +13913 +43 +14133 +14134 +13349 +14 +19 +14135 +683 +14 +14136 +43 +989 +57 +14137 +272 +14138 +237 +237 +2804 +354 +194 +2 +14139 +14140 +13282 +4461 +194 +3543 +53 +48 +19 +3 +43 +14141 +14142 +14 +48 +9400 +13842 +32 +14143 +210 +14144 +14145 +416 +19 +48 +5780 +14146 +66 +14147 +14148 +14149 +4963 +14150 +237 +8733 +43 +13390 +14151 +11754 +14152 +1011 +768 +8460 +14 +1710 +14153 +736 +14154 +136 +48 +43 +142 +20 +3546 +14155 +1229 +48 +14156 +14157 +536 +2035 +6341 +38 +14158 +185 +14159 +43 +3052 +317 +317 +2197 +3 +43 +2577 +43 +14160 +14161 +14162 +12555 +43 +14163 +19 +4990 +48 +35 +14164 +14165 +43 +1181 +14166 +548 +14167 +720 +14168 +14169 +178 +4278 +14170 +14171 +20 +14172 +1166 +43 +19 +43 +14173 +43 +12067 +379 +25 +2769 +14174 +3546 +14175 +14176 +284 +14177 +98 +14178 +827 +2015 +554 +284 +48 +1300 +8566 +43 +14179 +5780 +14180 +225 +14181 +14182 +48 +48 +1425 +1376 +9 +32 +9410 +213 +14183 +14174 +14 +237 +349 +48 +272 +188 +14 +12477 +958 +14184 +14185 +647 +6480 +10 +14186 +554 +14187 +201 +48 +7045 +2 +14188 +176 +915 +14189 +14190 +138 +14191 +14192 +19 +43 +14193 +10622 +57 +9688 +14194 +14195 +1287 +48 +4028 +14196 +5435 +2791 +48 +4634 +764 +43 +48 +971 +14197 +14198 +14199 +12456 +14200 +14201 +7817 +43 +237 +14202 +14203 +14204 +590 +14205 +6950 +20 +3066 +4028 +13685 +11421 +20 +3279 +14206 +14207 +14208 +20 +237 +3546 +14209 +7137 +213 +303 +1124 +20 +2804 +14210 +14211 +284 +43 +237 +57 +14212 +14001 +358 +48 +14213 +12987 +14214 +14215 +137 +7014 +155 +2316 +89 +14216 +15 +14217 +5169 +48 +3239 +286 +8994 +5780 +14218 +43 +19 +1175 +1010 +6950 +43 +14219 +48 +5949 +225 +14220 +14221 +22 +32 +14222 +733 +237 +14223 +43 +14 +14224 +303 +2 +1090 +14225 +14226 +14227 +14228 +9705 +14229 +14230 +14231 +14232 +48 +33 +14233 +286 +14234 +1927 +712 +720 +14235 +9 +4 +14236 +4730 +286 +736 +14237 +43 +323 +14238 +19 +536 +1870 +705 +12746 +305 +14239 +19 +43 +14240 +14241 +4852 +357 +14242 +14243 +14244 +248 +478 +13543 +8566 +7855 +112 +32 +14245 +2 +43 +14246 +14247 +14248 +14249 +286 +14 +647 +12937 +7256 +14250 +14251 +14252 +14253 +14254 +9 +14001 +13150 +14255 +6214 +14256 +14257 +272 +7855 +14258 +14259 +2841 +48 +4963 +14 +286 +43 +14260 +14261 +22 +14262 +536 +14263 +14264 +284 +14265 +248 +14266 +48 +337 +14267 +248 +3 +14268 +14 +248 +4263 +14269 +14270 +2600 +4053 +14271 +14272 +43 +14273 +19 +43 +201 +14 +14274 +16 +741 +14275 +14276 +14277 +1049 +2121 +1765 +2406 +2561 +337 +248 +43 +699 +342 +14278 +14279 +1710 +5582 +14 +14280 +14281 +32 +9918 +1224 +48 +8297 +14282 +48 +4570 +2316 +14283 +826 +4075 +57 +14284 +2 +14285 +14286 +14287 +1765 +14 +1604 +248 +48 +14288 +43 +48 +1425 +48 +14289 +14290 +1200 +1172 +14291 +822 +14292 +12402 +14293 +14 +19 +5243 +1992 +43 +286 +14294 +14295 +873 +14296 +48 +14297 +14 +1559 +14298 +2040 +14299 +14300 +14301 +6087 +2 +43 +14302 +14303 +43 +323 +14304 +1013 +152 +721 +14305 +10583 +5209 +425 +14306 +2349 +286 +237 +14307 +14 +14308 +14309 +14310 +14311 +14312 +14313 +14314 +57 +14315 +237 +48 +14316 +647 +8033 +14317 +1364 +14318 +736 +4226 +398 +14 +14319 +14320 +14321 +43 +165 +14322 +14323 +48 +408 +745 +915 +810 +14324 +155 +48 +43 +14325 +764 +14326 +72 +43 +9472 +48 +176 +14327 +14328 +14329 +590 +271 +43 +14330 +14331 +741 +5344 +12466 +3 +14332 +14333 +3546 +1655 +741 +14334 +14335 +2804 +19 +554 +155 +14 +14336 +1513 +14337 +14338 +20 +3546 +822 +43 +43 +64 +14339 +286 +6121 +5080 +14340 +775 +14 +4306 +14341 +2804 +14342 +8566 +14343 +3546 +3 +155 +10 +1385 +424 +14344 +14345 +14346 +720 +8428 +43 +14347 +14348 +14349 +2 +14350 +14351 +1013 +2314 +19 +12363 +43 +4637 +14 +1454 +14 +14352 +13748 +304 +14353 +29 +14354 +14355 +8554 +1228 +237 +43 +8188 +14356 +6363 +10 +14357 +764 +14 +123 +14358 +32 +4278 +9 +14359 +1415 +14360 +48 +15 +936 +14361 +14362 +14363 +14364 +14365 +741 +14366 +14367 +554 +3546 +14368 +6766 +15 +14369 +14370 +237 +14 +14371 +237 +248 +248 +14372 +19 +22 +14373 +32 +7522 +14374 +19 +14375 +4441 +9 +248 +14376 +14377 +303 +12343 +2804 +712 +11176 +43 +616 +3147 +14378 +3055 +14379 +155 +14380 +19 +19 +284 +9939 +823 +14381 +138 +14382 +19 +3743 +713 +14383 +14384 +14385 +3005 +14386 +43 +12013 +14387 +286 +1234 +14388 +140 +43 +155 +43 +305 +14389 +1203 +3546 +14390 +5770 +10 +554 +3886 +14391 +43 +14392 +14393 +19 +14394 +32 +14395 +11822 +1454 +741 +104 +5627 +8010 +14396 +14397 +14398 +2469 +14399 +3732 +14400 +14401 +14 +2324 +14402 +14403 +13823 +43 +14404 +14 +14405 +4192 +14406 +14407 +6728 +48 +14408 +14409 +3488 +14410 +720 +14411 +14412 +4388 +43 +14413 +57 +19 +48 +1696 +2308 +14414 +1343 +1524 +14415 +14416 +590 +14417 +89 +14418 +32 +647 +14419 +14420 +14421 +155 +590 +43 +9 +2847 +14422 +1465 +11966 +741 +14423 +14424 +770 +14425 +831 +4790 +14426 +14427 +474 +741 +282 +3546 +14428 +14 +14429 +14430 +1817 +5780 +14431 +14432 +1100 +5483 +48 +43 +14433 +1961 +5648 +2045 +14434 +14435 +14436 +48 +14437 +184 +43 +14 +13307 +48 +43 +14438 +11483 +14439 +14440 +14441 +140 +14442 +14443 +14444 +32 +14445 +286 +14446 +1540 +2463 +14447 +4020 +14448 +14449 +3711 +2 +196 +3546 +14450 +7176 +590 +14451 +14452 +1559 +14 +185 +137 +48 +764 +14453 +14454 +12404 +188 +48 +14455 +14456 +12746 +14457 +48 +14458 +1234 +57 +48 +14459 +337 +14460 +19 +14461 +14 +14462 +48 +3 +6970 +4765 +14463 +43 +14464 +590 +3976 +293 +104 +48 +14465 +4247 +14363 +43 +32 +57 +14466 +43 +286 +379 +590 +43 +14467 +57 +3216 +14 +12987 +14468 +14469 +19 +43 +12093 +43 +32 +60 +14470 +14471 +14472 +13798 +14473 +14 +7835 +14474 +13961 +13361 +286 +43 +3296 +2097 +19 +6294 +1258 +14475 +3757 +43 +4 +48 +1471 +14476 +647 +43 +590 +1051 +112 +1018 +14477 +14478 +14479 +5408 +237 +590 +36 +14480 +6595 +2944 +323 +43 +201 +3030 +19 +272 +14481 +188 +14482 +13566 +14483 +14484 +14485 +11762 +14486 +12479 +19 +712 +14487 +2561 +4917 +14488 +188 +48 +14489 +2561 +1559 +286 +14490 +357 +98 +9481 +436 +2561 +1425 +43 +1425 +32 +7283 +14491 +14477 +48 +6331 +14492 +155 +1710 +14493 +573 +764 +14494 +5483 +705 +14495 +14496 +14497 +554 +590 +57 +14 +57 +3543 +14 +48 +14498 +14499 +155 +397 +14500 +14501 +43 +11966 +14502 +5963 +2 +14503 +14 +14504 +14505 +3768 +43 +14506 +11762 +493 +14507 +14508 +3353 +3976 +2835 +11817 +43 +859 +10764 +2042 +14 +57 +1049 +12987 +12351 +3239 +48 +14509 +736 +196 +554 +1385 +14510 +14511 +712 +7183 +20 +14512 +8994 +14513 +2064 +14514 +14515 +1823 +43 +5739 +1617 +14278 +14363 +19 +14516 +19 +1859 +14517 +14518 +14519 +614 +29 +14520 +14521 +665 +1829 +810 +14522 +48 +14523 +14524 +14525 +43 +14526 +14527 +38 +845 +2 +14528 +286 +57 +14529 +428 +14530 +1154 +9112 +4808 +14531 +4028 +14532 +536 +43 +43 +8205 +349 +14533 +14534 +19 +112 +14535 +1051 +13508 +3808 +10 +1013 +14536 +1637 +1109 +43 +14537 +14538 +2039 +43 +590 +43 +14539 +3546 +14540 +14541 +6011 +14 +1011 +43 +14 +11740 +349 +14542 +590 +14543 +33 +20 +484 +48 +2459 +5318 +14544 +14 +1021 +872 +14545 +14546 +1710 +14547 +707 +14548 +112 +286 +48 +14549 +8263 +1051 +3 +48 +10137 +43 +12013 +1901 +13361 +14550 +152 +554 +5780 +48 +770 +14551 +14552 +48 +14553 +2064 +14554 +2882 +14555 +14556 +14557 +14558 +14559 +14560 +2550 +14561 +14562 +745 +10789 +358 +7471 +8297 +3034 +43 +446 +322 +14563 +32 +958 +14564 +4918 +4364 +178 +14565 +14566 +493 +590 +14567 +14568 +741 +349 +14569 +48 +13361 +14570 +14571 +8566 +915 +14572 +590 +1291 +1154 +14573 +43 +14574 +14575 +43 +14363 +14576 +48 +14577 +590 +155 +14 +6439 +104 +14578 +5080 +14579 +590 +872 +7855 +140 +14580 +14 +412 +14581 +9 +11762 +19 +6468 +48 +2 +14582 +1425 +48 +14583 +2463 +142 +14584 +7276 +323 +14585 +3546 +12987 +14586 +14587 +590 +14588 +14589 +14590 +14591 +14592 +14593 +3546 +352 +14 +14594 +5780 +76 +14595 +14 +14596 +14597 +20 +590 +14598 +155 +3252 +14599 +14600 +14515 +12987 +24 +14601 +8249 +14602 +43 +14603 +286 +12214 +915 +14604 +137 +3 +590 +14605 +8392 +43 +14606 +14607 +43 +14 +14 +14608 +14609 +14610 +14611 +43 +14612 +43 +14613 +3317 +188 +48 +11483 +6950 +14 +12987 +19 +14614 +14615 +647 +14616 +665 +1369 +692 +57 +19 +14617 +14618 +365 +9783 +14619 +14620 +14621 +14622 +14623 +590 +14624 +590 +3546 +14625 +188 +14626 +5162 +14627 +5601 +286 +849 +10993 +493 +14628 +14629 +2129 +286 +357 +12274 +14630 +14631 +14632 +9115 +590 +286 +1765 +1220 +8188 +48 +14633 +286 +43 +2040 +14634 +14 +14635 +43 +237 +11822 +14636 +140 +8218 +8457 +8297 +20 +8392 +43 +14637 +14638 +354 +7379 +14639 +20 +14640 +590 +1503 +14641 +379 +14642 +14643 +43 +155 +464 +286 +14644 +14645 +14646 +155 +764 +358 +20 +14647 +155 +237 +354 +14648 +10 +2035 +43 +57 +1605 +48 +14649 +741 +1217 +2 +14650 +19 +14651 +8740 +8896 +14652 +10 +14653 +14274 +14654 +2804 +13223 +14655 +14656 +2446 +12577 +590 +14657 +286 +43 +736 +14658 +14659 +43 +272 +964 +14660 +14661 +927 +5601 +3599 +14662 +46 +155 +14663 +14 +541 +554 +1716 +48 +7137 +43 +12661 +43 +1232 +3546 +741 +14664 +29 +48 +736 +590 +43 +338 +9900 +354 +14665 +14185 +12987 +14666 +2 +14667 +720 +8566 +2577 +14668 +5780 +9 +6499 +1765 +10 +590 +57 +249 +43 +14669 +155 +57 +1604 +14670 +14671 +14672 +14673 +14674 +14675 +14676 +1100 +3421 +14677 +741 +6439 +2828 +1617 +14678 +14679 +29 +7855 +12684 +12600 +43 +20 +4713 +19 +2577 +2577 +14680 +188 +14681 +14682 +19 +43 +3546 +14683 +354 +590 +9300 +2042 +788 +14684 +43 +19 +14685 +19 +323 +2476 +14686 +14687 +7341 +188 +284 +14363 +14688 +7653 +2430 +14689 +14690 +1637 +14 +85 +9210 +43 +14691 +14692 +48 +301 +14693 +14694 +11995 +4747 +12987 +14695 +140 +51 +66 +43 +10 +14696 +586 +2 +14 +284 +4963 +57 +20 +305 +303 +286 +703 +955 +1214 +14697 +10993 +48 +14698 +57 +43 +14699 +2324 +14604 +1082 +14700 +9 +43 +14701 +1056 +4873 +1612 +14702 +14703 +14704 +6809 +11428 +14705 +43 +14706 +2540 +48 +3553 +8297 +6903 +171 +48 +48 +14 +43 +43 +14001 +1066 +9078 +14707 +14708 +936 +137 +745 +7855 +14709 +14604 +14710 +14711 +590 +590 +3034 +14712 +13774 +590 +57 +19 +2042 +14713 +32 +590 +1232 +9278 +48 +13205 +647 +43 +1139 +12600 +11224 +48 +14714 +2197 +3 +43 +43 +590 +14715 +1220 +14716 +14717 +14718 +14719 +253 +19 +3546 +14720 +14721 +1696 +57 +48 +720 +554 +57 +14 +586 +14532 +2721 +14 +152 +14722 +5780 +14723 +14724 +48 +14725 +259 +14 +14691 +625 +770 +745 +3491 +4963 +43 +305 +2260 +6499 +8024 +14726 +764 +43 +5780 +43 +14727 +1229 +43 +14728 +2 +249 +14729 +14477 +2349 +14730 +1716 +1513 +590 +32 +3 +764 +1224 +14731 +671 +14477 +14732 +14 +2804 +237 +14733 +4227 +48 +251 +33 +155 +741 +14734 +14735 +590 +6011 +14736 +14737 +43 +554 +590 +14738 +14739 +14740 +14741 +14 +14742 +6741 +14743 +379 +14744 +57 +14745 +43 +14746 +14747 +14748 +373 +14749 +14750 +43 +736 +14751 +14752 +140 +741 +43 +3553 +7032 +14753 +1442 +14754 +9 +284 +6096 +10 +14755 +7897 +14756 +14757 +14758 +14759 +14760 +590 +1885 +484 +3553 +1049 +764 +9194 +14761 +14762 +4028 +1154 +533 +2287 +14763 +415 +19 +14764 +14765 +14766 +741 +9946 +13387 +43 +14767 +2577 +5134 +1051 +48 +8685 +590 +1425 +590 +2315 +14768 +1883 +14769 +2944 +720 +2859 +197 +272 +14770 +14771 +14 +14772 +590 +8188 +284 +379 +713 +14773 +590 +1415 +104 +14774 +209 +10 +9440 +303 +14775 +14695 +43 +14776 +2136 +14777 +14 +14778 +14779 +14780 +14477 +14781 +14782 +152 +43 +13375 +14494 +43 +188 +14 +14783 +9913 +14784 +14785 +20 +1232 +14786 +43 +48 +6106 +14787 +1115 +14788 +14789 +2 +2035 +14790 +14791 +741 +14363 +3543 +14792 +6766 +3764 +14793 +14794 +1716 +1181 +3553 +13223 +14795 +554 +43 +43 +14796 +484 +3484 +14797 +14798 +14799 +14800 +3 +2269 +14801 +1753 +1154 +14802 +14803 +14804 +138 +4518 +43 +14805 +14806 +1465 +536 +1013 +647 +14807 +14808 +14809 +14810 +14811 +14812 +14813 +1798 +14814 +10120 +590 +14815 +14816 +57 +14 +14817 +59 +14818 +14819 +12614 +1082 +358 +43 +9 +14820 +11696 +14821 +11754 +573 +8789 +5931 +3546 +14822 +14823 +11593 +14824 +2724 +42 +14825 +14826 +14827 +14828 +14829 +8297 +14830 +6341 +823 +14831 +43 +3251 +736 +14 +14015 +14832 +1107 +14833 +736 +1198 +14834 +14835 +14836 +14 +98 +19 +43 +57 +14837 +14838 +2 +1115 +14839 +14840 +48 +14841 +43 +155 +14842 +14843 +3844 +590 +14844 +43 +196 +14845 +14846 +19 +14847 +14848 +14849 +6917 +4532 +8217 +8116 +57 +14850 +305 +14851 +2593 +1051 +1547 +35 +14852 +14853 +352 +554 +2790 +152 +3842 +14854 +43 +14855 +778 +5601 +14856 +4088 +2164 +8566 +14857 +741 +13361 +11963 +590 +14858 +14859 +14860 +14861 +48 +11522 +32 +48 +32 +1817 +404 +80 +14862 +1824 +10 +43 +20 +6915 +590 +14863 +14864 +12404 +14415 +14865 +48 +10 +43 +14866 +736 +14867 +14868 +14869 +48 +14870 +14871 +14872 +554 +32 +1056 +43 +14873 +14874 +48 +2 +14875 +14876 +14877 +590 +1124 +14878 +14879 +14880 +12120 +14881 +14882 +1514 +43 +8610 +14883 +590 +14884 +3546 +1112 +14885 +12093 +43 +14886 +2859 +2764 +14000 +48 +590 +9922 +484 +43 +286 +915 +43 +1882 +4153 +14066 +14887 +155 +14888 +14 +590 +14889 +20 +48 +14890 +2733 +2243 +14891 +12987 +14892 +1369 +48 +590 +14893 +14894 +12005 +43 +14895 +43 +14896 +14897 +14 +14898 +14899 +1018 +590 +399 +14900 +237 +43 +590 +827 +14901 +14902 +14903 +14904 +14905 +14906 +14668 +201 +3 +10028 +3476 +14907 +397 +14908 +20 +10 +14477 +14909 +1261 +155 +14910 +48 +137 +14911 +14912 +14913 +14477 +10156 +2314 +43 +14914 +14 +464 +48 +14915 +185 +14916 +2865 +554 +14917 +11762 +43 +14918 +43 +14919 +286 +1232 +14 +155 +14920 +14921 +14922 +14923 +3 +142 +14924 +43 +14925 +10 +286 +14926 +14927 +48 +14928 +342 +9 +19 +14929 +14930 +2 +12246 +14931 +14932 +14933 +43 +14934 +7176 +2 +14935 +14936 +3546 +14 +2 +1732 +48 +14937 +32 +14938 +14939 +14940 +2804 +48 +19 +43 +3908 +14941 +14942 +14604 +14943 +14 +11822 +402 +5659 +554 +1228 +14944 +590 +11754 +7014 +8024 +7137 +122 +14945 +14946 +5650 +48 +11754 +14947 +48 +201 +869 +48 +10590 +43 +14948 +590 +48 +13985 +1920 +1891 +14949 +12055 +3546 +48 +14950 +14951 +43 +14952 +14953 +936 +14954 +4396 +15 +2308 +14955 +14956 +43 +590 +155 +14185 +43 +43 +590 +13349 +14957 +7509 +14958 +14959 +14960 +3546 +57 +14961 +1817 +892 +43 +14962 +14963 +14964 +19 +5080 +48 +11754 +43 +14634 +138 +14965 +14966 +14967 +14968 +736 +14969 +14970 +2764 +286 +14 +14971 +9 +2561 +1465 +14972 +12600 +14973 +14974 +286 +210 +142 +14975 +14976 +1226 +32 +1249 +3494 +14977 +1920 +590 +43 +14978 +554 +2463 +152 +20 +43 +32 +43 +11754 +590 +14979 +43 +14980 +32 +12600 +2577 +14981 +14982 +14983 +15 +14984 +590 +745 +1688 +14 +43 +2561 +2790 +14985 +43 +155 +3546 +3842 +3546 +14 +39 +14986 +43 +2029 +3949 +915 +590 +14987 +590 +286 +14988 +13361 +764 +1604 +43 +57 +14989 +104 +13570 +14332 +43 +1905 +14990 +10583 +4 +237 +849 +14991 +2 +14992 +4764 +872 +14993 +14994 +14995 +14996 +590 +1612 +19 +43 +14997 +112 +11762 +14998 +43 +590 +14999 +15000 +590 +2135 +9 +3546 +484 +10 +43 +590 +2035 +590 +15001 +15002 +155 +15003 +590 +590 +15004 +19 +43 +4028 +15005 +1804 +15006 +2125 +2047 +14 +15007 +15008 +10 +15009 +736 +48 +15010 +15011 +15012 +8512 +185 +32 +15013 +185 +13566 +43 +15014 +1513 +1229 +15015 +43 +15016 +14 +12987 +2 +3 +15017 +2804 +13576 +15018 +1716 +14 +15019 +15020 +12987 +15021 +2 +14001 +8098 +15022 +15023 +15024 +15025 +4760 +1364 +15026 +43 +2 +15027 +1578 +185 +323 +1244 +590 +15028 +43 +201 +590 +10356 +15029 +1232 +32 +7137 +213 +213 +15030 +15031 +6439 +15032 +14629 +15 +19 +15033 +305 +3546 +3743 +14 +15034 +32 +15035 +1244 +15036 +213 +3546 +1508 +15037 +2804 +286 +10147 +8896 +2 +48 +1112 +15038 +590 +590 +15039 +22 +337 +590 +764 +15040 +15041 +15042 +32 +140 +3 +590 +188 +15043 +9 +15044 +19 +15045 +597 +15046 +43 +4278 +2 +286 +43 +590 +741 +48 +20 +2 +15047 +43 +14327 +201 +3732 +112 +590 +48 +14477 +43 +14477 +15048 +14477 +15049 +1807 +43 +8188 +554 +15050 +15051 +13566 +354 +8220 +590 +1049 +3546 +15052 +590 +12605 +2064 +2 +11754 +2804 +43 +15053 +3546 +15054 +15055 +849 +12622 +590 +15056 +43 +43 +1889 +43 +590 +15057 +43 +14 +3546 +736 +6776 +43 +15058 +303 +15059 +764 +15060 +19 +1223 +491 +14 +15061 +1051 +720 +10222 +248 +48 +823 +5080 +286 +373 +764 +98 +590 +15062 +15063 +15064 +43 +15065 +14105 +35 +4760 +1578 +15066 +15067 +1745 +43 +6121 +43 +15068 +14973 +337 +32 +15069 +2 +15070 +197 +4487 +15071 +6950 +7291 +15072 +9705 +15073 +15074 +12600 +3546 +823 +500 +66 +43 +15075 +32 +15076 +15077 +13325 +3546 +1107 +15078 +4650 +15079 +15080 +15081 +13393 +15082 +15083 +43 +323 +15084 +15085 +48 +665 +1961 +1612 +13598 +15086 +15087 +6582 +15088 +13390 +32 +48 +15089 +1765 +17 +2314 +15090 +15091 +15092 +22 +137 +464 +590 +15093 +15094 +15095 +5041 +15096 +2 +15097 +2 +15098 +15099 +2 +43 +15100 +15101 +12862 +14 +647 +3543 +15102 +3553 +104 +2561 +29 +19 +15103 +12987 +3732 +15104 +57 +720 +15105 +15106 +43 +15107 +1524 +15108 +66 +1051 +15109 +104 +15110 +337 +616 +1716 +2314 +1920 +349 +15111 +9 +6950 +15112 +3546 +809 +22 +15113 +32 +15114 +15115 +15116 +15117 +98 +15118 +15119 +15120 +504 +15121 +15122 +15123 +14846 +15124 +14485 +736 +14610 +3546 +155 +155 +15125 +764 +15126 +43 +14 +15127 +597 +15128 +740 +15129 +15130 +14477 +1051 +15131 +5582 +705 +15 +15132 +57 +791 +10 +48 +213 +1051 +15133 +11321 +3470 +590 +2243 +15134 +1768 +11593 +8297 +8762 +14819 +15135 +349 +915 +15136 +1465 +15137 +15138 +176 +1377 +15139 +272 +3546 +590 +15140 +57 +3421 +15141 +15142 +6263 +48 +15143 +15144 +845 +15145 +48 +15146 +48 +15147 +14448 +15148 +2 +713 +6305 +9664 +15149 +590 +48 +4760 +15150 +15151 +745 +3626 +48 +12987 +590 +15152 +15153 +286 +48 +590 +57 +15154 +15155 +14 +665 +15156 +43 +2537 +3421 +284 +4518 +15157 +1870 +590 +15158 +764 +15159 +15160 +15161 +1604 +15162 +15163 +9766 +15164 +1208 +590 +20 +284 +2026 +14477 +286 +48 +12987 +43 +66 +15165 +14 +1617 +155 +2 +20 +647 +43 +15166 +15167 +411 +3546 +4116 +15168 +15169 +231 +48 +14571 +77 +48 +647 +15170 +12005 +15171 +1559 +19 +720 +15172 +19 +15173 +1578 +2042 +43 +590 +15174 +15175 +43 +1604 +707 +15176 +491 +14 +3 +15177 +15178 +15179 +20 +35 +790 +201 +14668 +464 +2728 +14185 +20 +15180 +1013 +6504 +15181 +647 +104 +4028 +2 +2 +1437 +14 +15182 +349 +48 +15183 +20 +15184 +178 +15185 +15186 +213 +12013 +5627 +57 +2882 +196 +6011 +222 +19 +15187 +15188 +9617 +15189 +5271 +590 +2064 +15190 +2260 +15191 +43 +155 +15192 +48 +493 +13387 +15193 +1712 +43 +15194 +14343 +43 +15195 +3594 +155 +48 +43 +15196 +2790 +15197 +57 +15198 +15199 +15200 +19 +15201 +15202 +15203 +14 +15204 +43 +15205 +15206 +259 +15207 +80 +98 +411 +15208 +15 +43 +705 +415 +22 +14509 +15209 +14 +15210 +2 +11754 +15211 +5780 +30 +48 +2975 +43 +1961 +861 +11754 +15212 +15213 +48 +2 +1578 +349 +823 +873 +19 +15214 +155 +141 +15215 +48 +43 +349 +15063 +19 +15216 +48 +1716 +2561 +15217 +15218 +1262 +741 +14 +15219 +15220 +1465 +8338 +245 +8230 +8392 +15221 +14 +15222 +11537 +66 +3317 +2239 +1765 +11482 +15223 +15224 +10659 +15225 +286 +15226 +15227 +15228 +43 +32 +14 +1091 +272 +15229 +43 +14219 +209 +43 +15230 +57 +48 +14603 +35 +15231 +15232 +541 +196 +1696 +15018 +48 +141 +286 +272 +155 +15233 +15234 +15235 +5614 +15236 +43 +32 +15237 +286 +5344 +201 +43 +15238 +369 +15239 +15240 +112 +15241 +15242 +15243 +15244 +15 +5271 +15245 +1696 +15246 +5627 +15247 +43 +15248 +3080 +274 +15249 +1870 +15250 +3553 +48 +720 +365 +15251 +155 +15252 +15253 +43 +10946 +3470 +15254 +15255 +48 +14957 +493 +1280 +15256 +9 +554 +7855 +48 +15257 +15258 +2 +15259 +169 +15260 +15261 +15262 +14 +15263 +397 +32 +15264 +15265 +13929 +57 +590 +15266 +1425 +15267 +43 +15268 +554 +15269 +590 +15270 +15271 +349 +43 +736 +155 +10 +9543 +15272 +1508 +15273 +590 +958 +15274 +15275 +3684 +15276 +741 +2790 +7855 +590 +3546 +43 +141 +342 +15277 +15278 +15279 +1508 +15280 +1612 +15 +48 +43 +3 +15281 +15282 +19 +15283 +15 +1013 +19 +15284 +14 +2064 +648 +43 +14603 +1942 +3732 +14 +25 +15285 +15286 +15287 +8357 +317 +1817 +736 +694 +15 +15288 +15289 +8297 +14770 +15290 +10574 +32 +15291 +722 +43 +5614 +15292 +6950 +590 +3546 +48 +305 +1013 +1011 +15293 +9 +60 +43 +15294 +15295 +15 +48 +9460 +15296 +9454 +3252 +14 +2446 +7855 +1612 +8188 +15297 +286 +764 +14 +57 +8188 +478 +3330 +823 +15298 +14888 +7977 +15299 +15300 +15301 +14604 +15302 +43 +15303 +3480 +48 +2804 +48 +15304 +13364 +43 +736 +19 +3915 +2042 +15305 +10933 +13961 +15306 +57 +15307 +484 +590 +286 +4028 +15308 +1870 +11428 +15309 +15220 +791 +2135 +12987 +48 +19 +43 +15310 +7356 +15311 +15312 +15313 +48 +15314 +29 +15315 +15316 +10 +590 +1091 +1027 +15317 +590 +12819 +15318 +15319 +15320 +4411 +15321 +12987 +9739 +8103 +19 +104 +554 +140 +590 +590 +15322 +1214 +15323 +720 +15324 +286 +590 +15325 +3546 +764 +15326 +15327 +5780 +19 +8566 +286 +741 +4406 +32 +1559 +48 +22 +14 +15328 +57 +210 +14 +15329 +590 +13248 +80 +647 +9472 +5683 +15330 +2410 +1051 +493 +104 +15331 +15332 +665 +155 +43 +36 +43 +15333 +1021 +15334 +43 +3546 +15335 +1655 +9 +89 +15336 +13913 +15337 +15338 +10 +590 +5780 +665 +11482 +48 +43 +590 +6624 +1765 +43 +14 +342 +14573 +1465 +15 +57 +14 +15339 +15340 +15341 +349 +15342 +11762 +15343 +286 +15344 +736 +2919 +20 +15345 +15346 +15347 +15348 +2804 +6915 +5764 +15349 +15350 +15351 +590 +32 +43 +15352 +15353 +43 +4088 +416 +1013 +15354 +590 +209 +2 +2499 +2430 +15355 +590 +528 +15 +15356 +48 +14957 +12987 +2804 +15357 +15358 +5780 +15359 +15360 +1234 +138 +15361 +15362 +495 +15363 +15364 +48 +2832 +15365 +15366 +3544 +15367 +14 +20 +3669 +48 +12987 +15368 +12402 +736 +2 +14001 +1116 +8297 +155 +887 +741 +9245 +4979 +104 +4278 +19 +1543 +112 +5561 +349 +9160 +272 +15369 +2 +15370 +10 +5415 +43 +19 +323 +4487 +8320 +15371 +12987 +48 +2865 +548 +15372 +15373 +138 +43 +15374 +590 +19 +554 +446 +155 +14 +14204 +1961 +2058 +15375 +15376 +1012 +14825 +43 +137 +19 +43 +24 +57 +15377 +43 +15378 +1648 +43 +9913 +15220 +12479 +15379 +6439 +301 +15380 +15381 +19 +286 +35 +15382 +9163 +6480 +15383 +5780 +15384 +15385 +1157 +286 +32 +5253 +4028 +2577 +9543 +3291 +373 +402 +15386 +736 +15387 +15388 +19 +15389 +278 +10356 +43 +1513 +15390 +1529 +15391 +14477 +3251 +15392 +48 +15393 +15394 +8566 +15395 +1991 +15396 +823 +15397 +48 +15398 +48 +2561 +15399 +19 +25 +164 +48 +48 +15400 +15401 +14 +14001 +112 +15402 +15403 +249 +15404 +1612 +2015 +4028 +43 +19 +43 +14 +57 +192 +373 +590 +15405 +57 +590 +15406 +3 +15407 +1326 +3559 +1376 +11822 +15408 +15409 +15410 +2550 +6671 +1011 +1091 +3105 +15411 +15412 +1153 +665 +15413 +15414 +19 +15415 +10230 +823 +15416 +15417 +892 +43 +15418 +14363 +15419 +15420 +15421 +15422 +3489 +48 +15423 +349 +1013 +2202 +7855 +7032 +15424 +12330 +15425 +12402 +48 +43 +15426 +1415 +1048 +19 +358 +57 +15427 +155 +2 +2314 +14477 +3546 +590 +1021 +104 +15428 +648 +764 +7215 +590 +15429 +2 +43 +4752 +354 +155 +19 +43 +43 +7154 +15430 +16 +764 +15431 +2769 +15432 +770 +13150 +48 +2 +590 +15433 +1606 +5963 +6874 +1870 +15434 +14 +80 +14 +15435 +138 +15436 +15437 +2476 +43 +590 +9 +15438 +15439 +736 +1870 +2 +15440 +1503 +15441 +48 +14 +48 +48 +15442 +12987 +3061 +2314 +3 +3417 +19 +1513 +1051 +15443 +590 +140 +6928 +1458 +554 +15444 +5204 +1091 +48 +15445 +14066 +590 +152 +15446 +493 +15447 +15448 +736 +6275 +14 +15449 +15450 +1310 +15451 +14477 +15452 +2764 +15453 +352 +5780 +8967 +1310 +15454 +15455 +872 +15456 +14604 +13045 +15457 +6965 +15458 +4821 +14816 +1013 +6776 +43 +43 +13566 +10 +4396 +48 +1716 +15459 +19 +201 +48 +15460 +15461 +10791 +19 +3842 +8205 +57 +15462 +15463 +5327 +377 +188 +15464 +15465 +15466 +48 +4897 +15467 +15468 +15469 +1364 +15470 +15471 +2056 +2029 +286 +6950 +15472 +15473 +2029 +48 +1425 +43 +43 +13424 +286 +32 +57 +590 +13904 +15474 +15475 +1013 +590 +10123 +8255 +9598 +12832 +873 +8244 +43 +5908 +15476 +736 +272 +9910 +15477 +237 +7855 +20 +15 +2197 +15478 +349 +1637 +8428 +6400 +43 +15479 +10306 +15480 +337 +1655 +14473 +248 +378 +14001 +104 +14 +237 +3066 +48 +1051 +201 +19 +15481 +48 +15482 +10 +15 +15483 +349 +590 +887 +2064 +98 +99 +14604 +15484 +15485 +15486 +15487 +8891 +15488 +337 +2769 +1232 +3 +15489 +15490 +43 +15491 +4056 +286 +286 +286 +15492 +286 +349 +379 +6145 +142 +514 +15493 +48 +104 +14477 +764 +14 +15494 +1021 +590 +13208 +10246 +15495 +15496 +14957 +14327 +2213 +492 +209 +15497 +48 +5833 +15498 +19 +15499 +43 +248 +14477 +15500 +43 +15501 +43 +15502 +15503 +1605 +741 +11762 +12987 +15504 +14477 +1612 +1566 +590 +2 +12936 +80 +15505 +1716 +15506 +15507 +137 +15508 +272 +15509 +686 +15510 +43 +286 +14647 +19 +15511 +741 +48 +15512 +15513 +3546 +14 +6817 +3906 +6054 +1765 +3119 +15514 +43 +15515 +15217 +29 +15516 +736 +3491 +12987 +1011 +3546 +10673 +43 +15517 +10 +736 +112 +15518 +8566 +14 +15519 +15520 +1889 +15521 +2457 +554 +201 +736 +43 +741 +1047 +1768 +15522 +66 +15523 +303 +43 +15524 +15525 +112 +286 +1612 +887 +15526 +15527 +15528 +669 +892 +48 +1912 +590 +15529 +66 +15530 +15531 +15532 +14 +2 +19 +188 +15533 +9 +15534 +15535 +104 +15536 +10723 +5780 +15537 +15538 +590 +1229 +43 +32 +48 +48 +213 +15539 +3 +5083 +590 +736 +15540 +323 +43 +15 +590 +15541 +736 +8269 +66 +15542 +2 +43 +12094 +15543 +15544 +15545 +8351 +872 +15546 +185 +15547 +15548 +4218 +15549 +4907 +15550 +554 +14 +590 +15551 +1011 +861 +5197 +14 +4752 +15552 +15553 +15554 +15555 +11369 +5496 +15556 +3034 +337 +528 +15557 +345 +272 +15558 +14 +155 +15559 +4747 +15560 +112 +14 +57 +13364 +590 +48 +357 +8566 +590 +14604 +2356 +1710 +15406 +15561 +4684 +1696 +1232 +15562 +15563 +15564 +11762 +2 +590 +15565 +14 +590 +14 +12987 +19 +14 +13781 +15566 +48 +112 +15567 +48 +736 +15568 +15569 +15570 +15571 +1465 +15572 +15573 +1508 +15574 +590 +14 +15575 +621 +14477 +248 +566 +15 +4414 +1243 +8053 +2260 +1992 +15576 +43 +15577 +48 +48 +736 +278 +14603 +647 +5162 +2356 +15578 +15579 +43 +2 +1154 +15580 +15581 +323 +98 +15582 +208 +15583 +11762 +7154 +15584 +1011 +48 +15585 +15586 +43 +32 +15384 +1423 +15587 +2463 +284 +1013 +15588 +13150 +15589 +8896 +736 +741 +2769 +15590 +10 +15591 +48 +440 +15592 +2281 +14 +14 +48 +48 +15593 +48 +2006 +15594 +14576 +286 +590 +590 +5304 +590 +15595 +10147 +2356 +15596 +15597 +46 +15598 +15599 +15600 +15601 +11176 +10 +1181 +15602 +5074 +590 +15603 +15604 +5089 +378 +2764 +13566 +15605 +15606 +14 +43 +14 +10 +6499 +14239 +46 +15607 +4963 +19 +647 +3543 +2 +15608 +14 +36 +2790 +15609 +3546 +13802 +15610 +3546 +15611 +48 +33 +15612 +19 +15613 +533 +5803 +15614 +48 +15615 +15616 +8460 +464 +13913 +43 +15617 +8297 +15618 +677 +14363 +15619 +155 +43 +448 +99 +1612 +14947 +2064 +12267 +15620 +176 +13361 +15621 +14816 +15622 +3 +15623 +15624 +15625 +43 +14 +3251 +15626 +15627 +15628 +15629 +15630 +43 +15631 +845 +1217 +15632 +43 +43 +15633 +1885 +15634 +15635 +590 +15636 +29 +43 +15637 +15638 +15639 +590 +7544 +15640 +43 +43 +43 +188 +741 +32 +3546 +2318 +43 +15641 +4302 +43 +699 +57 +10993 +6513 +590 +14416 +43 +3381 +4463 +14 +15642 +15643 +349 +15644 +514 +2330 +15645 +3598 +15646 +43 +15647 +15648 +15649 +14 +272 +10318 +15446 +379 +112 +15650 +104 +15651 +721 +8249 +2561 +590 +14 +3546 +48 +3546 +15652 +43 +15653 +15654 +13038 +1612 +590 +15655 +14896 +112 +554 +10016 +590 +20 +1049 +15656 +32 +12005 +299 +15657 +48 +155 +15658 +15659 +15660 +15661 +43 +11085 +9560 +11754 +15662 +3406 +15663 +464 +15664 +14 +764 +57 +15665 +48 +15666 +15667 +14185 +15668 +2561 +15669 +14 +590 +590 +8351 +15670 +48 +3546 +43 +43 +15671 +8789 +48 +201 +8916 +57 +188 +764 +15672 +48 +741 +2744 +15673 +15674 +1021 +152 +14434 +11754 +15675 +15676 +15677 +48 +11822 +526 +43 +15 +15678 +15679 +13760 +3546 +305 +3546 +9 +14477 +15680 +15681 +764 +57 +5420 +48 +590 +349 +196 +491 +43 +15682 +2409 +43 +15683 +43 +4341 +13361 +15684 +13807 +19 +971 +15445 +15685 +15306 +4341 +14477 +48 +15686 +43 +3546 +7276 +15687 +14 +15688 +15689 +358 +416 +155 +15690 +104 +43 +15691 +1961 +590 +15692 +15693 +15694 +13228 +249 +36 +573 +4376 +48 +43 +493 +48 +15695 +43 +1571 +352 +15696 +464 +6341 +19 +3 +1688 +736 +14001 +15697 +228 +15698 +5298 +15699 +15700 +1817 +15701 +2569 +15702 +11966 +15703 +722 +48 +2 +15704 +13150 +38 +14 +411 +15705 +10230 +15706 +286 +14660 +15707 +15708 +14604 +4411 +590 +15709 +15710 +8721 +15711 +845 +3553 +855 +415 +12987 +1870 +14 +14 +15712 +15713 +9 +15714 +15715 +10946 +43 +43 +590 +15716 +15717 +15718 +272 +590 +2804 +528 +14 +741 +43 +590 +48 +123 +12153 +43 +43 +15719 +15720 +5659 +3546 +15721 +286 +15722 +15723 +48 +14884 +15724 +13108 +3959 +15725 +15726 +14 +57 +1696 +1732 +4230 +43 +176 +15727 +15728 +15729 +14 +48 +15730 +822 +43 +15731 +15732 +11321 +931 +15733 +2 +1376 +10 +590 +15734 +554 +43 +15735 +349 +15736 +48 +15737 +15738 +590 +2 +5780 +155 +15739 +1060 +14604 +1542 +196 +14 +12077 +15740 +10 +2446 +741 +15741 +15742 +15743 +14477 +6400 +14604 +590 +3553 +14363 +32 +2859 +1112 +9994 +590 +349 +14363 +1444 +12987 +15744 +15745 +5438 +5305 +43 +590 +43 +2567 +19 +646 +15746 +15747 +590 +1514 +15748 +14 +19 +15749 +15750 +590 +15751 +15752 +19 +14 +4907 +249 +15753 +15754 +15755 +12202 +15756 +3849 +8867 +741 +764 +3842 +15757 +15622 +15758 +2 +1245 +15759 +3732 +741 +43 +57 +43 +15760 +2463 +15761 +590 +32 +14 +11483 +15762 +3291 +13271 +14 +1051 +15763 +15764 +3546 +15765 +2958 +590 +43 +7780 +12808 +14 +590 +32 +15766 +57 +3553 +590 +10 +7045 +43 +112 +259 +48 +43 +15767 +270 +15768 +3546 +43 +10 +15769 +43 +15770 +15771 +15772 +15773 +15774 +155 +15775 +48 +19 +15776 +15777 +43 +358 +19 +15778 +15779 +1637 +286 +1470 +590 +647 +286 +3353 +2700 +703 +358 +3546 +9 +15780 +140 +73 +14 +15781 +15782 +5627 +7291 +13528 +15783 +43 +5162 +14007 +14 +43 +15784 +43 +32 +43 +15785 +357 +48 +15786 +720 +7276 +15787 +303 +4790 +15788 +13208 +57 +2314 +13282 +15789 +15790 +2006 +14 +741 +11754 +5614 +19 +15791 +48 +15792 +15793 +5293 +14624 +736 +29 +3119 +20 +15794 +7137 +2 +213 +337 +590 +15795 +2009 +213 +3546 +15796 +4963 +249 +411 +5582 +284 +286 +5483 +15797 +15798 +1208 +1726 +12560 +14 +15799 +1066 +15800 +15801 +2064 +15802 +12 +7034 +15803 +13282 +5780 +7226 +15804 +15805 +1481 +2679 +1232 +15806 +5780 +15807 +15808 +4387 +15809 +1605 +2694 +15810 +14985 +15811 +983 +43 +8351 +15812 +2040 +15813 +15814 +10 +15815 +15816 +14532 +12013 +15817 +15818 +13508 +4808 +741 +14532 +15819 +43 +15820 +43 +14 +5780 +48 +15821 +15822 +1924 +14957 +15823 +15824 +590 +764 +13508 +48 +1765 +20 +43 +15825 +155 +155 +210 +741 +282 +43 +1291 +15156 +188 +15826 +379 +15827 +554 +15828 +19 +590 +15351 +15829 +349 +707 +48 +1751 +48 +15830 +29 +48 +3129 +554 +349 +13904 +15756 +43 +12807 +15831 +17 +57 +43 +15832 +292 +4907 +15833 +272 +4997 +15834 +15835 +15836 +3546 +1157 +15837 +48 +141 +15838 +15839 +337 +13913 +2804 +590 +15840 +554 +1251 +10117 +15841 +1524 +57 +14 +48 +48 +43 +9320 +48 +13282 +43 +15842 +15843 +15844 +764 +43 +358 +590 +1956 +15845 +15846 +43 +15847 +15848 +43 +14276 +48 +15849 +15850 +647 +12307 +509 +2600 +971 +15851 +1051 +15852 +9 +15756 +15853 +15854 +15855 +15856 +3 +1095 +32 +15857 +15858 +1300 +15859 +1232 +15860 +3484 +15861 +15862 +15863 +48 +590 +7014 +5088 +15864 +13492 +15865 +272 +20 +2197 +15866 +104 +43 +12621 +15867 +6518 +15868 +48 +15869 +15870 +8297 +349 +15871 +137 +155 +9418 +927 +15872 +6877 +48 +8701 +43 +15873 +3615 +286 +43 +14 +15874 +15875 +6741 +10 +1401 +15876 +43 +12987 +15877 +15878 +590 +14 +8566 +887 +12267 +349 +736 +15879 +15880 +43 +1234 +15881 +2064 +19 +15882 +15883 +15884 +15885 +3003 +20 +3546 +590 +11321 +11762 +15886 +13162 +741 +15887 +15888 +15889 +178 +43 +1224 +15890 +397 +1169 +15891 +590 +15892 +15699 +349 +1903 +99 +15893 +13361 +707 +43 +7601 +9 +1559 +15894 +43 +720 +9 +15895 +15896 +15897 +15898 +13150 +11754 +15899 +15900 +19 +15901 +1232 +32 +99 +1901 +1883 +10030 +15902 +19 +15903 +286 +14 +15904 +892 +7908 +1316 +13957 +15905 +176 +15906 +741 +15907 +15908 +590 +1465 +272 +43 +1912 +15909 +48 +15910 +48 +15911 +15912 +1917 +15913 +14 +2 +2 +15914 +15915 +15916 +11471 +590 +201 +112 +43 +5045 +60 +15917 +15918 +15428 +590 +15919 +7183 +57 +564 +15920 +29 +22 +22 +152 +14897 +2 +48 +1655 +80 +12534 +15921 +43 +15922 +720 +15923 +201 +15924 +15925 +5780 +15926 +14343 +1232 +15927 +19 +15928 +15929 +43 +32 +43 +48 +2459 +1385 +5344 +19 +209 +15930 +14 +286 +3546 +48 +43 +1465 +349 +4 +345 +155 +2476 +12120 +533 +2392 +15931 +13655 +15932 +43 +15933 +57 +1234 +19 +745 +1612 +2625 +14477 +12711 +43 +15934 +1961 +36 +2 +286 +15935 +14 +48 +317 +12772 +43 +590 +15936 +509 +493 +15937 +15938 +8733 +15939 +48 +2465 +4852 +590 +14 +590 +4230 +5827 +1169 +15940 +43 +3546 +15941 +15942 +15943 +15944 +3844 +1115 +15945 +1824 +590 +15946 +9 +15947 +14482 +590 +15948 +323 +43 +15949 +15950 +15951 +15952 +7236 +301 +5780 +15953 +15954 +15955 +15956 +15957 +14 +15958 +66 +1710 +590 +15959 +188 +15960 +1364 +415 +15327 +15961 +155 +15962 +15963 +15964 +48 +1234 +43 +15965 +20 +648 +15966 +5197 +3546 +48 +15967 +11483 +36 +15968 +15969 +1991 +15970 +155 +370 +48 +15971 +15972 +12329 +15973 +14 +1295 +2260 +286 +5780 +15974 +15975 +15976 +2029 +15977 +13361 +89 +15978 +15 +741 +7886 +1920 +590 +12987 +155 +141 +15979 +15980 +15981 +1223 +104 +43 +590 +15 +15982 +4179 +14553 +22 +15983 +14603 +15984 +5204 +19 +15985 +3546 +554 +9 +741 +15986 +142 +48 +15987 +9 +15988 +15989 +1154 +188 +15990 +736 +590 +590 +2 +48 +15991 +15992 +15993 +43 +43 +590 +536 +272 +6011 +15994 +43 +590 +1013 +152 +209 +6764 +48 +2 +272 +590 +9713 +8907 +15995 +1047 +15996 +5780 +478 +14185 +15997 +5344 +15998 +11321 +15999 +9 +6741 +12005 +16000 +1089 +16001 +16002 +16003 +764 +43 +8787 +14477 +16004 +16005 +10 +16006 +6764 +272 +16007 +14369 +112 +14 +20 +138 +48 +3417 +282 +2600 +4425 +286 +10 +590 +48 +3546 +2 +272 +720 +453 +14604 +707 +14477 +43 +11483 +1870 +286 +16008 +2762 +16009 +16010 +1578 +16011 +1295 +15699 +16012 +11762 +3546 +19 +16013 +16014 +3546 +1232 +13929 +16015 +15 +16016 +528 +1901 +349 +4928 +322 +43 +16017 +3546 +16018 +43 +43 +647 +16019 +16020 +20 +9 +16021 +16022 +11593 +2733 +16023 +16024 +1547 +16025 +16026 +112 +1449 +741 +16027 +1889 +720 +57 +43 +12397 +9 +16028 +16029 +11882 +736 +43 +20 +14 +19 +4524 +16030 +3610 +48 +5780 +43 +1371 +10 +16031 +1051 +15989 +16032 +188 +2577 +16033 +16034 +590 +15449 +6668 +19 +16035 +3 +16036 +48 +32 +213 +2694 +16037 +11762 +14 +7835 +16038 +14690 +16039 +13655 +12987 +16040 +16041 +16042 +152 +57 +536 +349 +1166 +3546 +14 +16043 +43 +14477 +14 +349 +19 +7357 +43 +43 +13282 +48 +16044 +16045 +8566 +1529 +35 +16046 +2117 +16047 +915 +16048 +590 +14843 +16049 +89 +2577 +16050 +2124 +16051 +19 +286 +43 +317 +751 +495 +707 +4961 +43 +57 +5208 +9965 +845 +16052 +48 +3976 +13973 +14 +43 +5780 +3417 +337 +10 +43 +2459 +16053 +2 +14884 +6287 +514 +1569 +4820 +597 +16054 +2286 +5119 +6950 +14 +272 +590 +16055 +3546 +16056 +3546 +1232 +5243 +2415 +399 +15778 +16057 +303 +16058 +2514 +13108 +274 +16059 +16060 +286 +43 +155 +16061 +5080 +16062 +48 +43 +16063 +3546 +11256 +16064 +16065 +12620 +43 +14 +16066 +16067 +8249 +2 +15 +2040 +5418 +16068 +16069 +305 +16070 +48 +4765 +16071 +185 +14 +583 +16072 +35 +16073 +155 +15 +16074 +16075 +16076 +8295 +16077 +509 +5351 +272 +16078 +272 +32 +590 +12987 +16079 +8351 +19 +495 +590 +11301 +14 +152 +140 +3546 +14 +6950 +397 +4280 +337 +286 +16064 +16080 +43 +2 +16081 +48 +43 +342 +57 +16082 +16083 +590 +19 +152 +3546 +16084 +694 +104 +3317 +12778 +5088 +16085 +16086 +16087 +43 +137 +16088 +16089 +8249 +775 +201 +9 +1082 +32 +3543 +16090 +14341 +16091 +16092 +57 +16093 +12560 +1012 +16094 +16095 +16096 +57 +210 +43 +533 +590 +16097 +43 +415 +29 +16098 +337 +3546 +14 +590 +14901 +43 +16099 +104 +5820 +16100 +239 +2035 +665 +16101 +16102 +1915 +14369 +590 +12987 +14363 +16103 +43 +16104 +209 +10003 +16105 +590 +1508 +590 +9 +16106 +16107 +3546 +3546 +586 +43 +48 +1232 +4982 +48 +16108 +16109 +152 +16110 +10004 +16102 +43 +16111 +10031 +16112 +48 +2042 +16113 +48 +16114 +1013 +349 +9 +16115 +16054 +16116 +6766 +43 +10 +16117 +16118 +3546 +872 +16119 +248 +1765 +19 +12996 +16120 +5780 +16121 +14 +16122 +2769 +16123 +16124 +590 +9583 +6766 +6214 +2316 +464 +15 +16125 +13282 +16126 +16127 +2764 +9 +323 +11211 +590 +3128 +647 +2550 +1425 +48 +16128 +22 +16129 +32 +16130 +16131 +349 +12277 +2356 +736 +15797 +590 +14 +5837 +4803 +16132 +14 +4982 +14 +16133 +16134 +8943 +16135 +6950 +16136 +349 +3546 +1021 +14 +20 +16137 +761 +16138 +16139 +16140 +1021 +764 +590 +43 +590 +16141 +16142 +213 +3368 +345 +248 +48 +647 +590 +14477 +16143 +16144 +16145 +16146 +13566 +16147 +590 +16148 +3638 +16149 +16150 +43 +14604 +1112 +736 +1765 +2 +14483 +12402 +16151 +16152 +13959 +15756 +57 +1107 +19 +12220 +20 +16153 +16154 +1765 +16155 +9 +583 +16156 +3 +16157 +43 +32 +16158 +16159 +872 +8351 +43 +16160 +2694 +16161 +647 +8758 +16162 +1559 +415 +14843 +11754 +16163 +686 +16164 +16165 +16166 +16167 +16168 +20 +43 +2 +12987 +16169 +1026 +43 +16170 +16171 +10 +16172 +43 +16173 +493 +142 +43 +10163 +16174 +349 +43 +43 +823 +16175 +13566 +13225 +15592 +43 +342 +12987 +16176 +16177 +14 +16178 +98 +16179 +10583 +16180 +13223 +32 +16181 +14604 +16182 +16183 +89 +1710 +9 +1214 +14 +4855 +16184 +222 +3139 +16185 +115 +48 +3546 +16186 +6950 +648 +48 +14 +38 +671 +16187 +1217 +16188 +349 +16189 +303 +16190 +16191 +16192 +16193 +10 +16194 +14604 +373 +16195 +1300 +286 +43 +20 +43 +741 +48 +16196 +3546 +640 +272 +12987 +828 +43 +16197 +16198 +3 +741 +5751 +2038 +48 +16199 +29 +16200 +14 +48 +134 +43 +16201 +2314 +155 +764 +16202 +3546 +16203 +823 +9514 +43 +16204 +647 +32 +2493 +48 +823 +16205 +14 +43 +9 +10 +590 +16206 +188 +6214 +13988 +286 +10979 +3598 +19 +43 +274 +417 +333 +12987 +6950 +378 +1217 +16207 +48 +16208 +590 +19 +10 +16209 +112 +3546 +14 +43 +16210 +43 +1310 +1295 +8864 +1224 +616 +43 +16211 +43 +6209 +4927 +16212 +736 +14532 +48 +3075 +201 +2 +8724 +5647 +286 +286 +590 +14 +16213 +43 +6744 +57 +16214 +3906 +16215 +9 +20 +43 +554 +379 +16216 +16217 +14 +1716 +16218 +15953 +16219 +16220 +14 +16221 +5220 +19 +1172 +15914 +16222 +48 +14 +13756 +16223 +13282 +16224 +43 +616 +554 +10 +16225 +6075 +57 +379 +16226 +16227 +57 +41 +14827 +16228 +16229 +1245 +13566 +16230 +16231 +2260 +1287 +9 +286 +43 +5780 +1013 +15 +590 +861 +369 +1012 +140 +43 +1314 +3 +590 +345 +16232 +48 +16233 +764 +16234 +1356 +915 +43 +98 +16235 +6068 +16236 +16237 +16238 +1013 +736 +554 +16239 +379 +48 +16240 +16241 +16242 +16243 +590 +80 +5299 +10 +349 +13321 +12807 +16244 +16245 +4028 +43 +1112 +791 +14 +16246 +10 +647 +16247 +16248 +16249 +16250 +16251 +3546 +43 +3546 +349 +16252 +16253 +16254 +3546 +29 +16255 +16256 +868 +7855 +14477 +16257 +1018 +16258 +16259 +16260 +16261 +16262 +16263 +2 +43 +32 +53 +736 +1217 +43 +3546 +590 +5332 +16264 +272 +13576 +16265 +43 +12457 +9 +14666 +42 +10 +15914 +242 +222 +668 +2039 +16266 +2314 +16267 +14693 +4824 +15975 +43 +16268 +14 +11522 +9583 +34 +16269 +14 +1181 +137 +112 +16270 +8593 +16271 +554 +16272 +16273 +16274 +43 +16275 +16276 +590 +354 +10 +16277 +14594 +4747 +8566 +16278 +16279 +43 +14 +2882 +3546 +8188 +16280 +178 +16281 +6736 +282 +16282 +590 +548 +9595 +43 +38 +590 +48 +48 +3369 +32 +1696 +16283 +16284 +5561 +16285 +16286 +15720 +3546 +115 +14 +16287 +53 +39 +5731 +16288 +16289 +9103 +16290 +7137 +14477 +616 +590 +43 +16291 +152 +14363 +16292 +3546 +5340 +15 +8566 +16293 +648 +16294 +16295 +48 +48 +15718 +8255 +115 +286 +573 +48 +16296 +16297 +16298 +43 +16299 +1100 +16300 +16301 +379 +398 +665 +701 +48 +13790 +16302 +12987 +14 +16303 +272 +16304 +16305 +2694 +16306 +16307 +528 +3546 +15504 +536 +222 +1172 +16308 +7379 +16309 +16310 +43 +2281 +16311 +1912 +11754 +16312 +3546 +16313 +210 +694 +16314 +16315 +349 +10727 +19 +989 +43 +1514 +16316 +210 +16317 +43 +16318 +16319 +16320 +3546 +16321 +16322 +379 +11754 +15 +16323 +6095 +590 +16324 +2957 +4752 +14420 +6950 +43 +16325 +358 +14477 +11408 +57 +590 +14477 +12560 +1566 +741 +3546 +16326 +7137 +16327 +16328 +849 +590 +1578 +2975 +15756 +16329 +16330 +16331 +3119 +416 +272 +8566 +14 +1107 +35 +16332 +48 +16333 +12987 +14 +16334 +43 +16335 +16336 +389 +1743 +4028 +57 +3066 +19 +16337 +590 +36 +15718 +1563 +16338 +43 +590 +43 +11762 +1300 +16339 +412 +5410 +48 +4293 +3 +16340 +16341 +112 +14477 +16342 +32 +6877 +14 +11754 +1232 +16343 +16344 +3119 +2811 +16345 +48 +590 +16346 +3546 +16347 +5344 +35 +3452 +201 +16348 +16349 +1048 +301 +15718 +16350 +140 +188 +16351 +16352 +3546 +13492 +210 +15 +2053 +1232 +377 +53 +1684 +16353 +16354 +1991 +3849 +155 +1961 +16355 +32 +48 +8724 +16060 +16356 +48 +3 +32 +16357 +59 +8297 +16230 +1991 +3355 +3275 +10993 +16358 +1149 +1559 +15718 +188 +10356 +20 +222 +16359 +16360 +14477 +16361 +43 +16362 +48 +4963 +22 +19 +16363 +13566 +9 +2787 +16364 +14477 +43 +14871 +3546 +250 +1817 +349 +170 +16365 +1082 +736 +16366 +16367 +14 +13296 +16368 +16369 +272 +16370 +16371 +48 +1049 +16372 +823 +4 +14866 +590 +185 +8188 +1987 +15797 +14 +3182 +1217 +16373 +35 +736 +16374 +16090 +201 +14679 +2925 +16375 +13582 +3334 +43 +14 +48 +13365 +16376 +16377 +16378 +16379 +7855 +152 +14 +14886 +60 +16380 +1470 +16381 +15 +16382 +16383 +43 +338 +16384 +43 +16385 +741 +590 +590 +14 +16386 +43 +34 +3546 +7137 +16387 +43 +14 +16388 +2434 +1181 +196 +1382 +4387 +43 +11341 +6877 +4155 +16389 +16390 +1083 +12987 +14 +15 +22 +16391 +43 +53 +123 +43 +6950 +1531 +16392 +43 +12987 +15756 +16393 +16394 +9402 +590 +112 +286 +207 +99 +6341 +16395 +16396 +155 +43 +16397 +12798 +16398 +2243 +5780 +48 +43 +12166 +16399 +43 +19 +16400 +43 +317 +607 +4907 +16401 +16402 +3546 +15 +14477 +12987 +736 +14001 +14603 +43 +1853 +1442 +705 +16403 +16404 +122 +16405 +43 +14604 +16406 +3317 +736 +16407 +16408 +43 +4717 +16409 +16410 +16411 +14814 +43 +14 +10389 +16412 +1160 +1018 +284 +16413 +16414 +213 +1604 +12560 +10 +8279 +16415 +1559 +16416 +16417 +2859 +57 +188 +43 +1013 +16418 +15744 +16419 +16420 +16421 +38 +16422 +8171 +303 +989 +9 +16190 +3353 +3546 +3546 +4179 +16423 +16424 +242 +43 +16425 +16426 +9 +14477 +16427 +284 +16428 +272 +16429 +16430 +16431 +358 +16432 +16433 +284 +48 +43 +2 +741 +20 +16434 +16435 +971 +16436 +16437 +1051 +16438 +16439 +15810 +6877 +11966 +48 +16440 +29 +16441 +57 +16442 +43 +337 +284 +16443 +48 +16444 +11539 +43 +16445 +16446 +10230 +342 +48 +16447 +16448 +1244 +43 +14689 +48 +16348 +19 +337 +15 +48 +43 +48 +315 +5688 +48 +43 +1013 +933 +849 +7259 +48 +12987 +16449 +323 +20 +16450 +16451 +1800 +16452 +16453 +1961 +16454 +2 +2136 +16258 +16455 +14363 +43 +1203 +398 +209 +1232 +12005 +558 +286 +16456 +590 +2577 +590 +16457 +14604 +3546 +16458 +12987 +16459 +32 +43 +16437 +6950 +16460 +16461 +43 +736 +590 +286 +284 +720 +16462 +16205 +741 +16463 +14957 +19 +16464 +16465 +14 +7283 +16466 +16467 +57 +14663 +2958 +16468 +248 +16469 +3353 +9 +1542 +14 +349 +16470 +10 +16471 +564 +590 +43 +16472 +16473 +15718 +16474 +15406 +16475 +14 +16476 +16477 +48 +14 +8367 +272 +16478 +16479 +11808 +16480 +1232 +397 +16481 +43 +16482 +590 +249 +3492 +16483 +43 +112 +1011 +16484 +16485 +16486 +303 +16487 +590 +6950 +16488 +2 +590 +16489 +16490 +3 +16491 +16492 +16493 +16494 +3546 +16495 +590 +2734 +590 +43 +5780 +7137 +16496 +7855 +590 +225 +671 +16497 +57 +16498 +646 +16499 +43 +48 +1157 +16500 +590 +8988 +5780 +48 +48 +16440 +1765 +19 +16096 +3034 +8005 +16501 +3435 +16502 +38 +16503 +8744 +15718 +16504 +16505 +29 +509 +16506 +1232 +16507 +15718 +14001 +2260 +16508 +14 +16509 +349 +3546 +16510 +286 +16511 +57 +16512 +43 +16513 +16514 +5217 +373 +153 +16515 +16516 +14 +43 +16517 +16518 +720 +14001 +43 +16519 +16520 +14 +16521 +22 +137 +2253 +196 +2006 +16522 +15384 +16523 +590 +590 +16524 +590 +43 +16525 +16526 +284 +16527 +457 +484 +16437 +16528 +5627 +188 +112 +155 +16529 +15718 +6915 +14 +16530 +16531 +35 +16532 +60 +16533 +16534 +15718 +337 +16535 +2733 +971 +1220 +16536 +43 +16537 +213 +14 +7960 +15 +16538 +14957 +14603 +590 +16539 +16540 +16541 +14 +43 +16542 +284 +2260 +43 +745 +48 +16543 +188 +43 +16544 +43 +12185 +8566 +16545 +323 +43 +16546 +590 +35 +43 +9461 +14477 +2561 +16547 +16548 +32 +323 +8297 +16549 +3546 +3598 +43 +43 +6121 +2254 +322 +14 +16550 +16551 +736 +142 +9617 +10 +16437 +2577 +16552 +14 +2772 +1738 +15824 +16553 +2733 +248 +5780 +590 +14 +16554 +16555 +43 +16556 +16557 +16558 +1991 +32 +43 +16559 +1563 +303 +16560 +16561 +16562 +1229 +16563 +349 +16564 +14 +14 +12351 +9 +16565 +192 +16566 +1524 +16567 +210 +16568 +17 +11207 +16569 +16570 +16437 +137 +3546 +16571 +16572 +14 +16573 +647 +272 +248 +16574 +16575 +43 +823 +43 +16576 +16577 +248 +16578 +57 +16579 +43 +20 +590 +5438 +43 +3546 +6950 +16580 +43 +248 +43 +5780 +16581 +9705 +16582 +16583 +590 +210 +43 +152 +597 +15 +1787 +2921 +349 +16584 +15718 +647 +16585 +741 +16586 +48 +16587 +32 +16588 +16589 +14916 +1799 +7917 +43 +2243 +29 +2 +590 +8392 +32 +648 +1013 +16590 +1437 +14604 +16591 +16592 +2 +1465 +16593 +48 +872 +286 +736 +19 +12987 +14546 +48 +16594 +357 +16595 +43 +22 +16596 +12987 +12483 +43 +16597 +16598 +349 +590 +2561 +15718 +14215 +541 +9681 +3546 +554 +286 +3553 +1559 +3546 +16334 +92 +14 +19 +16599 +1912 +1415 +16600 +29 +16601 +16602 +16603 +16604 +43 +16605 +3546 +16606 +16607 +9560 +16608 +14 +3546 +286 +272 +16609 +16610 +16611 +12936 +14 +11754 +16612 +448 +14 +1082 +43 +19 +43 +43 +2 +1208 +16613 +305 +16614 +20 +43 +1232 +1013 +16615 +19 +16616 +35 +16617 +16618 +16437 +16619 +43 +736 +15718 +464 +317 +790 +1542 +16620 +14 +89 +286 +16621 +16491 +5561 +495 +16622 +19 +38 +14695 +2 +272 +741 +16623 +5780 +14693 +16624 +16625 +10230 +10961 +849 +12987 +16626 +16627 +16628 +15 +6121 +43 +14477 +16629 +13361 +14 +3 +3508 +5601 +16630 +188 +349 +790 +16631 +43 +16632 +43 +9 +80 +6595 +16633 +16634 +4113 +692 +16635 +16636 +16637 +16638 +16639 +590 +19 +15694 +16640 +16641 +16642 +16643 +38 +16644 +11754 +5803 +554 +43 +16645 +16646 +14001 +5780 +14816 +3546 +647 +12605 +711 +16647 +16648 +16649 +2804 +5601 +43 +43 +16650 +20 +14594 +13954 +2540 +16651 +1425 +6595 +3055 +16652 +16653 +5088 +48 +16654 +16655 +249 +16656 +48 +16657 +12402 +16658 +48 +14 +13902 +2 +416 +48 +16659 +14179 +736 +16660 +845 +152 +16661 +16662 +16663 +43 +3491 +16664 +770 +14420 +4278 +15718 +16665 +16666 +16667 +16668 +349 +16669 +3484 +6950 +155 +1013 +178 +25 +43 +16670 +11176 +686 +43 +14 +16671 +16672 +399 +16673 +16674 +16675 +1018 +16150 +16676 +12 +7553 +48 +2 +358 +2245 +4907 +16171 +16677 +819 +16678 +11247 +43 +915 +16679 +446 +16680 +671 +554 +11754 +16681 +16682 +14 +152 +15 +590 +590 +16683 +590 +1157 +770 +19 +16684 +1047 +48 +43 +16685 +4028 +1765 +16686 +8244 +16687 +11483 +16688 +141 +89 +16689 +12987 +16690 +16691 +10259 +12 +16692 +43 +16693 +751 +3310 +648 +16694 +32 +590 +1425 +1154 +16695 +155 +16696 +590 +43 +16697 +14759 +19 +2577 +15718 +16698 +10720 +3546 +16699 +1021 +43 +3546 +7123 +11321 +59 +736 +16437 +43 +349 +2324 +16700 +13271 +554 +15718 +43 +16584 +9 +828 +16701 +76 +4790 +43 +16702 +11005 +1232 +16703 +13279 +48 +14 +16704 +12067 +32 +12434 +16705 +9849 +1364 +13803 +1364 +14546 +15718 +43 +16706 +16707 +5041 +1991 +16708 +1425 +14 +16709 +736 +15718 +16710 +15595 +590 +1012 +15472 +16711 +16712 +43 +16713 +39 +16714 +590 +1232 +32 +16715 +736 +231 +3408 +349 +9 +16716 +13150 +1295 +16717 +188 +48 +8046 +16718 +741 +16719 +253 +80 +14 +16720 +741 +3546 +8050 +16721 +43 +16722 +14603 +16723 +19 +1208 +16724 +16725 +16726 +16727 +16728 +16729 +12185 +57 +16730 +16731 +14001 +11762 +16732 +10 +16733 +16734 +16735 +16736 +16737 +48 +773 +16437 +16738 +16739 +16740 +48 +590 +19 +43 +14363 +38 +13484 +16741 +2012 +16742 +16634 +155 +665 +16743 +6877 +823 +14477 +14553 +9262 +2476 +590 +48 +16744 +554 +3 +19 +647 +554 +15054 +10737 +14 +16745 +2882 +43 +16746 +16747 +16748 +14 +14523 +48 +936 +272 +464 +415 +16749 +1013 +16750 +16751 +533 +16752 +209 +57 +43 +16753 +16754 +32 +2930 +16755 +8566 +25 +16756 +43 +286 +48 +2733 +48 +188 +16757 +14274 +16758 +16759 +7855 +13464 +16760 +6794 +6214 +590 +16761 +16762 +15718 +43 +1109 +210 +713 +2446 +112 +5780 +16763 +16764 +16765 +6341 +12402 +349 +2537 +43 +209 +16766 +3575 +11762 +16767 +3542 +15 +16768 +6939 +13754 +48 +43 +286 +16769 +647 +12987 +2537 +16770 +5969 +16413 +1232 +16437 +16771 +43 +349 +4717 +15718 +16772 +15718 +6741 +16773 +43 +16774 +590 +43 +43 +590 +16775 +590 +14 +1765 +16776 +16118 +16777 +14 +323 +14 +927 +2577 +464 +48 +10 +16778 +22 +8100 +57 +590 +43 +43 +14363 +16437 +16779 +16780 +15 +3546 +16781 +1051 +14 +16782 +2314 +48 +12402 +48 +1446 +736 +2314 +43 +16783 +1529 +554 +16784 +3546 +16785 +209 +590 +14 +43 +16786 +7923 +590 +16787 +43 +736 +16788 +16437 +16789 +16790 +1217 +3546 +16791 +16792 +3330 +19 +20 +669 +15384 +16793 +8685 +1961 +57 +15498 +16794 +1364 +16171 +15718 +16795 +349 +16035 +3491 +48 +16796 +16797 +16798 +16799 +19 +16800 +6950 +2015 +9 +16801 +16802 +3546 +590 +16803 +1082 +16804 +155 +15039 +16805 +14 +16806 +22 +2064 +15819 +48 +16807 +647 +16808 +16809 +3546 +590 +2253 +188 +849 +741 +358 +2769 +16810 +590 +16811 +16284 +112 +13179 +4118 +3481 +15718 +16812 +2136 +19 +15718 +741 +873 +16813 +48 +16814 +13666 +16815 +16816 +16817 +16818 +16819 +560 +5780 +872 +2012 +3768 +16820 +590 +16821 +12560 +13279 +16822 +1905 +15649 +48 +15 +9 +16823 +14 +14 +43 +11762 +305 +1181 +193 +16824 +16825 +43 +16826 +48 +16827 +34 +14363 +16828 +590 +7137 +15718 +16829 +89 +1524 +16830 +15718 +16831 +397 +16832 +286 +188 +2 +43 +16833 +16834 +595 +104 +16835 +1912 +849 +14007 +16836 +16837 +16838 +14477 +14 +14 +764 +13897 +8867 +43 +16839 +3546 +43 +5582 +14537 +590 +16840 +14 +16841 +2790 +48 +16842 +554 +16843 +16844 +1013 +16845 +3546 +590 +16846 +16847 +140 +16848 +16849 +16850 +8362 +16851 +15718 +5614 +823 +16852 +16853 +16468 +16854 +16855 +16856 +16857 +19 +16858 +188 +736 +11301 +16859 +3119 +48 +188 +112 +15718 +16437 +2195 +16860 +2804 +4388 +19 +16861 +43 +15718 +16437 +16862 +845 +10 +3768 +16863 +16864 +48 +67 +10079 +16865 +16866 +1765 +3546 +6736 +2042 +57 +491 +554 +9 +7137 +4606 +57 +16867 +16868 +590 +16869 +48 +19 +19 +16870 +16871 +16872 +48 +43 +16873 +76 +741 +32 +16874 +48 +16205 +13131 +36 +16875 +1082 +3546 +16876 +43 +2260 +43 +1513 +16877 +29 +16878 +14477 +1847 +1425 +770 +14477 +16879 +19 +736 +16880 +16881 +15 +43 +3105 +16882 +16883 +20 +16884 +16885 +286 +43 +16437 +16886 +48 +11762 +48 +15810 +43 +43 +357 +5318 +9 +5780 +741 +14477 +57 +650 +3543 +16887 +16888 +8758 +16889 +16890 +14 +43 +590 +16891 +16892 +48 +80 +379 +831 +9 +1542 +43 +16437 +48 +29 +15797 +7855 +8994 +3546 +7521 +179 +5990 +590 +15 +286 +11822 +2064 +16893 +3978 +2 +16894 +14477 +13484 +20 +1224 +16895 +5451 +14276 +2254 +16896 +48 +20 +342 +209 +5075 +16897 +349 +9 +14 +48 +43 +3546 +2121 +16898 +16899 +197 +647 +19 +16900 +15914 +16901 +1992 +16902 +43 +14 +6095 +3546 +3228 +16903 +16904 +566 +1316 +155 +16905 +11301 +16906 +16907 +43 +3546 +3546 +44 +2550 +5973 +1559 +2006 +1465 +43 +590 +590 +112 +16908 +16909 +16910 +16911 +1080 +16912 +1425 +43 +590 +16913 +1808 +2694 +16914 +12 +16915 +16916 +16917 +188 +43 +5190 +16656 +590 +10 +22 +1234 +155 +16918 +554 +741 +16919 +741 +20 +206 +43 +14185 +493 +16920 +14477 +16921 +14 +48 +16922 +5963 +29 +14420 +1120 +16923 +2404 +16924 +16925 +1458 +16926 +16927 +13760 +20 +16928 +6720 +16929 +6915 +590 +16930 +16931 +16932 +4684 +16933 +2117 +16934 +6741 +2764 +16437 +3546 +491 +2790 +35 +790 +16935 +1859 +354 +43 +14 +590 +12621 +48 +48 +286 +48 +19 +3553 +201 +16936 +43 +1169 +43 +8351 +14 +16937 +43 +14477 +1765 +2764 +43 +14957 +286 +14363 +15486 +3546 +48 +11321 +43 +16938 +16939 +16940 +4717 +554 +2769 +29 +3546 +8188 +3546 +2202 +14363 +1012 +43 +16941 +16942 +16437 +16943 +16944 +16945 +43 +1011 +4 +16946 +439 +16947 +16948 +16949 +16950 +13150 +16951 +43 +19 +48 +43 +16145 +19 +590 +14 +4278 +16952 +14 +43 +16953 +9 +15356 +286 +5416 +16954 +16955 +16881 +12987 +16956 +16957 +43 +16958 +16959 +741 +48 +16960 +616 +887 +590 +554 +3546 +16961 +7215 +16962 +16963 +7137 +1154 +16964 +7855 +741 +10958 +16965 +16966 +4278 +48 +48 +43 +590 +1077 +57 +1765 +2314 +16967 +595 +53 +16968 +1688 +48 +590 +16491 +16969 +12907 +12987 +16970 +16437 +19 +48 +474 +16971 +43 +2561 +16972 +43 +16973 +9 +16974 +112 +16975 +201 +14001 +16976 +43 +48 +16977 +590 +43 +1437 +16978 +48 +19 +9739 +15 +48 +16979 +15718 +845 +42 +80 +16980 +286 +741 +590 +155 +13566 +16981 +1992 +14 +16982 +1912 +16983 +16437 +43 +16984 +16985 +379 +43 +16986 +9 +1559 +57 +16987 +272 +210 +16988 +16989 +303 +29 +616 +16990 +16991 +16992 +48 +16993 +16994 +16995 +16996 +14 +613 +11522 +213 +16437 +48 +286 +2879 +16997 +357 +43 +14909 +16998 +358 +14477 +43 +19 +16999 +17000 +1054 +3546 +590 +43 +14185 +17001 +17002 +43 +43 +17003 +57 +337 +397 +333 +14 +2 +17004 +349 +14185 +17005 +590 +9 +17006 +17007 +15820 +43 +286 +14185 +1901 +16981 +15 +17008 +17009 +17010 +17011 +17012 +30 +43 +15 +48 +590 +14 +16437 +17013 +6301 +17014 +590 +590 +1361 +14477 +17011 +446 +590 +17015 +17016 +14 +17017 +736 +13555 +89 +17018 +4963 +337 +795 +15718 +19 +17019 +357 +5119 +104 +1502 +17020 +4388 +705 +6499 +5780 +14373 +736 +3546 +590 +11483 +3546 +80 +19 +17021 +89 +17022 +17023 +509 +17024 +536 +43 +1524 +2732 +17025 +971 +48 +17026 +201 +1228 +11321 +17027 +2650 +3192 +590 +2577 +3546 +1920 +152 +736 +14 +14853 +17028 +8255 +2594 +17029 +6950 +2514 +17030 +48 +5418 +17031 +1577 +57 +17032 +11754 +17033 +43 +32 +17034 +17035 +22 +48 +17036 +590 +17037 +14814 +17038 +1066 +4116 +17039 +43 +5218 +17040 +248 +43 +17041 +373 +3764 +16437 +43 +17042 +2349 +17043 +12891 +104 +5780 +17044 +17045 +17046 +1465 +32 +2409 +745 +7855 +3546 +17047 +17048 +48 +1011 +15220 +6106 +17049 +15855 +14 +17050 +736 +14 +590 +17051 +7276 +17052 +6072 +825 +590 +5780 +9705 +17053 +17054 +17055 +15718 +48 +17056 +2040 +17057 +17058 +493 +43 +17059 +3548 +3546 +358 +2694 +570 +15720 +2804 +17060 +17061 +188 +590 +17062 +57 +188 +3546 +17063 +11046 +137 +14363 +349 +13405 +17064 +17065 +17066 +16437 +17067 +43 +35 +5780 +2015 +17068 +48 +17069 +14 +15183 +17070 +1168 +14 +4934 +16826 +222 +17071 +17072 +9 +43 +19 +2260 +2009 +48 +15026 +17073 +17074 +17075 +14 +1612 +17076 +7962 +43 +15183 +8566 +15 +17077 +1021 +14 +17078 +17079 +43 +8392 +2593 +4808 +14 +17080 +590 +17081 +17082 +222 +9942 +17083 +3546 +17084 +17085 +48 +3216 +4056 +59 +701 +15718 +14 +893 +2457 +4026 +17086 +14477 +823 +736 +9444 +2009 +14 +43 +736 +17087 +8961 +3546 +17088 +43 +43 +17089 +11995 +48 +43 +179 +590 +3546 +8566 +15718 +32 +17090 +43 +14603 +10 +16488 +17091 +43 +1444 +43 +43 +17092 +14 +43 +14477 +17093 +48 +1153 +3626 +3317 +17094 +17095 +11727 +17096 +17097 +16491 +9649 +17098 +1364 +19 +17099 +17100 +5387 +16014 +9 +1817 +315 +13361 +317 +7176 +17101 +17102 +379 +17103 +17104 +17105 +17106 +20 +17107 +2864 +43 +484 +43 +7522 +17108 +17109 +6950 +349 +17110 +249 +17111 +43 +48 +43 +8668 +2577 +17112 +2769 +6048 +20 +17113 +48 +14 +5435 +17114 +17115 +17116 +14343 +17117 +533 +15989 +17118 +20 +17119 +43 +721 +8188 +17120 +17121 +1559 +14 +861 +590 +590 +19 +43 +17122 +17123 +15275 +17124 +17125 +17126 +3330 +741 +9 +590 +17127 +17128 +2979 +12987 +48 +590 +11754 +43 +43 +17129 +14477 +399 +43 +14 +19 +1051 +17130 +32 +25 +17131 +15718 +590 +17132 +6776 +17133 +9184 +5780 +12987 +17134 +15718 +1508 +764 +1992 +48 +8994 +4691 +12674 +15718 +590 +10 +11647 +11762 +17135 +590 +2318 +17136 +1287 +6741 +15442 +17042 +533 +1606 +17137 +43 +352 +188 +34 +15 +48 +17138 +358 +1612 +209 +19 +15975 +17139 +15240 +17140 +2316 +32 +17141 +16826 +17142 +46 +17143 +736 +14594 +11754 +53 +16741 +43 +286 +9 +48 +14911 +590 +43 +43 +17144 +736 +43 +7137 +5022 +17145 +3546 +2694 +17146 +17147 +1425 +379 +43 +179 +17148 +493 +43 +17149 +17150 +1559 +17151 +14 +377 +17152 +17153 +188 +3546 +14186 +583 +43 +17154 +17155 +15718 +694 +43 +17156 +590 +17157 +398 +1696 +647 +3546 +1765 +736 +495 +14477 +17158 +15645 +19 +683 +17159 +11483 +17160 +17161 +3546 +17162 +17163 +17164 +5601 +57 +590 +17165 +22 +4055 +137 +3335 +16197 +5067 +17166 +43 +17167 +48 +1232 +323 +9578 +823 +17168 +17169 +57 +10 +554 +17170 +618 +17171 +15914 +48 +17172 +2410 +14477 +16437 +43 +16589 +10147 +6950 +9427 +533 +201 +43 +17173 +931 +76 +17174 +19 +12987 +17175 +17176 +16826 +845 +17177 +17178 +17179 +15718 +17180 +14660 +286 +1612 +17181 +586 +43 +48 +17182 +16866 +17183 +17184 +17185 +3546 +2872 +2260 +17186 +17187 +17188 +17189 +114 +286 +3546 +270 +16436 +2260 +17190 +590 +43 +5409 +17191 +1513 +48 +14363 +17192 +9103 +15718 +16640 +48 +43 +48 +43 +17193 +15718 +48 +17194 +43 +17195 +4760 +14 +17196 +17197 +989 +43 +14825 +17198 +736 +57 +17199 +365 +17200 +17201 +17202 +43 +741 +590 +17203 +17204 +8668 +5582 +17205 +14185 +17136 +48 +17206 +4364 +3546 +43 +48 +2260 +43 +14 +14 +17011 +15718 +43 +6518 +1606 +209 +43 +1870 +1048 +32 +14 +17207 +17208 +17209 +12267 +16437 +1011 +14 +17210 +43 +5785 +9 +17211 +17212 +43 +1291 +17213 +2787 +89 +791 +17214 +1232 +10 +25 +14538 +17215 +14 +4803 +6505 +17216 +647 +17217 +188 +17218 +48 +17219 +399 +3999 +564 +317 +590 +188 +17220 +17221 +1912 +1924 +17222 +3553 +17223 +17224 +17225 +415 +17226 +694 +17227 +17228 +17229 +48 +474 +17230 +2 +178 +560 +17231 +17232 +17233 +5675 +17234 +2560 +22 +17235 +43 +2430 +17236 +17237 +17238 +17239 +2790 +10 +4908 +19 +17240 +48 +17241 +17242 +17243 +1232 +99 +10 +19 +1577 +43 +48 +17244 +17245 +14477 +736 +17246 +17247 +9 +43 +17248 +43 +844 +5344 +17249 +8566 +43 +14048 +1222 +17250 +112 +3417 +14185 +265 +736 +17251 +43 +8566 +17252 +48 +57 +2733 +590 +17253 +15824 +17254 +1154 +4028 +17255 +590 +16092 +17256 +17257 +9 +17258 +590 +6341 +286 +2316 +17259 +14 +5080 +7872 +48 +14 +1765 +57 +5780 +17260 +365 +17261 +22 +17262 +17263 +48 +1172 +17264 +43 +48 +48 +17265 +272 +43 +17266 +1765 +590 +155 +17267 +2577 +17268 +17269 +17270 +209 +48 +17271 +17272 +17273 +43 +43 +57 +7835 +14 +14185 +17274 +17275 +286 +2728 +16014 +590 +1529 +17276 +43 +17277 +43 +8994 +17278 +17279 +17280 +9410 +1224 +1961 +43 +1531 +5119 +17281 +43 +9784 +398 +5780 +2550 +14 +152 +736 +17282 +1051 +32 +14604 +647 +48 +201 +43 +17283 +2476 +1615 +12402 +48 +14 +17284 +48 +9 +17285 +1559 +17286 +17287 +17288 +5192 +595 +9705 +823 +17289 +707 +3050 +823 +1924 +17290 +16437 +48 +48 +17291 +43 +17292 +12404 +1154 +17293 +349 +14477 +358 +17294 +665 +17295 +17296 +43 +14 +741 +17297 +14 +43 +1376 +35 +1300 +14 +11286 +11757 +14001 +17298 +48 +15718 +17299 +736 +17300 +3599 +2697 +9 +12220 +17301 +17302 +19 +17303 +228 +590 +2577 +76 +17304 +12966 +4028 +43 +590 +590 +17305 +17306 +16437 +3543 +741 +17307 +14 +713 +14 +1232 +4313 +48 +14 +17308 +17309 +48 +48 +3546 +8301 +14871 +228 +17310 +5169 +48 +1115 +14 +1817 +3546 +1855 +736 +822 +3480 +17311 +15718 +741 +590 +43 +286 +1889 +17312 +365 +17313 +155 +22 +17314 +43 +15426 +12 +15718 +17315 +15 +6732 +1862 +17316 +5780 +17317 +17318 +17319 +48 +590 +17320 +15975 +43 +17321 +17322 +14 +17323 +17324 +5175 +43 +1605 +76 +43 +416 +17325 +17326 +17327 +349 +17328 +17329 +43 +17330 +14 +323 +17331 +17332 +1249 +97 +209 +17333 +17334 +3546 +17335 +17336 +32 +17337 +13307 +17338 +112 +17339 +17340 +14185 +17341 +43 +48 +2035 +17055 +22 +17342 +43 +10789 +17343 +17344 +17345 +17346 +17347 +17348 +17349 +32 +278 +15026 +17350 +10 +17351 +1524 +17352 +1229 +1615 +17353 +15718 +32 +736 +446 +2577 +17354 +491 +1612 +590 +17355 +43 +564 +2833 +1013 +3546 +43 +15718 +3546 +14 +9 +3484 +17356 +17357 +554 +17358 +17359 +590 +17360 +2733 +17361 +17362 +14 +493 +15 +17363 +122 +2913 +573 +4028 +17364 +17365 +12 +4963 +590 +22 +3417 +464 +8188 +17366 +1157 +43 +9 +17367 +1907 +323 +17368 +17369 +2117 +10230 +12987 +12534 +17370 +17371 +2202 +15586 +17372 +22 +17373 +1051 +17374 +17375 +17376 +17377 +16640 +358 +590 +14477 +43 +14 +590 +17378 +17379 +43 +14 +17380 +17381 +17382 +17073 +15718 +1232 +12351 +12005 +16437 +17383 +1287 +590 +14477 +1090 +17384 +272 +17385 +43 +20 +17386 +14477 +4684 +1287 +2577 +8249 +11471 +11593 +6776 +17387 +554 +17388 +17389 +20 +13913 +15718 +17390 +379 +17391 +17392 +9 +17235 +3546 +989 +720 +349 +2035 +741 +1502 +43 +6518 +20 +17393 +17394 +17395 +43 +3546 +17396 +112 +14 +17397 +4765 +17398 +9 +14 +5920 +5381 +501 +590 +3546 +17399 +17400 +671 +3546 +17401 +2577 +17402 +823 +17403 +17404 +19 +2286 +17405 +1542 +17406 +1051 +6294 +2349 +5627 +196 +1234 +17407 +10 +1021 +17408 +590 +2410 +16826 +284 +10673 +17409 +86 +17410 +2476 +17411 +12120 +14001 +43 +17412 +4765 +17413 +17414 +1369 +17415 +17416 +14001 +57 +15122 +17417 +16089 +1232 +2064 +17413 +17418 +616 +17419 +17420 +597 +2739 +358 +43 +248 +43 +43 +736 +3790 +17421 +17422 +8566 +16437 +19 +590 +11762 +15718 +17423 +9 +736 +43 +29 +5920 +17424 +17425 +16604 +3546 +14868 +17426 +3287 +349 +17427 +17428 +17429 +48 +286 +15 +2009 +43 +14 +1578 +2389 +17430 +43 +736 +176 +3034 +17431 +17432 +201 +17433 +12299 +43 +349 +11754 +17434 +43 +764 +484 +17435 +19 +17436 +683 +19 +188 +5611 +14 +14 +14 +179 +1112 +2308 +17437 +11685 +141 +17438 +14603 +17439 +590 +43 +17440 +13974 +17441 +337 +15718 +284 +349 +4521 +17442 +16604 +17443 +646 +17413 +17444 +2324 +17356 +3546 +43 +17445 +590 +43 +17446 +16102 +14067 +16437 +17447 +416 +43 +17448 +17449 +17450 +17451 +590 +17452 +17453 +2315 +17454 +43 +17455 +43 +590 +17456 +46 +48 +13529 +4153 +590 +15 +17457 +12062 +349 +2 +2849 +354 +14161 +1543 +640 +17458 +15824 +590 +3546 +17459 +590 +284 +2577 +48 +17460 +48 +6468 +17461 +17462 +590 +590 +17463 +30 +6950 +736 +17464 +14477 +17465 +17466 +17467 +43 +892 +13325 +188 +14846 +3330 +9 +17468 +1688 +15308 +677 +14532 +17469 +1154 +3330 +32 +17470 +349 +9 +337 +713 +17471 +736 +1465 +696 +43 +213 +590 +286 +48 +17472 +1743 +17473 +17474 +17475 +17476 +6171 +152 +8367 +112 +14 +1232 +2 +16003 +590 +48 +48 +48 +43 +554 +15217 +43 +48 +48 +77 +17477 +14001 +9 +43 +17478 +17479 +213 +6505 +1605 +17480 +48 +17481 +590 +3080 +43 +9 +590 +17482 +13030 +8188 +22 +17483 +17484 +14477 +14 +43 +15 +6617 +123 +17485 +713 +4028 +57 +17486 +1013 +849 +17487 +43 +17488 +1920 +22 +971 +16866 +17489 +9842 +43 +17490 +1605 +7276 +43 +736 +590 +17491 +2 +10 +17492 +138 +17493 +17494 +17495 +17496 +43 +48 +43 +1637 +5446 +57 +48 +741 +13430 +48 +284 +9 +17497 +286 +48 +694 +17470 +17498 +17499 +57 +2009 +6406 +1047 +17500 +43 +3072 +179 +43 +32 +887 +13569 +286 +15951 +14 +43 +3546 +822 +694 +48 +17501 +1442 +349 +2655 +5908 +17228 +15583 +155 +17502 +17503 +48 +1056 +590 +17504 +16190 +17505 +48 +4441 +17506 +17507 +1513 +3546 +8668 +6877 +17508 +155 +17509 +17510 +17511 +9259 +17512 +43 +17513 +1716 +590 +5627 +15797 +16981 +15881 +3743 +8469 +17514 +8188 +32 +14 +590 +14 +14841 +17515 +137 +112 +5080 +17516 +17517 +354 +48 +17518 +915 +17519 +17229 +99 +213 +17520 +213 +745 +17521 +17522 +4081 +17523 +17524 +141 +17525 +337 +1508 +17526 +43 +14189 +12013 +213 +14 +17527 +17528 +17529 +29 +736 +19 +17530 +8849 +564 +416 +17531 +17532 +209 +17533 +1364 +17534 +11483 +9 +17535 +17536 +8994 +43 +29 +43 +17537 +43 +115 +17538 +17539 +48 +16437 +12005 +17540 +2 +2356 +533 +17541 +7208 +1961 +2 +590 +958 +17542 +19 +14363 +337 +2864 +46 +475 +248 +43 +17543 +6214 +17544 +3546 +43 +17545 +14 +17546 +337 +17547 +17548 +17549 +17550 +17551 +484 +57 +282 +19 +17552 +17553 +14477 +17554 +13985 +590 +19 +14 +15718 +15592 +3415 +43 +3330 +741 +43 +48 +11995 +43 +57 +3034 +43 +77 +16102 +98 +1364 +17555 +17556 +971 +10 +8297 +17557 +272 +2260 +11483 +57 +14477 +17558 +13466 +284 +17559 +15718 +12120 +17560 +43 +17561 +15718 +17562 +17563 +4306 +647 +17564 +337 +48 +17565 +15334 +48 +14947 +1637 +337 +7154 +272 +213 +16437 +8392 +43 +337 +16437 +15718 +15 +10 +14 +17566 +17567 +558 +17568 +14 +3491 +8076 +48 +17569 +43 +1727 +4963 +3546 +590 +43 +17570 +17571 +5304 +303 +1112 +590 +17572 +17573 +17055 +17574 +17575 +590 +2577 +3546 +15718 +43 +736 +16437 +17576 +303 +19 +43 +17577 +57 +14363 +43 +112 +17578 +248 +11995 +17579 +17580 +14 +305 +590 +17581 +43 +286 +60 +12807 +20 +15718 +741 +1924 +46 +15718 +3626 +17582 +17583 +6058 +474 +4677 +15001 +188 +17584 +491 +48 +1799 +958 +43 +17585 +3329 +5627 +823 +424 +3553 +10757 +34 +19 +286 +17586 +14 +48 +11600 +43 +48 +43 +104 +11475 +17587 +17588 +17589 +17590 +1716 +12722 +14 +17591 +2136 +8297 +10843 +3572 +3546 +8670 +15718 +17592 +17593 +590 +19 +17594 +2042 +3553 +17595 +17596 +17597 +11754 +17598 +694 +590 +20 +17599 +17600 +17601 +8249 +17602 +10 +17603 +48 +43 +43 +9 +2035 +10356 +137 +14 +17604 +48 +17605 +9 +17606 +2006 +590 +14477 +358 +43 +17607 +17608 +20 +590 +17609 +14 +16437 +17610 +57 +17611 +17612 +3310 +14 +20 +12987 +286 +1051 +822 +15 +416 +14 +17613 +1524 +48 +5299 +17614 +188 +9118 +1513 +14 +17615 +5267 +43 +872 +17616 +196 +17617 +17618 +122 +17619 +14 +1912 +17620 +17621 +17622 +5780 +872 +8849 +43 +43 +66 +323 +17623 +155 +188 +1716 +17624 +736 +286 +1082 +43 +17625 +286 +17626 +43 +1423 +17627 +17628 +1992 +209 +590 +17629 +791 +17630 +1696 +17631 +17632 +42 +9 +17262 +17633 +17634 +15649 +15654 +17635 +17636 +770 +590 +43 +48 +14 +17637 +155 +2 +13492 +4313 +11522 +17638 +43 +48 +1172 +2525 +17639 +554 +189 +17640 +8867 +43 +11754 +590 +14 +170 +14102 +17151 +48 +17641 +590 +349 +790 +707 +3546 +43 +286 +17642 +238 +19 +17643 +349 +8566 +19 +17644 +990 +15 +14 +958 +8428 +67 +14189 +720 +15718 +648 +3546 +17645 +20 +16437 +17646 +822 +5085 +790 +161 +17647 +17648 +11817 +286 +17649 +17650 +32 +17651 +32 +17652 +17653 +16437 +15761 +500 +4441 +17654 +66 +16981 +417 +536 +48 +7855 +43 +14477 +590 +6214 +17655 +14 +17656 +5080 +19 +112 +554 +14604 +17657 +48 +3546 +17658 +43 +2975 +554 +9 +6011 +155 +48 +17659 +17596 +17660 +16437 +48 +48 +4313 +17136 +1648 +17661 +19 +4963 +9 +15718 +9 +7154 +1287 +48 +17662 +17663 +17664 +7783 +590 +176 +8668 +16437 +2769 +17665 +17666 +10 +15118 +17667 +2314 +764 +15718 +17668 +48 +43 +43 +43 +349 +6468 +48 +15320 +14604 +590 +17669 +694 +140 +17670 +19 +2769 +57 +15718 +15718 +1051 +48 +6571 +66 +112 +15 +1808 +112 +2 +1745 +3072 +10 +1112 +11754 +14604 +19 +13566 +554 +17671 +48 +17672 +43 +17673 +1330 +48 +140 +4808 +1710 +3484 +17674 +15 +9 +1961 +1232 +48 +5217 +17675 +554 +17676 +17677 +590 +57 +590 +15 +10 +16437 +14363 +15683 +97 +671 +590 +48 +613 +48 +1817 +14604 +3944 +17678 +17679 +365 +647 +17680 +17681 +17682 +17683 +5780 +17684 +12120 +15 +17685 +12987 +17686 +1203 +17687 +43 +17688 +1018 +379 +17689 +2577 +12864 +8208 +272 +17097 +1612 +12600 +915 +17690 +2865 +16437 +43 +17691 +17692 +736 +17693 +13711 +17694 +17695 +2697 +3546 +43 +17696 +43 +17697 +1384 +17698 +590 +15054 +590 +17699 +14 +14185 +872 +4278 +17700 +402 +2260 +19 +7860 +15 +491 +17701 +17702 +2202 +2577 +14 +11754 +43 +22 +16437 +2694 +536 +1401 +17703 +323 +5088 +19 +1066 +590 +43 +43 +7580 +17704 +7253 +12202 +17705 +1927 +115 +14 +10 +590 +7812 +17706 +17707 +17708 +17709 +17710 +17711 +210 +17712 +17713 +43 +17714 +352 +590 +16305 +10993 +17715 +89 +15 +741 +138 +22 +736 +590 +17716 +590 +17717 +533 +15493 +2253 +17718 +43 +48 +720 +4684 +48 +17719 +17720 +2733 +17721 +17722 +35 +3005 +60 +17723 +17724 +15824 +17725 +2 +1134 +8188 +17726 +4929 +17727 +17728 +3546 +17729 +1437 +3653 +17730 +17731 +17732 +11754 +1559 +323 +15718 +17733 +17734 +17735 +17736 +17737 +1203 +17738 +665 +17739 +48 +6900 +17740 +14 +590 +48 +179 +17741 +736 +16437 +669 +464 +1013 +16150 +17742 +1578 +15853 +1514 +17743 +43 +16844 +17744 +12404 +14 +152 +1765 +48 +14477 +17745 +11321 +43 +11754 +16719 +14477 +2314 +5403 +17746 +15718 +1559 +14007 +1425 +19 +17747 +17748 +736 +4760 +80 +48 +3544 +17749 +80 +573 +15718 +2537 +892 +17750 +57 +17751 +554 +10 +17752 +14079 +5780 +17753 +17754 +43 +10028 +17755 +43 +1021 +1847 +1091 +17756 +17757 +14 +1425 +5780 +12987 +17758 +13375 +17759 +1112 +19 +17760 +14 +17761 +17762 +43 +3546 +14477 +13349 +48 +13282 +17763 +43 +2619 +1442 +413 +12402 +1559 +17764 +66 +2577 +349 +817 +43 +16443 +14957 +2941 +43 +1612 +3077 +3034 +17765 +2561 +48 +16024 +9 +17766 +817 +42 +48 +48 +17767 +17768 +17769 +1169 +17770 +17771 +17772 +14679 +17773 +17774 +12987 +736 +17775 +15718 +1049 +14 +1425 +590 +43 +8208 +1384 +17776 +43 +17777 +1992 +14935 +541 +17778 +15148 +2577 +349 +349 +17779 +17780 +17781 +17782 +17783 +19 +305 +428 +665 +17784 +48 +17785 +17786 +15928 +17787 +17788 +3546 +3546 +14 +11593 +48 +17789 +647 +533 +17790 +286 +17791 +590 +14 +17792 +4963 +76 +193 +17793 +272 +17794 +741 +1011 +1808 +590 +4269 +17795 +12 +15718 +2392 +104 +16927 +17796 +647 +5041 +14 +17797 +590 +4196 +48 +647 +12241 +17466 +17798 +15 +1232 +17799 +66 +17800 +3279 +764 +14693 +2764 +8263 +43 +48 +34 +14477 +590 +2336 +3546 +305 +15989 +5780 +178 +17801 +17802 +17803 +17804 +1442 +15718 +32 +140 +17805 +590 +17806 +590 +2476 +13209 +17807 +16437 +11593 +17808 +17809 +10946 +43 +17810 +590 +17811 +15718 +590 +13179 +48 +14 +17812 +2 +48 +17813 +15718 +705 +17814 +3546 +1181 +2000 +98 +1232 +14 +152 +17815 +17816 +14604 +43 +17817 +17818 +185 +5780 +590 +738 +12684 +12722 +4808 +17819 +17820 +17821 +15 +17822 +17823 +6804 +17824 +14 +14 +17825 +817 +338 +1793 +60 +14 +17826 +14 +57 +736 +17827 +2769 +17828 +17829 +17830 +3546 +43 +741 +590 +14363 +590 +17831 +4963 +10789 +17602 +971 +9 +15874 +17832 +14 +13528 +17833 +3546 +16437 +736 +17834 +14 +3172 +1559 +17835 +17836 +16640 +9 +43 +14 +48 +590 +3 +17837 +415 +43 +9660 +155 +17838 +17839 +17840 +9 +590 +17841 +43 +17842 +15718 +17843 +11733 +32 +48 +201 +43 +17844 +43 +14477 +9 +57 +554 +16180 +48 +17845 +554 +14 +1091 +6953 +17846 +9945 +14872 +14603 +15718 +17847 +17848 +590 +15718 +2477 +209 +43 +17849 +112 +35 +8214 +225 +2064 +17850 +17381 +648 +17851 +15718 +17852 +17853 +6950 +17854 +155 +478 +43 +17855 +48 +14082 +357 +590 +57 +1090 +14 +17856 +861 +17857 +3546 +1563 +43 +17858 +14 +17859 +358 +2594 +17860 +17861 +1425 +17862 +2982 +17863 +6776 +155 +48 +19 +590 +17864 +19 +1356 +17865 +17866 +16437 +17867 +17868 +2035 +17869 +43 +17870 +590 +3316 +910 +15308 +736 +717 +32 +370 +109 +349 +17871 +9119 +2043 +17872 +16020 +14 +2 +48 +17873 +17874 +2 +8188 +17875 +13566 +15 +349 +14604 +43 +17876 +17877 +17878 +14 +286 +17879 +493 +17880 +4524 +48 +17881 +17882 +11754 +14 +17883 +17884 +15 +590 +43 +1154 +15797 +17885 +17886 +14603 +533 +15718 +484 +17887 +43 +43 +14560 +2804 +11483 +590 +43 +48 +14603 +19 +17888 +1157 +17889 +57 +9 +17890 +6537 +48 +10642 +4128 +7624 +3543 +17891 +8188 +48 +17892 +686 +17893 +17894 +17895 +14 +57 +17770 +17896 +4650 +43 +17897 +1295 +590 +590 +20 +48 +14477 +16413 +17898 +48 +43 +849 +17899 +849 +17900 +15 +155 +248 +736 +17901 +2721 +17902 +17903 +17904 +6785 +43 +10 +4963 +43 +17905 +20 +17906 +48 +155 +188 +213 +17907 +155 +3546 +188 +303 +16927 +17908 +17909 +17910 +14604 +17911 +43 +741 +416 +590 +17912 +3546 +1425 +3546 +14 +597 +349 +3546 +43 +16128 +48 +286 +873 +736 +17913 +19 +43 +345 +349 +22 +15 +17914 +554 +2029 +5169 +17915 +43 +17916 +17917 +590 +1612 +48 +337 +17918 +1716 +43 +16464 +14 +17919 +43 +17920 +17921 +12158 +13307 +15718 +155 +2314 +17922 +17923 +17924 +17 +248 +48 +17925 +14363 +1696 +17926 +32 +17927 +17928 +6935 +35 +43 +17929 +17930 +13150 +590 +1680 +17931 +10028 +11966 +16696 +323 +2804 +590 +736 +17932 +17933 +11754 +155 +43 +1232 +590 +43 +17934 +3546 +2035 +20 +8685 +20 +11593 +8610 +2318 +7239 +66 +43 +6214 +43 +43 +137 +17935 +17936 +2804 +647 +17937 +48 +590 +43 +3546 +3553 +16437 +861 +17938 +736 +823 +17939 +286 +1465 +14 +13375 +2791 +1222 +823 +554 +17940 +736 +1559 +17941 +8297 +16826 +7137 +286 +2733 +1902 +13282 +10356 +89 +936 +17942 +1181 +17943 +14406 +17944 +17945 +17946 +647 +17947 +17948 +32 +17949 +17950 +17951 +32 +43 +43 +17952 +284 +15 +17953 +464 +22 +80 +3330 +736 +9 +5780 +43 +17954 +17955 +17956 +17957 +17958 +32 +155 +8668 +13317 +399 +43 +17959 +2593 +3546 +736 +2567 +11762 +48 +19 +1082 +1011 +15 +17960 +3059 +43 +6765 +769 +1817 +17872 +17663 +15 +248 +5027 +17961 +590 +42 +36 +13484 +5601 +741 +3034 +12722 +17962 +17963 +17964 +17965 +43 +17966 +48 +17967 +43 +43 +572 +48 +19 +16844 +736 +43 +43 +13484 +17968 +1513 +17969 +43 +5780 +48 +1139 +17970 +17971 +303 +17972 +303 +17973 +17974 +17975 +736 +17976 +17977 +17978 +9 +48 +357 +11762 +17979 +17980 +43 +17981 +17982 +43 +12560 +397 +17983 +1920 +17984 +284 +17985 +17986 +213 +48 +478 +17987 +6114 +48 +48 +3546 +248 +20 +286 +14 +248 +736 +7448 +4963 +4963 +19 +14 +865 +590 +365 +17988 +17989 +323 +248 +43 +736 +17990 +764 +955 +17991 +22 +13459 +32 +4461 +152 +48 +48 +188 +17992 +14 +11176 +1051 +213 +736 +17993 +17994 +43 +3546 +1577 +736 +15718 +10510 +17995 +823 +17996 +17997 +17998 +590 +16696 +590 +43 +43 +14477 +15718 +16239 +17999 +18000 +18001 +18002 +18003 +18004 +3460 +18005 +43 +18006 +873 +17412 +18007 +5601 +19 +18008 +18009 +18010 +43 +18011 +48 +721 +286 +13807 +5780 +3546 +14001 +18012 +6400 +18013 +18014 +19 +2591 +4684 +155 +18015 +18016 +5780 +2258 +18017 +18018 +18019 +14981 +3491 +12319 +9 +18020 +18021 +188 +2314 +286 +18022 +18023 +18024 +13431 +18025 +18012 +18026 +286 +286 +18027 +1287 +554 +2045 +707 +155 +18028 +9 +43 +18029 +18030 +3353 +14 +18012 +3546 +1091 +590 +209 +18031 +790 +18032 +32 +98 +43 +18033 +32 +770 +18034 +13730 +18035 +15031 +18036 +18037 +18038 +14 +18039 +14477 +18040 +358 +18041 +7137 +18042 +18043 +43 +6883 +19 +3 +741 +1107 +19 +14693 +18044 +201 +18045 +14 +112 +3546 +18046 +43 +18047 +12397 +18048 +43 +365 +18049 +13466 +10 +32 +18050 +43 +43 +188 +15720 +528 +48 +7978 +20 +11762 +18051 +201 +98 +18052 +590 +18053 +209 +6531 +3546 +18054 +18055 +1013 +915 +647 +616 +18056 +17370 +554 +18057 +8218 +3546 +286 +209 +57 +554 +18058 +48 +18059 +14604 +18060 +18061 +18062 +2314 +2026 +111 +48 +1824 +3732 +18063 +48 +48 +43 +15285 +931 +43 +4028 +18064 +3546 +14 +18065 +18066 +12989 +3546 +43 +18067 +18068 +590 +19 +43 +18069 +18070 +15718 +338 +8668 +590 +18071 +48 +15268 +3287 +43 +349 +736 +18072 +3447 +15718 +1247 +323 +17728 +18073 +43 +18074 +17675 +180 +349 +112 +18075 +43 +18076 +590 +1437 +3546 +43 +3034 +14604 +7137 +18077 +18078 +18079 +15 +16937 +17480 +11483 +1048 +16014 +18080 +349 +3598 +554 +18081 +18082 +57 +43 +43 +14 +590 +764 +18083 +15 +48 +16437 +188 +4 +138 +1481 +349 +18084 +9 +9 +741 +5780 +18085 +789 +18086 +5780 +17228 +18087 +14477 +18088 +15718 +10 +48 +10117 +4411 +18089 +178 +1300 +845 +18090 +19 +272 +349 +18091 +32 +1048 +14 +188 +10287 +77 +736 +11762 +1542 +80 +48 +18092 +43 +18093 +9371 +741 +18094 +554 +4070 +48 +349 +15718 +18095 +48 +18096 +201 +14 +694 +3944 +18097 +2 +9 +2762 +286 +112 +590 +18098 +3553 +18099 +43 +15718 +13599 +349 +18100 +18101 +18102 +1446 +1547 +250 +590 +2 +18103 +19 +5188 +18104 +18105 +46 +14 +18106 +10 +3 +18107 +43 +8053 +1955 +590 +18108 +11762 +15 +8320 +18109 +18110 +14871 +43 +48 +18111 +18112 +16180 +18113 +3976 +286 +1710 +1870 +590 +18114 +15 +18115 +43 +43 +6950 +43 +3351 +18116 +19 +14420 +48 +6950 +18117 +590 +222 +19 +1232 +7451 +43 +18118 +1991 +16437 +286 +647 +18119 +15718 +13150 +18120 +2476 +736 +18121 +18122 +18123 +14 +272 +5780 +14604 +18124 +48 +1868 +9 +18125 +12344 +2287 +647 +43 +18126 +18127 +2591 +18128 +3546 +554 +590 +18129 +13179 +16437 +18130 +15718 +18131 +122 +5650 +2459 +1364 +18132 +2035 +1502 +1310 +536 +66 +1989 +3546 +590 +16014 +14 +7537 +14604 +112 +1824 +16437 +48 +18133 +1912 +554 +18134 +18135 +66 +18136 +4315 +152 +647 +18137 +10 +13913 +18138 +14 +1112 +349 +3546 +6766 +43 +12987 +13566 +590 +18139 +4441 +32 +554 +18140 +18141 +18142 +647 +18143 +16102 +18144 +43 +98 +18145 +2 +14186 +18146 +43 +590 +18147 +694 +18148 +1425 +18149 +590 +736 +18150 +286 +17749 +590 +48 +32 +46 +43 +1465 +411 +3462 +32 +18151 +18152 +14001 +2892 +349 +14386 +15540 +18153 +57 +13179 +48 +18154 +18155 +14616 +11283 +286 +18156 +788 +2325 +48 +66 +112 +18157 +2975 +1912 +15 +2410 +323 +18158 +14102 +249 +7624 +16437 +3546 +11860 +14477 +19 +48 +3546 +18159 +48 +18160 +18161 +12013 +119 +15530 +18162 +573 +60 +18163 +18164 +48 +18165 +1648 +741 +18166 +18167 +817 +48 +15820 +305 +249 +18168 +1112 +18169 +43 +18170 +249 +349 +18171 +18172 +32 +3 +15 +18173 +18174 +1513 +590 +1021 +9 +18175 +15718 +18176 +48 +32 +43 +20 +14 +43 +18177 +137 +590 +18178 +18179 +76 +57 +43 +717 +18180 +13150 +590 +18181 +1060 +18182 +703 +18183 +18184 +18185 +18186 +18187 +18188 +48 +18189 +18190 +18191 +18192 +9 +1011 +89 +9 +8367 +915 +15718 +18193 +43 +18194 +18195 +349 +13150 +958 +18196 +43 +590 +18197 +17303 +18198 +3034 +43 +18199 +4160 +43 +48 +5780 +5990 +14363 +7747 +43 +14007 +1920 +19 +3546 +3546 +6457 +18200 +10 +18201 +4793 +15877 +8392 +18202 +18203 +18204 +5623 +3546 +305 +18205 +7137 +176 +22 +18206 +15718 +13343 +201 +18207 +590 +15720 +43 +18208 +18209 +18210 +18211 +18212 +3546 +18213 +48 +11754 +18045 +18214 +1907 +6874 +18215 +15718 +16437 +11312 +349 +2 +1612 +3546 +18216 +18217 +18218 +286 +15647 +18219 +15718 +590 +14 +48 +823 +412 +3546 +48 +18220 +18221 +18222 +18223 +1481 +18224 +6834 +18225 +18226 +8297 +1919 +17055 +18227 +18228 +416 +18229 +140 +228 +43 +18230 +2166 +2164 +18231 +1090 +1047 +18232 +10848 +16966 +18233 +20 +48 +18234 +89 +349 +12402 +13484 +43 +18235 +10356 +1361 +18236 +1912 +18237 +541 +492 +18238 +373 +43 +20 +613 +15718 +18239 +18240 +18241 +18012 +5780 +11754 +43 +18242 +430 +18243 +590 +14 +18244 +4820 +57 +849 +138 +1612 +4174 +590 +18245 +46 +18246 +370 +18247 +19 +16437 +989 +99 +18248 +14 +2 +18249 +14916 +43 +554 +736 +2260 +17033 +32 +1716 +16788 +18250 +7137 +43 +18251 +18252 +18253 +827 +8668 +18254 +77 +1790 +13375 +18255 +18256 +18257 +2694 +18258 +43 +14007 +13282 +18259 +18260 +18261 +18262 +18263 +9 +24 +18264 +18265 +43 +590 +14477 +18266 +14612 +18267 +590 +18268 +18269 +2476 +18270 +15989 +22 +18271 +18272 +14 +18273 +18274 +286 +3338 +3 +18275 +2197 +43 +18276 +57 +43 +18277 +590 +5007 +75 +18278 +18279 +18280 +333 +14 +18281 +18282 +590 +18283 +4677 +399 +18284 +1437 +112 +155 +970 +112 +18285 +19 +10979 +25 +15778 +18286 +8351 +18287 +43 +16329 +43 +18288 +19 +18289 +6214 +18290 +590 +18291 +349 +18292 +745 +18293 +43 +12845 +18294 +1013 +18295 +18296 +1425 +14 +10583 +14 +958 +2769 +14 +6883 +665 +18297 +18298 +6499 +18064 +259 +349 +18299 +18300 +18301 +764 +18302 +48 +14 +43 +590 +66 +18303 +18304 +18305 +14 +43 +301 +18306 +18307 +18308 +16656 +43 +342 +32 +18309 +193 +12247 +736 +18310 +18311 +1502 +18312 +12120 +11480 +18313 +279 +14 +736 +6785 +1578 +14693 +15718 +18314 +18315 +18316 +4001 +915 +358 +43 +18317 +18318 +286 +17698 +16437 +18319 +18320 +18321 +12005 +18322 +43 +349 +1901 +18323 +14 +19 +17557 +15718 +1232 +495 +24 +16 +1517 +11762 +2 +379 +12404 +18324 +18325 +1942 +43 +358 +13126 +18045 +12913 +279 +43 +6316 +1228 +13150 +18326 +6766 +18327 +43 +201 +3354 +188 +3546 +18328 +333 +3546 +9 +9 +14 +43 +18329 +19 +1212 +16437 +4028 +155 +9 +286 +43 +43 +18330 +272 +6950 +1258 +80 +18331 +11754 +15718 +13664 +14 +14240 +18332 +18333 +43 +22 +1364 +188 +677 +14604 +1637 +18334 +18335 +32 +18336 +13459 +48 +18337 +3976 +590 +14 +509 +736 +590 +272 +10 +20 +1013 +626 +18338 +17868 +155 +18339 +188 +2000 +2577 +915 +6766 +18340 +16180 +2 +48 +15718 +286 +1604 +18341 +18342 +3 +43 +554 +18343 +43 +48 +18344 +14 +18345 +14420 +18346 +590 +8188 +18347 +18348 +18349 +18350 +18351 +3546 +222 +17868 +15718 +18352 +18353 +9 +43 +647 +14604 +10 +18354 +1992 +43 +14 +6794 +14477 +43 +14604 +1012 +20 +48 +43 +48 +18355 +18356 +548 +18357 +1236 +18358 +17635 +185 +14 +11306 +349 +19 +18359 +19 +2 +16437 +1765 +18360 +590 +48 +32 +2260 +4963 +48 +15718 +2430 +3066 +18361 +18362 +317 +9 +18363 +464 +4023 +18364 +43 +12987 +16437 +20 +155 +4077 +18365 +379 +14477 +18012 +745 +2314 +15718 +48 +2476 +6950 +17 +14 +2 +178 +112 +590 +43 +48 +349 +43 +5780 +1961 +188 +1234 +533 +18366 +18367 +22 +9 +15 +18368 +18369 +155 +18370 +18371 +155 +18372 +14 +14374 +18373 +19 +1920 +736 +12372 +554 +48 +3546 +18374 +18375 +18376 +286 +17253 +18377 +286 +15586 +590 +18378 +244 +48 +12404 +349 +18379 +18380 +590 +6776 +228 +2769 +18381 +6915 +16511 +18382 +43 +2 +5780 +3546 +18383 +3546 +155 +18384 +114 +2258 +736 +209 +3546 +3491 +474 +18045 +18385 +1655 +18386 +43 +43 +349 +590 +11670 +18387 +736 +145 +18388 +18389 +6011 +1502 +19 +12907 +43 +43 +1425 +18390 +590 +22 +13648 +2957 +927 +19 +14 +1531 +491 +11762 +16656 +736 +18391 +18392 +43 +43 +6400 +590 +20 +15 +15931 +20 +11822 +1817 +18393 +19 +18394 +141 +17136 +18395 +554 +18396 +18397 +7048 +5178 +138 +18398 +14710 +18399 +15718 +18400 +386 +1683 +18401 +16981 +18402 +17370 +17653 +613 +18403 +590 +1232 +18404 +18405 +5773 +19 +18406 +14477 +11480 +14 +18407 +272 +14 +99 +43 +1109 +14363 +958 +14001 +18408 +15951 +2 +43 +19 +8015 +560 +1047 +14645 +15586 +48 +16230 +48 +12178 +14856 +43 +43 +4155 +66 +15 +19 +18409 +57 +18410 +18411 +349 +1738 +18412 +48 +17119 +48 +14 +14477 +18413 +1765 +18414 +179 +17698 +286 +18415 +18416 +18417 +6344 +18418 +18419 +18420 +590 +2 +741 +14 +495 +5780 +18421 +349 +1716 +18422 +15 +16437 +301 +15486 +18423 +18424 +1976 +1991 +18425 +2197 +19 +222 +17602 +18426 +18427 +14515 +1924 +18428 +18429 +9 +43 +48 +18430 +2430 +590 +18431 +14 +6950 +18343 +57 +18432 +18433 +2694 +349 +18434 +358 +1021 +9 +3546 +590 +18435 +13566 +48 +8218 +32 +18436 +15819 +97 +48 +2733 +2324 +18437 +1566 +48 +1559 +809 +19 +43 +43 +14363 +10 +22 +373 +14532 +590 +18438 +43 +74 +17670 +43 +1364 +18439 +10485 +323 +10 +112 +16944 +19 +19 +5415 +18440 +18441 +8758 +18442 +6621 +18443 +18444 +18445 +18446 +12404 +1021 +18447 +152 +590 +18448 +590 +18449 +1223 +43 +764 +43 +764 +14 +14 +13393 +6874 +48 +18450 +398 +43 +14477 +14 +18451 +43 +18452 +15 +284 +18453 +5421 +11607 +18454 +32 +20 +18455 +18456 +43 +48 +554 +18457 +491 +14 +43 +5925 +18458 +213 +18459 +4028 +15718 +15 +18460 +17303 +4820 +18461 +14 +18462 +18463 +6243 +15718 +179 +2577 +284 +18464 +22 +18465 +43 +3546 +14477 +14 +18466 +18467 +32 +18468 +18469 +284 +19 +12907 +337 +18470 +590 +595 +43 +38 +18471 +14871 +1012 +4594 +12466 +18472 +590 +18473 +1426 +303 +736 +18474 +1612 +18475 +6950 +3655 +10028 +2525 +99 +741 +16014 +18476 +43 +9402 +349 +5780 +590 +18477 +18478 +741 +12258 +18479 +43 +1425 +10642 +590 +590 +4083 +14 +18406 +5469 +3546 +15718 +337 +16925 +18480 +18481 +18482 +365 +5780 +18483 +15718 +18484 +5264 +11341 +6669 +3546 +554 +613 +17046 +18485 +48 +337 +18486 +18487 +188 +38 +369 +18488 +19 +18489 +89 +3052 +18490 +18491 +14 +18492 +4285 +989 +43 +14604 +15718 +43 +18493 +3640 +18494 +590 +43 +18495 +1295 +590 +590 +736 +590 +48 +138 +18496 +1066 +48 +1356 +11754 +99 +43 +12005 +18497 +284 +18498 +286 +18499 +18500 +721 +18501 +14 +8668 +14 +18502 +19 +18503 +17385 +9389 +18504 +18505 +188 +43 +13913 +5409 +11822 +6518 +155 +736 +48 +349 +1738 +48 +415 +43 +18506 +18507 +284 +43 +19 +3130 +188 +18508 +18509 +18510 +16118 +18511 +16342 +3767 +845 +46 +18512 +43 +4151 +18513 +18514 +590 +3417 +248 +18002 +18515 +6214 +11754 +17941 +32 +18516 +12798 +57 +18012 +57 +18517 +18518 +2264 +18519 +16437 +18520 +48 +18521 +14 +19 +43 +14 +9 +18522 +9 +14693 +18523 +18524 +590 +5659 +541 +17871 +19 +1364 +58 +48 +18525 +14603 +2 +18526 +9649 +590 +3301 +18527 +19 +18528 +373 +6004 +18529 +19 +18530 +1013 +873 +18531 +665 +9 +286 +43 +32 +18532 +18533 +3546 +736 +18534 +18535 +16437 +18536 +493 +554 +155 +18537 +6011 +18538 +18539 +20 +18540 +18541 +736 +18542 +286 +111 +495 +201 +7053 +18543 +11321 +19 +415 +48 +43 +2971 +3 +48 +10 +48 +10601 +597 +18544 +48 +16944 +2707 +19 +354 +43 +18545 +18546 +48 +2593 +3546 +18547 +19 +19 +43 +18548 +12603 +43 +1749 +12 +43 +18549 +19 +18550 +349 +1021 +16527 +18551 +17 +18552 +18553 +80 +18554 +286 +43 +43 +5169 +9 +590 +1226 +43 +248 +349 +18555 +18556 +15 +35 +741 +2567 +286 +19 +18155 +14 +43 +43 +764 +15830 +18557 +48 +43 +2 +736 +43 +18558 +14603 +18559 +18560 +7379 +736 +2446 +11995 +18561 +18562 +872 +3546 +650 +48 +43 +43 +18563 +248 +18564 +446 +18565 +18566 +15718 +1310 +18567 +48 +18568 +152 +9979 +10 +4387 +9 +2348 +4083 +11593 +3 +7048 +464 +19 +19 +18569 +80 +18570 +19 +18571 +11762 +18572 +7964 +18573 +18574 +48 +138 +10 +18575 +736 +590 +43 +2042 +48 +17228 +590 +213 +284 +18576 +8098 +18577 +11571 +647 +764 +18578 +1559 +43 +18579 +18580 +2309 +590 +15718 +3 +3 +490 +16437 +4028 +213 +12722 +18581 +8098 +18582 +18583 +11822 +1112 +18584 +14477 +17173 +18585 +590 +10 +248 +18586 +2476 +48 +1425 +10262 +14 +4693 +18587 +5780 +18588 +18589 +15782 +378 +5438 +1847 +18590 +155 +18591 +12365 +8994 +18592 +18593 +2733 +18594 +18595 +18596 +18597 +18598 +5780 +18599 +286 +18600 +18601 +213 +14 +18602 +349 +1157 +303 +2325 +1157 +590 +123 +18603 +43 +18604 +741 +13282 +18605 +1013 +112 +11754 +9 +15683 +18606 +12987 +18607 +1157 +5438 +248 +1169 +18608 +554 +3944 +18609 +18610 +89 +43 +18611 +1018 +11762 +10930 +10262 +18612 +303 +43 +1870 +590 +1208 +48 +18613 +18614 +48 +713 +303 +349 +18615 +12621 +18616 +48 +18617 +18618 +3546 +99 +736 +43 +2026 +18619 +32 +286 +18620 +18621 +5253 +2577 +60 +590 +18622 +43 +741 +18623 +17670 +213 +43 +19 +18624 +6068 +18625 +736 +11011 +10 +222 +2577 +16437 +1912 +18626 +484 +337 +1688 +18627 +2029 +201 +669 +8351 +43 +18628 +18629 +741 +43 +18630 +583 +11963 +32 +18631 +10727 +11330 +3546 +2859 +3546 +16437 +18632 +48 +43 +57 +18633 +18634 +931 +736 +11537 +2694 +18635 +10 +13167 +18636 +9945 +1723 +11762 +43 +18637 +736 +5837 +18638 +123 +19 +18639 +18640 +14 +18641 +18642 +18643 +3546 +43 +155 +48 +3543 +18644 +11762 +7137 +14 +11364 +14886 +736 +18645 +14 +590 +18646 +18647 +12225 +8103 +18648 +18649 +201 +18650 +15 +22 +18651 +32 +18652 +14 +2281 +10028 +1961 +2577 +16180 +18653 +12661 +213 +152 +15718 +19 +18654 +9 +18655 +18656 +9 +43 +1310 +13150 +16637 +18657 +18658 +16117 +48 +1384 +48 +18659 +18660 +18661 +1112 +18662 +18663 +9 +43 +18664 +248 +18665 +1513 +18666 +590 +17557 +48 +651 +349 +201 +6950 +43 +18667 +48 +415 +32 +18668 +3 +533 +48 +5243 +43 +14 +1533 +18669 +764 +722 +1437 +18670 +18671 +12746 +43 +11483 +16981 +18672 +1907 +18673 +18674 +18675 +349 +19 +590 +590 +18676 +18677 +1612 +861 +14604 +2764 +80 +323 +18678 +349 +989 +18679 +19 +18680 +43 +1648 +4477 +18681 +18682 +43 +4364 +18683 +8992 +18684 +533 +18685 +286 +18686 +32 +18687 +201 +10 +269 +43 +736 +43 +7137 +18688 +18689 +1529 +48 +18690 +18691 +1749 +19 +1232 +48 +9 +15720 +18692 +2728 +18693 +1356 +18694 +57 +18695 +4028 +18696 +18697 +18698 +14477 +823 +14520 +48 +18699 +18700 +14771 +48 +8566 +18701 +14 +32 +8249 +155 +10028 +18702 +10 +272 +18703 +11321 +8280 +3546 +9 +48 +18695 +20 +12600 +18704 +519 +43 +3548 +48 +590 +278 +17859 +14 +16437 +4055 +16089 +18705 +18706 +1234 +2318 +2944 +736 +590 +741 +14515 +3408 +3 +48 +18707 +590 +590 +12304 +16925 +14363 +18708 +32 +34 +590 +248 +590 +18709 +43 +337 +1696 +8218 +2140 +15718 +1100 +18710 +3484 +18711 +18712 +286 +19 +647 +18713 +2672 +13228 +1889 +2724 +9 +8188 +15216 +14335 +2694 +18714 +12987 +15724 +590 +3546 +18715 +15 +18716 +6877 +57 +6952 +43 +18717 +18718 +18719 +1902 +48 +4364 +9 +1224 +18720 +48 +18721 +48 +48 +18722 +122 +14604 +18723 +4212 +286 +188 +5780 +32 +2672 +6950 +18724 +43 +14363 +18725 +12913 +57 +823 +1082 +18726 +18727 +18728 +141 +1605 +373 +2577 +2577 +18729 +1810 +18730 +18731 +6214 +18732 +43 +22 +4803 +18733 +736 +6463 +80 +18734 +48 +18735 +18736 +18737 +48 +18738 +18739 +305 +8297 +43 +2040 +5426 +3546 +590 +815 +5599 +823 +17571 +18740 +12832 +272 +18741 +18742 +464 +18743 +18744 +286 +43 +286 +18745 +5908 +18746 +3 +18747 +11754 +3 +43 +3553 +18748 +349 +18749 +1011 +18750 +43 +3155 +20 +18751 +48 +554 +48 +5627 +242 +48 +18752 +14567 +18753 +4907 +48 +14 +43 +15989 +1245 +43 +2919 +14 +14 +18754 +713 +18755 +18756 +18757 +18758 +18759 +1115 +349 +6877 +80 +349 +12003 +3546 +43 +18760 +18761 +616 +18762 +43 +14477 +1612 +43 +1091 +590 +22 +1244 +323 +18763 +2202 +43 +18764 +12013 +18765 +18766 +15718 +18767 +4278 +43 +887 +5316 +349 +3546 +9 +18768 +764 +4116 +14 +3546 +533 +18769 +20 +352 +18770 +152 +48 +590 +323 +57 +18771 +15541 +22 +18772 +18773 +18774 +18775 +2939 +647 +48 +18776 +18777 +12120 +915 +32 +1615 +11013 +2314 +18778 +48 +6916 +590 +12120 +43 +18779 +11754 +155 +15718 +842 +1604 +18780 +48 +18781 +14 +201 +18782 +741 +48 +43 +18783 +349 +18784 +43 +18785 +5780 +18786 +48 +16881 +9 +16909 +590 +13599 +48 +18787 +2260 +741 +9 +5780 +18788 +1169 +3543 +1013 +741 +1051 +142 +18789 +18345 +8512 +845 +18790 +4814 +18791 +3391 +43 +18792 +48 +286 +48 +48 +18793 +14 +18794 +1912 +250 +18795 +349 +43 +43 +18796 +1559 +18797 +20 +357 +3476 +14001 +590 +15718 +18798 +18799 +43 +18800 +18801 +77 +665 +14 +48 +823 +188 +20 +43 +2430 +2325 +586 +18802 +411 +272 +2806 +18803 +57 +791 +13961 +14 +18804 +18805 +791 +18806 +1765 +590 +18807 +18808 +18809 +1181 +48 +7053 +18810 +201 +14 +3546 +823 +137 +18811 +14162 +155 +43 +4155 +5438 +16383 +3334 +13570 +18045 +18812 +16303 +18813 +823 +20 +43 +9 +318 +14 +590 +18814 +138 +17228 +399 +18815 +887 +349 +43 +821 +16437 +18816 +9543 +590 +18045 +222 +7215 +15384 +137 +2879 +18817 +286 +4963 +514 +349 +18818 +590 +6883 +6950 +2410 +14001 +3546 +32 +19 +43 +13656 +3252 +18819 +1560 +2561 +18037 +19 +9 +188 +764 +48 +32 +15054 +18820 +14477 +14 +647 +16234 +8668 +14603 +1226 +15442 +14 +9 +2577 +18821 +1232 +1425 +6987 +18822 +32 +18823 +43 +48 +3239 +286 +18824 +12987 +3078 +3543 +14 +19 +3546 +18825 +43 +14 +12402 +14477 +14 +48 +18826 +14240 +18827 +48 +18828 +12936 +18553 +18829 +18830 +18831 +736 +17508 +14 +13929 +18832 +43 +43 +349 +18833 +18834 +514 +764 +18835 +2577 +2260 +590 +32 +18836 +13710 +19 +18837 +15718 +18838 +17326 +43 +18839 +18840 +736 +590 +5780 +2129 +18841 +9543 +18842 +14001 +4313 +6950 +9784 +736 +18843 +18844 +736 +18597 +14 +590 +18845 +18846 +18847 +1743 +57 +12404 +48 +48 +18848 +11822 +12792 +18849 +18850 +1716 +11787 +4752 +5908 +16205 +19 +18851 +671 +112 +11593 +18852 +9254 +1559 +249 +18853 +18854 +5161 +18855 +301 +5966 +14203 +15398 +282 +3546 +590 +18856 +18857 +647 +1013 +2865 +18858 +18859 +14 +43 +365 +18860 +15572 +9 +15058 +18861 +48 +3546 +5780 +12479 +15718 +201 +18862 +2 +48 +6950 +18863 +1115 +590 +647 +22 +590 +1955 +18864 +18865 +18866 +9 +2042 +12308 +590 +595 +48 +18867 +18868 +48 +57 +18869 +18870 +48 +18871 +43 +9 +8253 +14477 +14603 +48 +18872 +18873 +665 +590 +16591 +17515 +18874 +736 +1300 +18875 +18876 +48 +15718 +18877 +43 +14 +16 +590 +42 +2896 +60 +3440 +18878 +112 +1149 +9 +349 +18879 +2023 +1612 +18880 +14 +7053 +2537 +18881 +2197 +43 +16437 +208 +18882 +18883 +2260 +18524 +7935 +48 +1566 +9 +3543 +18884 +18885 +43 +18886 +18887 +12987 +53 +18888 +15718 +5438 +1011 +43 +1674 +18889 +19 +18890 +738 +18891 +18892 +188 +18893 +14 +18894 +209 +18895 +57 +349 +18896 +18897 +43 +272 +9396 +10960 +43 +18898 +4414 +18899 +5920 +5188 +349 +18900 +18901 +536 +18902 +20 +18903 +43 +18904 +155 +18905 +18906 +10 +15718 +5169 +349 +19 +2274 +554 +5650 +9125 +1172 +2117 +12560 +397 +1559 +18907 +18908 +18909 +16788 +2372 +770 +590 +43 +1100 +13466 +18910 +323 +18911 +18912 +14 +18913 +9 +18914 +286 +16436 +1169 +18429 +155 +12661 +89 +18915 +8297 +11754 +2471 +3519 +15583 +18916 +323 +349 +18917 +18918 +18919 +11335 +18920 +18921 +1765 +590 +18922 +18923 +48 +3546 +18924 +14 +590 +43 +3 +18925 +3546 +18695 +18926 +17174 +1637 +18927 +18928 +3546 +3 +18929 +48 +7183 +48 +18930 +18931 +17571 +1442 +18932 +3353 +2253 +16981 +15989 +3958 +18933 +15054 +18934 +14 +2733 +43 +18935 +18936 +18937 +43 +18938 +18939 +9 +548 +18940 +18941 +14 +590 +43 +736 +736 +32 +43 +18942 +43 +48 +736 +770 +1100 +4616 +6877 +16437 +43 +3546 +2 +7117 +48 +15718 +590 +18943 +15907 +590 +3440 +590 +18944 +18945 +18946 +8668 +18947 +29 +19 +14 +18948 +3353 +989 +286 +20 +14 +18949 +18950 +2314 +6958 +18951 +616 +14477 +2728 +18952 +43 +18953 +18954 +1217 +18955 +9339 +43 +741 +18956 +14477 +18957 +7703 +18958 +14843 +284 +9 +18959 +370 +18960 +736 +18961 +2320 +323 +43 +18962 +2577 +48 +18963 +18964 +9 +115 +18965 +15718 +18966 +892 +9 +5791 +18967 +15026 +1950 +648 +2733 +18159 +3546 +18968 +18969 +19 +18970 +18971 +18972 +2697 +18973 +590 +77 +18974 +13205 +14 +12404 +155 +5217 +30 +284 +590 +18975 +18976 +35 +5755 +9 +842 +18977 +10 +13361 +18978 +7521 +7233 +1992 +15 +18979 +14666 +32 +590 +43 +17144 +286 +18980 +11754 +18981 +2035 +43 +18695 +18982 +14363 +6518 +18983 +11762 +43 +18984 +18985 +15068 +18986 +18987 +19 +616 +1291 +590 +1232 +10 +18988 +18989 +18990 +222 +268 +18991 +18992 +18993 +17 +303 +7053 +14 +19 +573 +2694 +25 +18980 +18994 +18995 +19 +18996 +18997 +248 +18998 +18999 +213 +2040 +12185 +48 +19000 +1562 +9465 +48 +43 +6499 +19001 +11754 +34 +19002 +9 +6915 +43 +39 +19003 +13529 +9 +707 +19004 +2 +3546 +248 +14604 +19005 +590 +17571 +1870 +3196 +4388 +6543 +22 +48 +9 +19006 +19007 +48 +19008 +155 +48 +19009 +19010 +19011 +3546 +19012 +196 +677 +22 +18695 +19013 +379 +10789 +19014 +19015 +10 +19016 +17177 +989 +19 +13848 +43 +19017 +19018 +77 +57 +19019 +19020 +155 +19021 +5469 +554 +3 +590 +48 +19022 +19023 +48 +590 +284 +1765 +201 +19024 +14 +19025 +19026 +1992 +43 +142 +3059 +6258 +19027 +3546 +19028 +19029 +15 +19030 +213 +1011 +1956 +19031 +43 +188 +188 +15718 +1013 +3926 +751 +533 +14 +7137 +2311 +11754 +19032 +677 +736 +590 +18695 +19033 +379 +19034 +15308 +19035 +19036 +43 +29 +43 +590 +48 +48 +25 +19 +14 +15 +3546 +19037 +13430 +8566 +19038 +3491 +19039 +19040 +9 +8392 +951 +1765 +286 +19041 +19042 +43 +19043 +9 +19044 +43 +694 +13375 +19045 +19046 +14 +19009 +16560 +2733 +19047 +303 +48 +5780 +5780 +5004 +736 +1738 +19048 +536 +19049 +14 +43 +1232 +1529 +48 +19050 +43 +1364 +8668 +48 +15 +19051 +533 +2398 +10 +19052 +17136 +19053 +1181 +19054 +19055 +14001 +15 +19056 +590 +2744 +8351 +19057 +19058 +19059 +19 +303 +5963 +3553 +19060 +48 +2 +19061 +14 +19062 +2019 +19063 +646 +19064 +19065 +3546 +3546 +284 +16 +14 +647 +9144 +770 +12397 +500 +590 +19066 +18045 +5662 +19067 +1434 +19068 +1100 +11762 +19069 +16437 +11283 +1559 +10933 +17801 +3407 +1765 +207 +43 +19070 +3411 +1217 +4803 +19071 +358 +2316 +43 +17871 +590 +19072 +13361 +1049 +19073 +19074 +15718 +19075 +9994 +590 +272 +590 +720 +14 +10 +10 +19076 +19077 +19 +272 +16092 +32 +15718 +19078 +3546 +19079 +19080 +19081 +15718 +9462 +741 +48 +19082 +1961 +16437 +19083 +284 +48 +19084 +19085 +19086 +19087 +155 +19088 +34 +372 +19089 +43 +19090 +57 +16205 +19091 +48 +303 +2019 +14477 +9688 +48 +10 +13361 +19092 +19093 +11822 +19094 +17136 +43 +9 +17653 +272 +48 +349 +209 +19095 +19096 +14477 +19097 +9 +43 +3239 +14 +14 +34 +10 +536 +19098 +19099 +646 +10094 +66 +5601 +7183 +19100 +57 +19101 +7752 +248 +7053 +19102 +112 +19103 +19104 +19 +9 +196 +155 +1051 +11971 +57 +17380 +1481 +43 +19105 +3546 +43 +7032 +43 +815 +19106 +817 +720 +98 +284 +1112 +1013 +19107 +48 +764 +19108 +1232 +20 +112 +19109 +19110 +671 +1745 +9 +19111 +19112 +14 +11321 +303 +19113 +464 +12260 +349 +19114 +201 +24 +2593 +1617 +43 +17698 +19115 +15718 +1559 +43 +179 +15718 +19116 +337 +736 +19117 +16437 +5579 +19118 +19119 +2865 +18896 +19120 +19121 +3353 +915 +554 +2476 +12746 +648 +188 +19122 +19123 +19124 +1223 +19125 +16437 +1562 +17868 +590 +1885 +19126 +1513 +936 +14025 +7053 +272 +19127 +188 +19128 +19046 +990 +736 +43 +19129 +647 +15 +15718 +18951 +19130 +19131 +536 +19132 +19133 +13648 +19134 +19135 +43 +19136 +19137 +19138 +19139 +8249 +19140 +590 +43 +179 +196 +43 +18869 +2430 +19141 +19142 +11321 +19143 +18325 +43 +43 +19144 +3546 +48 +3484 +19145 +284 +1869 +19146 +2577 +736 +2790 +32 +379 +19147 +2042 +19148 +683 +19149 +18940 +448 +15718 +19150 +474 +19151 +590 +32 +19152 +57 +3546 +19153 +823 +17752 +19154 +32 +1310 +19 +43 +43 +19155 +832 +19156 +19157 +19158 +2944 +2694 +19159 +19160 +6766 +32 +590 +43 +3546 +57 +19161 +19162 +19163 +104 +12987 +18334 +19164 +1710 +554 +19165 +11762 +43 +590 +19166 +8553 +43 +19167 +19168 +19 +6950 +1012 +43 +77 +1048 +284 +5391 +19169 +4803 +19170 +2 +286 +5217 +20 +48 +14 +19171 +2197 +741 +19172 +1385 +7137 +19173 +48 +5780 +3546 +43 +43 +284 +19174 +19 +590 +48 +43 +43 +1332 +8668 +19175 +19176 +14189 +19177 +15718 +43 +2694 +1852 +19178 +19179 +720 +6317 +284 +1562 +19180 +1637 +3875 +19181 +845 +43 +590 +349 +9 +7053 +337 +19182 +19 +303 +19183 +19184 +19185 +14363 +1012 +48 +613 +9 +19 +14477 +5344 +19186 +19187 +736 +286 +3546 +1082 +646 +142 +43 +19188 +6250 +155 +13955 +5780 +43 +3544 +683 +1972 +1559 +32 +13375 +3546 +19189 +19190 +12 +155 +19191 +19192 +12158 +2187 +19193 +19 +19194 +11697 +19195 +19196 +590 +1797 +915 +6994 +19197 +3067 +19 +14477 +3095 +4907 +43 +19198 +48 +9 +43 +736 +18928 +48 +19199 +18120 +17698 +20 +80 +104 +19 +3034 +19200 +48 +3 +14215 +19201 +5791 +19202 +18045 +43 +19203 +5204 +19204 +43 +10 +9 +19 +590 +707 +19205 +822 +17920 +19206 +741 +7137 +19207 +14477 +19208 +19209 +19210 +14 +19211 +590 +48 +8249 +19212 +19213 +590 +43 +2329 +48 +10381 +3906 +14 +1920 +19 +197 +19214 +14240 +4166 +17173 +8351 +19215 +377 +19216 +3546 +1823 +9 +14 +14 +18982 +19217 +48 +18695 +5041 +647 +19218 +19 +19219 +554 +3546 +11762 +249 +19 +19220 +19221 +43 +9 +11321 +19222 +19223 +764 +358 +12158 +19224 +48 +19225 +19226 +32 +43 +15718 +9 +19227 +48 +14066 +842 +590 +533 +43 +15001 +286 +19228 +19229 +14515 +411 +19230 +8668 +19231 +19232 +15718 +1559 +286 +155 +48 +48 +16349 +48 +19233 +19234 +19235 +18980 +590 +19236 +11754 +19237 +8807 +1384 +1605 +16437 +573 +38 +17206 +19238 +554 +57 +43 +19239 +3981 +573 +19240 +48 +1425 +19241 +3546 +19242 +43 +43 +19243 +19244 +19245 +48 +19246 +43 +32 +12807 +286 +2314 +590 +1765 +43 +1425 +7747 +19247 +19248 +1232 +19 +43 +5148 +19249 +286 +590 +5344 +19250 +9913 +1107 +736 +43 +13140 +646 +736 +19251 +15123 +19252 +16437 +2804 +4028 +104 +209 +22 +19253 +5780 +7137 +19254 +32 +19255 +5601 +9 +43 +14 +43 +19256 +7053 +19 +15718 +19257 +19258 +349 +43 +155 +155 +19259 +665 +19260 +155 +5623 +43 +3 +14 +19261 +19228 +14435 +19262 +19263 +19264 +1109 +179 +736 +14 +828 +43 +15649 +4634 +14 +19265 +15 +590 +201 +9 +736 +29 +155 +15718 +18980 +1082 +19266 +32 +19267 +20 +155 +14604 +19268 +9 +14957 +9 +19269 +590 +19270 +13807 +2577 +809 +286 +43 +176 +32 +736 +286 +12497 +19271 +43 +19272 +14 +1817 +736 +19273 +18869 +19274 +6143 +720 +33 +6531 +2 +48 +590 +17144 +19275 +19276 +1224 +1217 +155 +554 +677 +590 +14001 +18695 +14604 +5780 +19277 +669 +43 +590 +19278 +647 +14 +14 +683 +3 +9 +2721 +647 +43 +17093 +43 +80 +19279 +19280 +43 +6513 +19281 +1896 +140 +12987 +8131 +16951 +1961 +19282 +3484 +19283 +5808 +206 +19284 +647 +338 +43 +19285 +14 +764 +2187 +46 +3546 +1765 +197 +19286 +18300 +15718 +43 +1765 +19287 +17670 +1224 +19288 +19289 +590 +554 +19290 +43 +14477 +8244 +1668 +19291 +3376 +19292 +19293 +4388 +19294 +14 +19 +32 +590 +1376 +19295 +2287 +317 +48 +48 +19296 +14 +15718 +412 +19297 +43 +19298 +57 +19299 +5780 +19300 +13569 +19301 +19302 +19303 +19304 +1870 +43 +14 +5780 +43 +349 +43 +10592 +43 +272 +2 +228 +317 +19305 +2042 +286 +6877 +2463 +822 +19306 +5627 +19307 +19308 +590 +19309 +7053 +19310 +19 +590 +272 +2988 +736 +671 +16437 +48 +1991 +19311 +16437 +20 +19312 +15718 +14 +14916 +9400 +19313 +7053 +14 +13973 +1224 +8668 +286 +9 +4684 +14102 +4387 +16589 +590 +286 +19314 +1154 +19315 +225 +741 +1364 +2287 +19316 +19317 +4234 +14 +19318 +3546 +1352 +43 +46 +17571 +1352 +2064 +14 +15718 +1991 +19319 +19320 +43 +5391 +5168 +5780 +43 +43 +10 +19321 +1927 +19322 +533 +19323 +1559 +19324 +9 +19325 +12185 +38 +19 +19326 +590 +19327 +19328 +19329 +19330 +19331 +4053 +19332 +19333 +19334 +38 +15718 +29 +5007 +43 +43 +19335 +514 +14 +48 +112 +6766 +8566 +1543 +19336 +12987 +6950 +32 +19337 +19338 +272 +11762 +48 +48 +140 +18969 +14 +2724 +7208 +554 +48 +14 +2197 +19339 +19340 +19341 +14 +1107 +43 +286 +57 +15718 +19342 +19343 +19344 +1612 +14660 +48 +14 +14 +19345 +14962 +9 +19346 +14477 +19347 +19348 +43 +19349 +19350 +14 +19351 +19352 +19353 +2770 +616 +19354 +823 +19355 +19356 +736 +13943 +19357 +3546 +19358 +2287 +19359 +19360 +2865 +586 +5780 +20 +43 +48 +19361 +1524 +9 +590 +19362 +15718 +237 +19363 +155 +18846 +19364 +354 +415 +17112 +491 +19365 +397 +7253 +43 +19366 +8668 +9400 +19367 +43 +4963 +14477 +12923 +13566 +3421 +683 +43 +19368 +16012 +19369 +43 +19370 +112 +19371 +104 +1100 +19372 +19373 +43 +1696 +18954 +7053 +19374 +155 +493 +19 +1989 +43 +590 +3213 +43 +349 +349 +495 +19375 +9 +19376 +19377 +19378 +19 +15 +13532 +19379 +19380 +19381 +4 +43 +19382 +19383 +152 +19384 +19199 +17042 +48 +19385 +18299 +18982 +17602 +19386 +1012 +286 +12987 +48 +19387 +1886 +43 +237 +19388 +823 +19389 +12462 +43 +19390 +1920 +7053 +14 +19391 +2577 +19392 +14 +8508 +19393 +18951 +19394 +15718 +17027 +15 +19395 +2 +13769 +1232 +14689 +43 +19396 +322 +270 +19397 +36 +10500 +19398 +13807 +14 +13656 +16437 +2314 +19399 +14 +14527 +19400 +19401 +19402 +14 +43 +2446 +19 +6776 +597 +19403 +14884 +19404 +19405 +48 +590 +48 +19406 +745 +8218 +19407 +1655 +19408 +138 +736 +12907 +19409 +19410 +19411 +19 +43 +14102 +18045 +43 +2042 +19412 +514 +19413 +43 +16180 +8220 +19414 +19415 +15718 +398 +19416 +4963 +155 +2260 +15 +19417 +19418 +2197 +32 +18448 +43 +233 +18846 +1232 +19419 +19420 +19421 +14477 +19422 +43 +3875 +2035 +19423 +3546 +19424 +19425 +57 +14 +16240 +720 +6054 +43 +590 +14 +57 +19426 +34 +43 +2 +43 +19427 +14856 +19 +19 +8444 +38 +13182 +48 +89 +554 +19428 +14477 +19404 +19429 +19430 +14 +2577 +5088 +250 +1116 +3546 +19431 +188 +590 +9 +43 +19432 +43 +19404 +4918 +1051 +6341 +11210 +19433 +19434 +19435 +18045 +43 +5827 +19436 +536 +43 +720 +19437 +764 +19438 +286 +9396 +19439 +14599 +9024 +19 +5780 +14 +15 +14 +19440 +12807 +17608 +201 +48 +185 +19441 +9039 +12647 +155 +1976 +43 +19 +19442 +176 +823 +349 +3546 +15718 +14 +7117 +14363 +4963 +43 +19443 +583 +671 +16681 +299 +18695 +19444 +3569 +19445 +8668 +5217 +6766 +19446 +19447 +3553 +19448 +590 +140 +8668 +8855 +19167 +736 +10356 +15718 +15 +19449 +19450 +19451 +741 +43 +19452 +2882 +19453 +15718 +19454 +416 +19455 +19 +43 +19 +19456 +19457 +6400 +19458 +32 +3297 +18869 +19459 +6249 +8787 +12987 +19460 +1790 +43 +1051 +15975 +19461 +19462 +112 +720 +11963 +7053 +6766 +17508 +3546 +2 +19463 +19404 +1251 +19 +164 +1889 +19464 +823 +4803 +590 +2 +590 +19465 +8668 +736 +57 +11483 +19466 +19467 +43 +3484 +590 +2 +9 +19468 +188 +19469 +19470 +1912 +590 +12987 +43 +2577 +9 +3546 +140 +19471 +19472 +19473 +19474 +19475 +13361 +155 +48 +823 +16640 +22 +22 +478 +19476 +19477 +11646 +17043 +19478 +18980 +1091 +19479 +19480 +14603 +741 +2117 +554 +1444 +1120 +14604 +98 +11158 +19481 +11754 +43 +19482 +155 +155 +9 +19483 +19484 +19485 +53 +19486 +19487 +17281 +19488 +19489 +1817 +19490 +19491 +19492 +3546 +19493 +15718 +19494 +597 +43 +14804 +2 +2561 +6468 +19495 +19496 +13848 +19497 +590 +43 +43 +15718 +19105 +809 +2983 +57 +19498 +19499 +19500 +19501 +1798 +43 +19502 +707 +18163 +14 +18980 +14604 +11301 +43 +19503 +19504 +19505 +19 +17433 +43 +2121 +590 +19506 +6776 +19507 +15718 +19508 +19404 +19509 +9 +19510 +19511 +1011 +349 +16085 +15718 +7053 +17799 +13663 +14477 +464 +19512 +286 +57 +8392 +19513 +861 +249 +17730 +19514 +1559 +19 +8041 +19515 +8460 +43 +9259 +5208 +19516 +8367 +11428 +57 +19517 +15718 +14 +19518 +1912 +18695 +5298 +13954 +19519 +43 +590 +17635 +19520 +13375 +491 +43 +19521 +43 +5780 +14 +19522 +19523 +19524 +1578 +1542 +590 +286 +18695 +14 +4050 +5780 +19525 +16387 +19526 +19527 +43 +823 +590 +57 +9688 +43 +18982 +19 +10 +1021 +57 +14770 +18503 +19 +1561 +554 +14467 +10500 +2040 +19528 +616 +745 +19529 +43 +11754 +19530 +19531 +590 +43 +19532 +17972 +19 +514 +9 +43 +4803 +9 +13798 +209 +17314 +1524 +48 +43 +349 +43 +1244 +43 +19533 +19534 +19535 +137 +370 +958 +19536 +2 +3034 +16092 +19537 +19538 +188 +10 +13150 +590 +19539 +464 +8188 +15324 +590 +14 +373 +3484 +10287 +19540 +3030 +19541 +4907 +43 +138 +19542 +590 +19543 +354 +15572 +1817 +8895 +19 +18980 +19544 +19545 +19 +19546 +590 +19547 +196 +19 +19548 +197 +7855 +15 +19549 +613 +8668 +19550 +19551 +625 +19552 +14 +8220 +43 +18951 +8110 +4963 +1765 +4963 +19553 +736 +155 +19554 +19555 +2415 +20 +2804 +590 +19556 +32 +16118 +16283 +13915 +2406 +19557 +19558 +493 +19559 +13361 +19560 +43 +19404 +19561 +19562 +5561 +43 +22 +590 +736 +19563 +349 +19564 +43 +155 +43 +3876 +1481 +1100 +19565 +398 +19566 +715 +1471 +3546 +1710 +19567 +15874 +6950 +19568 +19569 +14 +590 +19570 +3251 +19571 +14843 +19572 +514 +112 +9 +19573 +15718 +19 +19 +155 +11593 +16437 +249 +19574 +42 +301 +43 +6086 +9 +590 +971 +3546 +19575 +809 +19576 +536 +19577 +1810 +19578 +3546 +349 +7053 +4028 +590 +5314 +3417 +736 +14 +19 +43 +14843 +8392 +14527 +15 +17342 +2624 +19579 +19580 +3492 +342 +122 +19581 +43 +19582 +5489 +43 +493 +43 +2561 +43 +19583 +19584 +19585 +19586 +19587 +15989 +43 +1112 +3546 +590 +19588 +4 +9 +2733 +19199 +19 +19589 +19590 +590 +19591 +19592 +3546 +48 +19593 +19 +1648 +339 +3546 +19594 +57 +19404 +19595 +590 +19596 +38 +19597 +19598 +741 +3546 +19599 +16329 +25 +18577 +1470 +15718 +5207 +19600 +5415 +43 +5780 +1502 +43 +590 +19601 +14477 +1481 +196 +19602 +43 +43 +1765 +4806 +15718 +9 +8668 +43 +12953 +19603 +19604 +19605 +827 +4821 +19606 +19607 +19335 +8668 +19608 +19609 +3944 +14 +19610 +19404 +19611 +548 +12777 +4411 +19612 +43 +19 +3546 +19 +6837 +19404 +43 +14477 +2 +19613 +19614 +541 +15 +590 +19615 +590 +4084 +19616 +89 +20 +19304 +35 +19617 +20 +19618 +14 +14 +8297 +1961 +647 +15718 +770 +5780 +19619 +19 +13466 +19620 +19 +365 +15718 +14477 +10 +19621 +19 +19622 +43 +6122 +2006 +736 +19623 +16437 +19624 +2035 +113 +155 +2260 +18774 +19625 +2260 +57 +13205 +284 +10 +19626 +19627 +590 +19628 +1295 +5780 +89 +358 +8392 +19618 +19629 +164 +19630 +19631 +16527 +89 +1232 +19 +5371 +19632 +19633 +19634 +15718 +9 +12987 +2859 +18695 +1688 +7110 +43 +1300 +19635 +14 +590 +15669 +1013 +19 +6883 +19 +48 +19 +13279 +19636 +43 +19637 +18742 +98 +17919 +2804 +43 +7377 +14 +57 +292 +19638 +43 +590 +19639 +43 +1604 +303 +19640 +15220 +19641 +14527 +736 +19642 +19643 +17032 +43 +286 +19644 +3519 +10899 +286 +19404 +137 +19056 +19618 +19645 +19646 +16437 +14240 +18100 +19647 +19648 +19649 +19650 +19651 +19652 +2672 +9567 +19653 +19404 +16866 +19654 +5169 +19655 +19656 +590 +134 +1870 +11762 +32 +349 +19657 +248 +248 +590 +1517 +19658 +2577 +337 +19659 +5211 +1765 +19660 +1768 +4905 +19661 +1696 +590 +3546 +19662 +3488 +19663 +1385 +14477 +736 +19664 +43 +19665 +533 +8355 +1901 +8244 +18980 +43 +3330 +18982 +12245 +15718 +13566 +446 +19666 +8853 +349 +284 +590 +7053 +337 +15737 +19667 +13465 +707 +14 +590 +1961 +15881 +19668 +373 +188 +14175 +352 +17941 +155 +19669 +43 +19670 +7328 +4722 +590 +1442 +349 +19432 +19671 +286 +9163 +357 +19672 +18045 +19673 +14477 +14 +9 +2197 +9 +19674 +9 +19675 +19676 +19677 +19678 +3546 +5188 +2029 +249 +8255 +3559 +349 +3546 +43 +16092 +19679 +17698 +337 +19680 +19 +14 +590 +590 +1104 +248 +19681 +19618 +19682 +9474 +19683 +19684 +15 +19685 +10 +533 +15054 +3546 +1228 +1606 +8953 +19686 +15 +7137 +15718 +11762 +303 +764 +823 +19687 +15924 +7137 +19688 +19689 +736 +823 +155 +19690 +3353 +19691 +19692 +17085 +19693 +3330 +3546 +286 +19694 +3546 +43 +209 +15 +590 +19695 +19696 +19697 +19698 +19699 +19 +337 +43 +19700 +19701 +704 +19702 +2593 +43 +57 +16102 +19703 +19704 +14342 +14660 +1605 +590 +19705 +19706 +19707 +19708 +19709 +19 +1090 +19710 +19 +43 +4684 +10 +32 +286 +7137 +152 +10356 +19711 +2051 +19712 +9 +317 +286 +2762 +20 +1310 +3546 +14 +2042 +57 +19713 +19714 +1112 +17608 +19715 +18982 +2593 +155 +14477 +16981 +3 +19 +2412 +19716 +19717 +24 +1955 +19718 +14185 +43 +6058 +19719 +19720 +590 +32 +19 +16866 +19721 +19722 +2356 +9400 +19655 +19723 +19724 +14369 +6095 +590 +736 +14 +43 +5267 +38 +707 +19725 +155 +8716 +155 +19726 +19727 +213 +19728 +19729 +665 +4793 +43 +7053 +18980 +590 +19730 +19731 +19732 +15718 +736 +286 +2804 +286 +19733 +19734 +286 +533 +19735 +19736 +19737 +19738 +9 +19739 +2310 +14527 +19655 +155 +1018 +43 +19740 +15 +2009 +19741 +9 +373 +286 +14477 +19199 +14 +12534 +19 +19742 +19743 +112 +2804 +2 +14477 +42 +19744 +491 +15718 +7053 +448 +137 +770 +1513 +590 +15718 +19745 +284 +6595 +22 +14 +19746 +19747 +19748 +19749 +484 +11970 +43 +19750 +5267 +19 +19751 +13343 +2314 +57 +19097 +19752 +18980 +91 +19753 +19754 +19755 +284 +1131 +19756 +19370 +19 +3546 +213 +16437 +9 +19757 +43 +19758 +822 +42 +19759 +43 +5410 +19760 +76 +3546 +16437 +15647 +19761 +43 +15718 +19762 +1514 +43 +272 +19763 +19764 +3275 +1710 +19765 +7053 +19766 +19092 +43 +3472 +11762 +19655 +19767 +19768 +19769 +6518 +16437 +8610 +19 +4411 +19770 +43 +19771 +19772 +19773 +188 +57 +8849 +8392 +249 +286 +1559 +9 +15384 +19774 +137 +15718 +19775 +3546 +35 +19776 +19777 +142 +19618 +3546 +19618 +43 +286 +3546 +590 +7291 +19778 +554 +3546 +14 +19779 +5080 +1812 +19 +590 +19780 +19781 +112 +1961 +9184 +3546 +9402 +18045 +9102 +6565 +971 +142 +7053 +12363 +377 +19618 +379 +19782 +19783 +19784 +10527 +9 +19785 +19786 +19 +16826 +19787 +19655 +16437 +15649 +19788 +1920 +19789 +19618 +6766 +13282 +12067 +19790 +19791 +3546 +3995 +19 +19618 +16272 +18321 +43 +14604 +13841 +188 +19792 +647 +19793 +19794 +590 +19795 +19796 +19797 +6504 +19798 +14 +14 +3546 +19799 +683 +10311 +1364 +464 +19800 +1765 +317 +5780 +201 +554 +7137 +19801 +19792 +15989 +19802 +19803 +1226 +19804 +19805 +823 +19806 +19807 +827 +1559 +19808 +349 +1013 +19809 +3310 +19810 +36 +19811 +19792 +19812 +19813 +705 +43 +19 +590 +19814 +6950 +1514 +13985 +19815 +18176 +57 +32 +10946 +19816 +8351 +17865 +19404 +19817 +19 +19818 +286 +9 +305 +19819 +4487 +284 +823 +155 +989 +5101 +590 +11483 +19820 +8721 +303 +7855 +213 +19821 +9 +248 +1513 +188 +43 +19822 +213 +411 +14 +4502 +19823 +6877 +337 +249 +34 +14 +19824 +19825 +19826 +20 +19827 +377 +16126 +14 +19828 +20 +19829 +303 +861 +284 +20 +13150 +1428 +213 +3546 +19830 +19831 +12101 +286 +14604 +248 +5780 +19832 +15718 +3353 +1011 +564 +19833 +303 +1425 +19655 +8392 +15886 +19834 +14 +19835 +3546 +19836 +6335 +5780 +4274 +3050 +19837 +10 +16437 +19618 +19838 +20 +15718 +19839 +736 +43 +19840 +4174 +14 +379 +2314 +7053 +19841 +19218 +2694 +15718 +1224 +286 +19806 +152 +9 +517 +18695 +19842 +19843 +1310 +8351 +2029 +19618 +19 +5780 +14477 +2006 +48 +9245 +19844 +14477 +14 +19618 +1560 +19845 +19846 +19042 +19847 +16437 +19848 +1924 +19849 +29 +19850 +19851 +19806 +2164 +57 +3790 +188 +1444 +8444 +349 +1502 +18120 +18695 +19 +19852 +286 +19853 +248 +958 +286 +19854 +14483 +19855 +19856 +19857 +16826 +19858 +720 +19 +19859 +13150 +13913 +14603 +19860 +14 +43 +823 +19861 +4550 +19862 +19863 +19864 +5791 +19439 +19 +590 +19865 +15 +3497 +4 +111 +57 +15718 +349 +43 +12005 +19866 +43 +4801 +554 +19867 +19491 +4406 +1090 +1386 +815 +225 +2 +5344 +19618 +19868 +14 +19 +3546 +9 +248 +18896 +19869 +155 +19870 +19871 +19872 +16024 +1234 +1369 +590 +43 +736 +19655 +2446 +7053 +19873 +19 +19874 +3491 +323 +8779 +586 +7137 +19875 +14 +19806 +16445 +19876 +43 +155 +19877 +15406 +590 +590 +3842 +19878 +19879 +8244 +19880 +19618 +19618 +10729 +19881 +13959 +32 +19882 +2 +19883 +2561 +2356 +36 +790 +14363 +19884 +19885 +861 +19886 +19887 +15718 +19806 +12807 +188 +15718 +19888 +827 +155 +4398 +19889 +989 +286 +112 +1444 +484 +7137 +19890 +827 +7053 +2234 +19 +2032 +1513 +19891 +741 +2259 +14477 +590 +590 +18695 +15285 +1083 +16190 +10381 +19892 +19893 +2040 +1013 +573 +14363 +6741 +590 +736 +19894 +3546 +19895 +14 +19896 +19897 +9 +12067 +736 +1013 +915 +19618 +790 +2849 +286 +14 +213 +5780 +5088 +19898 +1563 +323 +16466 +2117 +554 +2047 +19899 +736 +19900 +286 +1051 +15087 +33 +1083 +17320 +590 +3034 +7923 +19901 +2 +12913 +12093 +19902 +19618 +19903 +112 +1944 +16310 +4278 +14604 +19904 +5791 +19905 +19906 +16183 +43 +19907 +16437 +19908 +3491 +9 +19909 +3546 +19910 +19911 +736 +17604 +188 +3546 +11966 +32 +43 +19912 +9410 +19913 +19914 +43 +14 +19915 +7419 +19916 +112 +19917 +736 +2446 +48 +1139 +19918 +104 +43 +349 +19919 +18771 +188 +7032 +19920 +18891 +15 +1051 +6363 +19921 +3251 +18684 +1907 +19922 +823 +3427 +43 +14 +13375 +19923 +14477 +19404 +19618 +2415 +2314 +189 +5249 +398 +19924 +19925 +19926 +19927 +500 +3546 +18561 +5283 +554 +20 +1559 +35 +19928 +19929 +4634 +16437 +12247 +284 +14846 +43 +19930 +1559 +8566 +10 +13848 +15718 +140 +14770 +19931 +16121 +15592 +19932 +19933 +213 +19934 +213 +284 +19935 +19936 +14 +19 +647 +1112 +19937 +14363 +590 +19938 +10503 +19 +284 +18503 +11870 +19939 +19618 +19940 +32 +15718 +19941 +14 +349 +1559 +19942 +43 +736 +736 +19943 +3546 +99 +19646 +19618 +15718 +17698 +7260 +19944 +14 +14 +48 +18683 +19945 +970 +1566 +188 +13656 +19946 +303 +19947 +13566 +19 +4083 +15718 +19948 +1529 +19949 +19950 +19951 +119 +8566 +3635 +1157 +7053 +248 +19952 +19953 +176 +1021 +9 +4747 +19954 +303 +5623 +7987 +7208 +19 +10 +13179 +4196 +337 +1889 +19404 +19955 +19956 +19957 +2577 +19958 +19959 +2260 +19 +19960 +284 +19961 +19962 +17903 +19963 +19964 +9 +43 +276 +3 +1992 +11321 +19965 +17698 +1234 +1013 +228 +19966 +303 +14 +7137 +1244 +77 +713 +4963 +19967 +19404 +827 +19968 +11754 +15 +19969 +6741 +3546 +823 +19970 +1051 +590 +379 +19971 +19972 +19439 +19973 +745 +13282 +9 +7053 +19974 +16 +3546 +16855 +349 +1688 +19975 +671 +19976 +19289 +43 +770 +9 +19 +1517 +14 +19977 +19978 +8566 +13140 +15054 +5627 +14 +60 +1364 +19979 +13279 +19980 +597 +590 +19981 +19982 +12987 +19983 +32 +178 +12973 +19 +19984 +1236 +25 +19985 +17920 +1224 +2476 +10094 +19655 +60 +303 +14523 +6766 +19986 +19987 +15718 +19988 +8460 +140 +14143 +43 +43 +19806 +188 +19989 +19990 +9 +1051 +17774 +15384 +7836 +15 +19991 +19992 +19993 +19 +19994 +213 +5623 +12479 +19995 +98 +43 +16375 +19996 +248 +957 +19 +19997 +349 +8668 +590 +19998 +19999 +20000 +1415 +1013 +20001 +590 +15718 +19 +20002 +736 +137 +20003 +1920 +20004 +20005 +1574 +19 +16014 +1222 +7799 +14422 +20006 +19806 +286 +20007 +188 +20008 +590 +1300 +5561 +2 +303 +19404 +20009 +10003 +20010 +2577 +323 +5022 +20011 +19 +32 +19404 +17541 +20012 +4966 +7276 +5963 +20013 +590 +20014 +57 +790 +20015 +10 +20016 +20017 +827 +8685 +20018 +20019 +1229 +736 +20020 +554 +20021 +20022 +2166 +20023 +7609 +1817 +5582 +613 +14477 +20024 +57 +20025 +20026 +2694 +14020 +14 +14 +20027 +20028 +590 +9 +4227 +3172 +20029 +22 +19404 +20030 +249 +29 +1912 +20031 +20032 +43 +1765 +2764 +7855 +20033 +20034 +15080 +20035 +16831 +19404 +17661 +20036 +3546 +19655 +9 +98 +14 +651 +11483 +155 +20037 +19 +20038 +3743 +20039 +583 +4 +16437 +20040 +7053 +9 +20041 +19404 +11762 +19806 +16165 +286 +590 +19618 +6565 +2577 +20042 +15584 +19917 +20043 +3546 +16437 +20044 +43 +20045 +3546 +14977 +500 +5438 +16437 +15718 +209 +30 +20046 +20047 +20048 +4278 +20049 +536 +519 +20050 +3507 +19 +29 +20051 +22 +19381 +20052 +20053 +20054 +10381 +8668 +20055 +1013 +10310 +20056 +16866 +22 +16798 +590 +317 +20057 +1107 +20058 +16437 +13908 +1224 +20059 +80 +1870 +20060 +57 +43 +20061 +358 +14 +373 +20062 +19618 +6915 +20063 +20064 +20065 +20066 +14 +14429 +20067 +20068 +20069 +1212 +20070 +20071 +20072 +20073 +20074 +20075 +3958 +20076 +3256 +19 +20077 +3470 +20078 +201 +647 +4088 +2550 +1091 +486 +6505 +764 +38 +286 +16437 +43 +17374 +20079 +36 +20080 +20081 +20082 +20083 +20084 +19618 +554 +20085 +20086 +10028 +43 +373 +20087 +1112 +6214 +11762 +20088 +20089 +57 +936 +568 +11298 +17229 +20090 +286 +43 +3546 +16925 +20091 +1437 +20092 +20093 +3546 +20094 +597 +3698 +99 +15718 +137 +20095 +20 +20096 +1779 +7053 +19009 +9 +201 +20097 +14 +20098 +736 +20099 +20100 +20101 +823 +20 +138 +1047 +576 +11762 +15718 +43 +20102 +20103 +22 +20104 +590 +457 +10 +14603 +2770 +1107 +6395 +20105 +8668 +286 +57 +20106 +764 +3546 +20107 +20108 +19 +20109 +14 +19618 +5297 +20110 +16640 +20111 +20112 +2733 +823 +20113 +17555 +18539 +2577 +32 +42 +43 +20 +14 +20114 +20115 +7815 +1716 +590 +19 +14603 +7516 +6741 +712 +22 +20116 +16866 +43 +10356 +14 +20117 +20118 +43 +7137 +5627 +20119 +4765 +936 +915 +20120 +8218 +14 +20121 +8110 +590 +415 +18325 +7137 +11754 +201 +647 +14299 +15718 +20122 +14 +872 +20123 +20124 +19806 +11321 +16925 +9 +10 +7419 +16437 +15810 +1013 +13150 +2637 +20125 +7137 +20126 +20127 +590 +43 +11389 +20128 +1013 +3546 +736 +201 +274 +19806 +1230 +20 +18852 +15718 +19404 +4165 +19091 +10500 +9 +43 +1513 +20129 +14 +2164 +11754 +20130 +1574 +15 +1578 +15718 +835 +43 +19618 +1316 +13713 +647 +7379 +20131 +20132 +20133 +4426 +20134 +14973 +349 +1115 +5144 +57 +15718 +3 +20135 +19404 +20136 +20137 +20138 +35 +736 +19618 +764 +188 +20139 +873 +22 +411 +3236 +15718 +9738 +323 +9 +2561 +20140 +20141 +43 +9 +249 +179 +5670 +2197 +20142 +20143 +20144 +20145 +20146 +15718 +20147 +43 +14148 +20148 +11341 +15925 +20149 +19404 +1012 +2264 +15655 +1051 +1013 +20150 +19618 +20151 +15351 +20152 +1765 +20153 +20154 +14604 +20155 +20156 +20157 +19806 +201 +2517 +20158 +2349 +19 +43 +2594 +9 +20159 +19852 +19 +20160 +20161 +14 +14 +16881 +43 +14477 +590 +9 +349 +12404 +14148 +9194 +20162 +140 +665 +19404 +2 +590 +7379 +20163 +2476 +9 +3 +9713 +554 +80 +827 +5316 +739 +20164 +12620 +20165 +19 +20166 +20167 +272 +20168 +2 +536 +20169 +20170 +3546 +590 +19091 +20171 +286 +20172 +18145 +20173 +20174 +15186 +20175 +616 +3546 +590 +20176 +1249 +48 +1048 +6217 +20177 +20178 +20179 +14477 +3794 +20180 +16028 +2804 +16310 +20181 +1912 +20182 +14816 +1253 +20183 +20184 +20185 +12957 +15718 +736 +20186 +20187 +20188 +286 +4907 +19792 +8809 +20189 +2577 +14 +20190 +1012 +80 +11976 +2884 +6058 +19618 +67 +4313 +823 +2 +9 +13566 +358 +43 +43 +1082 +1425 +20 +20191 +1542 +20192 +1148 +14947 +20193 +5522 +736 +365 +20194 +2577 +20195 +20196 +3635 +43 +373 +19335 +16798 +20197 +20198 +9363 +7053 +20199 +3543 +20200 +35 +590 +48 +20201 +20202 +9688 +9 +20203 +590 +1013 +9 +20204 +20205 +20206 +10117 +13137 +1244 +20207 +19 +14 +20208 +14 +9 +3553 +20209 +20210 +16242 +20211 +15018 +20212 +646 +1107 +20213 +20214 +5080 +2577 +17698 +19 +20215 +17571 +736 +19618 +736 +9 +18283 +590 +15718 +20216 +20217 +349 +20218 +14961 +1051 +286 +20219 +20220 +20221 +286 +9 +20222 +1276 +105 +19 +20223 +3236 +10 +832 +20224 +245 +970 +20225 +3546 +448 +20226 +8188 +14 +3329 +20227 +20228 +9 +20229 +3546 +15718 +20230 +188 +43 +19618 +2430 +286 +14066 +20231 +590 +9440 +5791 +20232 +20233 +43 +15533 +43 +272 +43 +3105 +25 +20234 +209 +14 +20235 +20236 +178 +345 +15718 +185 +5837 +19404 +43 +178 +4963 +1105 +6341 +590 +15541 +57 +192 +248 +349 +5755 +349 +15158 +2330 +43 +18579 +19618 +13279 +20237 +43 +20238 +20239 +18154 +20240 +2129 +915 +20241 +15718 +20242 +6364 +20243 +586 +6028 +13566 +3213 +4126 +20244 +60 +11087 +20245 +736 +9 +11762 +12005 +8668 +43 +16014 +286 +8188 +1956 +4765 +20246 +10946 +20247 +8668 +16981 +20248 +736 +20249 +14 +369 +2804 +20250 +14343 +822 +411 +590 +20251 +365 +11762 +590 +19618 +20 +16925 +20252 +20253 +20254 +20255 +5990 +10 +20256 +19618 +1710 +20257 +19806 +8853 +20258 +9 +14420 +5438 +12555 +1991 +20259 +16656 +2561 +20260 +411 +14 +1107 +274 +590 +20261 +10 +20262 +5920 +20263 +20264 +590 +20265 +43 +80 +14 +20266 +20267 +20268 +20269 +2694 +2314 +3546 +20270 +1927 +10038 +1083 +20271 +14 +15 +1765 +14148 +3553 +590 +831 +14215 +823 +9 +736 +20272 +20273 +2790 +590 +5080 +17821 +20274 +20275 +2577 +6776 +14 +20276 +305 +20277 +9 +20278 +736 +19939 +736 +1364 +10004 +707 +9396 +14 +32 +20279 +15649 +43 +20280 +19 +2577 +323 +5803 +43 +4963 +736 +15718 +18951 +590 +20281 +613 +15595 +20282 +2896 +43 +501 +1154 +19 +14127 +14185 +7032 +20283 +3546 +2770 +509 +3 +19 +43 +15744 +20284 +43 +20285 +20286 +20287 +20288 +8668 +32 +1382 +5820 +282 +2694 +2476 +20289 +32 +590 +57 +20290 +554 +14 +20291 +15925 +9 +6924 +20292 +20293 +20294 +1112 +1444 +10094 +20295 +14026 +20296 +20297 +17112 +2577 +17338 +9 +2561 +1234 +20298 +736 +10946 +590 +20299 +43 +1295 +20300 +20301 +1612 +20302 +15 +9 +1578 +20303 +9 +11966 +9 +20304 +861 +14216 +6011 +20305 +286 +272 +590 +20306 +11822 +20307 +201 +286 +352 +14 +4547 +20308 +20309 +15193 +14 +17635 +20310 +20311 +19655 +14 +3546 +20312 +15647 +20313 +1051 +20314 +14 +305 +2459 +20315 +20316 +20317 +20318 +20319 +2835 +861 +19618 +590 +668 +2 +43 +15 +19 +14363 +14868 +14 +20320 +19404 +32 +20321 +98 +20322 +176 +43 +19 +13349 +491 +349 +18661 +14477 +3732 +20323 +1560 +19618 +20324 +20325 +411 +20326 +842 +17920 +15718 +20327 +20328 +20329 +20330 +20331 +20332 +15718 +20333 +192 +2 +19 +19 +22 +19618 +19806 +20334 +20335 +590 +4952 +155 +3546 +17872 +20336 +20 +20337 +11321 +3909 +540 +20338 +2577 +20339 +20340 +20341 +536 +22 +20342 +7053 +20343 +20344 +1091 +2794 +1013 +196 +2577 +11482 +20345 +20346 +616 +590 +379 +20347 +349 +32 +20348 +20349 +43 +5659 +43 +5780 +20350 +13179 +2325 +12397 +43 +57 +14666 +10356 +20351 +36 +20352 +20353 +18956 +14477 +188 +8100 +20354 +20355 +1245 +2971 +7053 +19618 +20356 +20357 +274 +19618 +19618 +9 +7328 +14 +20358 +20359 +12397 +19618 +20360 +936 +1536 +20361 +821 +32 +20362 +20363 +20364 +15141 +14 +14131 +4506 +7048 +20365 +20366 +20367 +7701 +15718 +823 +15718 +590 +43 +12987 +20368 +9 +20369 +14 +1716 +18503 +272 +20370 +20371 +20372 +20373 +10230 +20374 +20 +19 +2253 +590 +677 +955 +20375 +15589 +751 +20376 +20377 +209 +20378 +20379 +20380 +12241 +8367 +861 +20381 +20382 +20383 +20384 +18982 +20385 +19655 +19404 +1738 +20386 +1942 +2463 +707 +20387 +11230 +209 +43 +4023 +20388 +14604 +20389 +20390 +20391 +20392 +3 +20393 +18695 +20394 +19 +19618 +650 +19618 +2410 +1217 +590 +20395 +20396 +20397 +5780 +3546 +15824 +19618 +1019 +222 +2561 +20398 +20399 +19 +683 +20400 +20401 +20402 +707 +155 +32 +43 +43 +19 +20403 +20404 +20405 +2064 +20406 +9 +590 +16437 +19618 +20407 +15586 +59 +736 +2316 +2316 +164 +541 +13257 +201 +20408 +20409 +43 +98 +14 +610 +9 +20410 +7053 +20411 +20412 +19618 +590 +20413 +19618 +8297 +916 +20414 +18951 +3546 +6766 +20415 +15718 +10163 +736 +22 +415 +20416 +155 +20417 +20418 +20419 +15384 +2144 +8392 +5780 +20420 +286 +1169 +20421 +12231 +1738 +57 +20422 +15654 +19 +10 +19618 +379 +1513 +1224 +19655 +20423 +20424 +20425 +19618 +20426 +20427 +19404 +4126 +20428 +20429 +9526 +89 +590 +20430 +20431 +20432 +6095 +20433 +20434 +20435 +57 +20436 +14299 +349 +1011 +20437 +20438 +20439 +20440 +373 +20441 +20442 +7477 +20443 +7045 +20444 +10287 +20445 +2593 +1696 +865 +32 +46 +764 +590 +590 +9 +19618 +43 +590 +1765 +19917 +20446 +20447 +369 +20448 +20449 +16205 +18045 +20450 +18100 +9497 +19 +14 +19797 +2733 +14 +20451 +19618 +43 +8668 +155 +4961 +15718 +17482 +8188 +15718 +20452 +12987 +439 +20453 +19 +14 +20454 +18798 +1716 +20455 +20456 +20457 +20458 +3353 +20459 +20460 +707 +3034 +7053 +20461 +155 +4963 +20462 +345 +14001 +20463 +57 +7912 +14 +20464 +5780 +1316 +20465 +15 +20466 +20467 +9 +20468 +1529 +12987 +736 +20469 +14477 +4684 +20470 +20471 +2 +43 +20472 +209 +590 +1082 +20473 +1965 +1013 +20474 +57 +17084 +9 +43 +138 +20475 +20476 +7253 +20477 +20478 +20479 +8188 +6518 +7536 +20480 +720 +1912 +16925 +20481 +20482 +20483 +6571 +20484 +20485 +14477 +20486 +15 +20487 +20488 +14148 +20489 +20490 +1166 +5773 +20491 +20492 +29 +865 +720 +3317 +12304 +8882 +20493 +379 +3546 +2009 +20 +43 +14 +20494 +20495 +19655 +20496 +32 +18956 +19655 +20497 +15718 +19618 +1566 +4028 +915 +590 +282 +20498 +590 +20499 +845 +19742 +9 +43 +2260 +14 +13582 +345 +20500 +20501 +19 +9 +43 +14001 +32 +20502 +20503 +2260 +590 +20504 +1991 +20505 +647 +35 +20506 +5438 +8882 +590 +19806 +590 +20507 +5780 +19618 +43 +19618 +8255 +4565 +245 +188 +8367 +12013 +20508 +20509 +20510 +20511 +1307 +272 +590 +590 +446 +5197 +349 +20512 +20513 +2314 +201 +155 +20514 +11315 +155 +66 +2832 +8188 +155 +7053 +464 +15654 +345 +20515 +19618 +14 +14 +1612 +20 +4441 +196 +188 +20516 +15718 +19618 +4141 +20517 +345 +14 +43 +590 +2064 +554 +440 +20518 +17151 +20519 +397 +1520 +43 +20520 +349 +20521 +22 +43 +20522 +17228 +20523 +20524 +590 +20525 +20526 +19618 +14 +213 +590 +2035 +20527 +3546 +9 +13807 +5314 +3546 +14477 +10 +14 +14 +1809 +4918 +9801 +20528 +20529 +53 +14 +20530 +155 +3 +155 +15718 +484 +1765 +20531 +19404 +20532 +89 +770 +1224 +3067 +823 +5217 +345 +14562 +19218 +272 +590 +590 +19 +19 +4775 +20533 +1287 +20534 +19618 +20535 +20536 +590 +16205 +2561 +12987 +20537 +20538 +20539 +19 +155 +20 +43 +20540 +590 +20541 +20542 +20543 +18283 +736 +12402 +7521 +43 +20544 +17834 +595 +17670 +3421 +10 +20545 +272 +2260 +20546 +14604 +15315 +14260 +89 +20547 +20548 +2029 +20549 +3546 +345 +379 +20550 +20551 +1442 +20552 +15718 +18956 +10 +213 +3417 +20553 +558 +18683 +751 +17698 +20554 +2 +20555 +16844 +15718 +2975 +345 +20 +20556 +80 +14477 +209 +20557 +5438 +3546 +16437 +13854 +20558 +6441 +20559 +9 +20560 +1224 +20561 +3546 +43 +20562 +1559 +647 +20563 +1230 +19 +192 +249 +3546 +20564 +713 +6071 +20565 +20435 +20566 +20567 +12987 +20558 +736 +20568 +736 +1112 +43 +4313 +20569 +14 +19091 +14363 +648 +9941 +12827 +20570 +20571 +16844 +1157 +15308 +57 +20572 +2790 +9898 +20573 +20574 +20 +3546 +3546 +713 +590 +80 +112 +1920 +20575 +20576 +349 +20577 +20578 +2694 +736 +19618 +4028 +13539 +20579 +20388 +6741 +5052 +7364 +915 +20580 +349 +736 +20581 +20582 +20583 +20584 +20585 +20586 +20587 +354 +20588 +272 +43 +5117 +7176 +745 +1698 +745 +7137 +647 +20589 +20590 +35 +20591 +20592 +15267 +20593 +736 +20594 +14342 +7053 +1727 +9 +683 +20595 +12832 +1508 +647 +32 +43 +20596 +14 +19 +590 +20597 +15718 +43 +4341 +590 +19 +13959 +38 +2865 +8256 +417 +32 +13566 +19197 +9 +15001 +7379 +14 +32 +15718 +736 +20598 +6741 +2125 +823 +3353 +20599 +20600 +10880 +10574 +3546 +15718 +20601 +9 +20602 +16437 +14 +22 +20603 +20604 +7053 +32 +16743 +1710 +6701 +20605 +590 +15 +19 +3435 +20606 +57 +14603 +2844 +12480 +349 +8149 +19618 +20607 +18798 +9320 +1889 +20608 +77 +11995 +19 +8015 +20609 +323 +20610 +18503 +14 +20611 +20612 +915 +14 +20613 +5601 +32 +18951 +286 +3546 +14477 +19618 +18045 +5333 +19618 +590 +17920 +647 +3546 +188 +20614 +19 +3407 +209 +20615 +19404 +6420 +3 +14477 +16437 +15 +1208 +185 +590 +20616 +19618 +20617 +14477 +17247 +720 +1569 +493 +590 +1212 +17872 +3213 +18862 +20 +20618 +13307 +213 +20619 +20620 +3546 +272 +20621 +43 +20622 +590 +20623 +8967 +377 +736 +20624 +286 +178 +590 +736 +20555 +20625 +20626 +3050 +19 +2314 +1251 +791 +590 +34 +18951 +357 +5780 +1013 +20627 +16389 +20628 +20629 +713 +761 +20630 +533 +1013 +5542 +10 +1442 +646 +20631 +3 +20632 +5780 +20633 +20634 +337 +590 +20635 +16927 +3999 +20636 +590 +17698 +7743 +1217 +1385 +2925 +6741 +20637 +20638 +57 +18052 +590 +6294 +20639 +1688 +10230 +20640 +20641 +2517 +20642 +20643 +32 +842 +20644 +19 +3059 +1870 +3546 +284 +3546 +20645 +20646 +20647 +20648 +9 +222 +18695 +20649 +3 +519 +2697 +20650 +20651 +7053 +20652 +13945 +6028 +533 +493 +504 +1208 +20653 +284 +43 +613 +9 +43 +20654 +3480 +2872 +43 +9 +590 +20655 +6950 +8668 +590 +20656 +3 +19618 +8668 +20141 +14363 +188 +3976 +20657 +20658 +1056 +791 +20659 +19618 +3546 +2804 +590 +17602 +4441 +20660 +20661 +20662 +3067 +1517 +1051 +741 +20663 +20664 +20665 +43 +4 +20666 +188 +4196 +19 +8996 +3546 +1013 +1912 +6571 +713 +20667 +2260 +205 +57 +3546 +20 +20668 +1765 +15718 +1716 +8999 +590 +3559 +20669 +188 +3546 +20670 +2035 +18455 +10 +248 +303 +20671 +20672 +323 +20673 +764 +736 +1710 +20674 +20 +2694 +20675 +713 +10 +20 +3252 +188 +8218 +19042 +4441 +19 +964 +736 +13370 +736 +5904 +411 +6354 +209 +14 +12987 +14363 +323 +286 +15 +20676 +19618 +590 +13127 +17545 +590 +20677 +3546 +18814 +20678 +20679 +2129 +1100 +1961 +1013 +10787 +20680 +89 +1300 +155 +917 +20681 +20682 +20683 +20684 +19576 +248 +2316 +464 +20685 +20686 +29 +590 +736 +20687 +20688 +20689 +1738 +5780 +10 +15718 +19618 +20690 +20691 +20692 +19618 +6205 +19 +20693 +8351 +20694 +32 +2775 +7053 +18025 +20695 +2537 +20696 +20697 +590 +20698 +15649 +43 +2 +155 +10 +1847 +20699 +4907 +14 +20700 +3546 +2243 +19 +43 +38 +20701 +590 +2550 +20702 +9 +274 +213 +20703 +1465 +35 +6877 +155 +284 +213 +3994 +43 +11762 +20704 +1559 +274 +1870 +590 +8668 +19 +4081 +248 +43 +20705 +19806 +590 +16991 +20706 +20707 +12936 +20708 +20709 +8218 +9 +647 +345 +736 +19806 +19 +43 +20710 +790 +20711 +14127 +10 +248 +745 +112 +22 +20712 +590 +20713 +20714 +43 +337 +474 +590 +3317 +357 +665 +43 +43 +14 +278 +20715 +8668 +18695 +3546 +20716 +9 +13045 +10 +15 +15540 +209 +18954 +19618 +176 +20717 +647 +19323 +137 +20700 +248 +1013 +590 +32 +10038 +872 +155 +20718 +14363 +20719 +20720 +20721 +19 +20722 +478 +5601 +9 +345 +12788 +188 +20723 +20724 +554 +15718 +8351 +19618 +736 +12987 +14 +20725 +155 +20726 +13375 +20727 +20728 +48 +971 +3732 +14 +25 +15 +20729 +19618 +2476 +3546 +20730 +590 +20731 +20732 +14604 +519 +16472 +590 +286 +7053 +3546 +3476 +616 +823 +2593 +19618 +19 +14 +24 +586 +20 +1208 +12584 +20733 +20734 +6364 +20735 +590 +20736 +20737 +20 +3546 +12768 +18128 +286 +286 +2121 +20738 +3417 +19618 +155 +590 +590 +19624 +648 +32 +2694 +209 +15718 +19 +1018 +6785 +9400 +14 +3543 +358 +19806 +43 +20739 +18552 +501 +3944 +823 +3599 +38 +20740 +533 +20741 +20742 +20743 +20744 +20745 +590 +20746 +349 +286 +17467 +8566 +590 +14001 +43 +795 +20747 +14477 +1208 +1018 +3376 +7053 +1817 +20748 +10 +9 +5601 +13375 +99 +590 +16 +14 +1021 +20749 +201 +20750 +20751 +43 +15496 +89 +345 +19792 +5099 +2637 +3743 +14 +11618 +20752 +20753 +15718 +18178 +2356 +20754 +20755 +29 +20756 +155 +4144 +6571 +20757 +20758 +554 +20759 +573 +20760 +12987 +17356 +720 +20761 +20762 +20 +14 +20763 +8668 +1764 +20764 +2 +1575 +20765 +14477 +14 +20766 +317 +20767 +274 +20768 +20769 +683 +286 +20770 +18283 +339 +970 +152 +20771 +20772 +14 +3546 +20773 +43 +112 +39 +4717 +554 +155 +20774 +286 +1091 +345 +4581 +3546 +20775 +9 +3546 +5441 +20776 +2577 +2253 +665 +20777 +20778 +20779 +14 +20780 +20781 +20 +16305 +971 +57 +3553 +20782 +20783 +14477 +720 +20784 +20785 +3695 +5689 +2415 +849 +20786 +1437 +12333 +3353 +13474 +10706 +20787 +826 +14 +66 +590 +20788 +20789 +20790 +9 +2 +1109 +16672 +8668 +20791 +43 +16437 +2 +19 +19404 +2164 +20792 +20793 +20 +1655 +20794 +20795 +15718 +12987 +20 +15744 +12254 +1684 +970 +80 +19655 +9 +272 +590 +1310 +20796 +9 +764 +15718 +5316 +474 +11073 +137 +188 +20499 +20797 +279 +20798 +411 +20799 +20800 +43 +10439 +5208 +19618 +10 +2446 +1229 +647 +4174 +109 +1742 +736 +7855 +32 +1100 +20801 +20802 +15975 +57 +18816 +14689 +213 +16941 +379 +349 +13279 +3330 +60 +286 +19618 +20803 +4485 +648 +20804 +554 +20805 +43 +349 +20806 +19618 +43 +12893 +20807 +1011 +19618 +15 +20808 +13543 +1738 +20809 +38 +1559 +29 +20810 +213 +18695 +15535 +11321 +20811 +827 +345 +5780 +20812 +519 +349 +18896 +1559 +20813 +20814 +4084 +6571 +20815 +43 +20816 +43 +20817 +20818 +491 +4820 +20819 +20820 +20821 +345 +20822 +17 +15649 +10028 +152 +1423 +20823 +20824 +20825 +1927 +20826 +625 +2694 +9314 +43 +20827 +736 +19618 +20828 +3546 +590 +32 +590 +19404 +20829 +19618 +17602 +18683 +1630 +19618 +590 +57 +464 +8392 +8351 +20830 +179 +20831 +18982 +20832 +20833 +20834 +19618 +9796 +19404 +10 +14 +207 +14 +284 +20835 +1082 +20836 +6140 +3059 +20837 +20838 +43 +10621 +15718 +2015 +20839 +3546 +20840 +57 +16012 +20841 +20842 +13138 +2254 +19 +827 +155 +349 +415 +20843 +7799 +9 +20844 +2832 +20845 +20846 +2694 +20847 +20848 +20849 +20850 +20851 +20852 +20 +53 +590 +3 +19618 +20853 +43 +137 +20854 +20855 +365 +20856 +20174 +185 +20857 +20858 +554 +19 +20859 +43 +15820 +248 +17670 +20860 +12397 +43 +20861 +2314 +6441 +399 +5418 +2260 +823 +16437 +20 +20862 +20863 +213 +7379 +823 +20864 +19 +2197 +14916 +3408 +2694 +3 +20865 +736 +12996 +20 +43 +554 +7908 +20866 +20867 +248 +20868 +1234 +354 +3548 +57 +14152 +20869 +14274 +3546 +20 +595 +303 +32 +201 +20870 +20871 +1112 +15583 +19618 +209 +20872 +3491 +19 +19618 +590 +7328 +155 +16375 +1605 +248 +2015 +20873 +20874 +20875 +323 +9 +4230 +20876 +2770 +4441 +4230 +20877 +1859 +14 +19 +15699 +293 +495 +9 +971 +446 +4118 +20878 +20879 +14680 +8297 +823 +20880 +345 +38 +20881 +791 +1100 +20161 +2804 +590 +14 +18054 +14 +1384 +248 +209 +554 +20882 +20883 +1961 +20884 +43 +590 +20885 +140 +305 +20886 +2577 +1091 +20887 +20888 +20889 +20890 +20891 +10993 +20892 +13666 +3192 +20893 +1425 +18257 +2197 +20894 +20895 +4963 +19 +20896 +32 +3546 +20897 +155 +19 +5780 +1100 +736 +5582 +141 +5632 +1066 +1157 +13908 +13943 +2260 +43 +16696 +2 +20898 +248 +573 +20899 +20900 +15694 +16437 +20901 +14477 +284 +19478 +12560 +736 +20902 +349 +13149 +43 +20428 +20903 +20904 +1013 +20905 +519 +43 +345 +20906 +2577 +32 +43 +590 +9 +519 +9 +43 +3335 +17356 +1765 +57 +20907 +14082 +10 +842 +14 +20908 +809 +43 +20909 +13528 +43 +1912 +20910 +32 +20911 +665 +736 +8668 +20912 +20913 +14 +43 +20914 +192 +3546 +1508 +736 +20915 +201 +2064 +19404 +16927 +20916 +791 +286 +20917 +9 +20918 +20919 +20920 +20921 +20922 +3291 +57 +17247 +1090 +19618 +5804 +14 +20923 +20924 +20925 +18372 +3546 +20926 +20927 +20928 +20929 +2029 +20930 +20931 +519 +1927 +35 +15718 +19 +398 +9485 +4544 +2 +19 +3553 +43 +590 +7027 +17112 +10487 +20932 +20 +20933 +20934 +872 +20935 +590 +19655 +286 +736 +20936 +349 +1559 +11715 +2314 +2316 +554 +19618 +14 +14603 +4269 +66 +20937 +1961 +59 +349 +20938 +14 +20939 +12642 +43 +13976 +20940 +13361 +720 +20941 +20942 +2694 +16826 +20943 +3296 +20944 +19965 +352 +43 +5344 +19404 +20945 +3752 +19 +2919 +201 +11808 +12987 +12987 +10 +323 +20946 +3546 +20947 +1566 +43 +20948 +2197 +412 +43 +11754 +286 +20572 +1924 +18695 +20949 +20950 +20951 +22 +9 +1502 +683 +20952 +7053 +17635 +20953 +14 +20954 +20955 +43 +20956 +590 +20957 +7053 +1864 +20958 +694 +19 +345 +17083 +89 +14538 +14477 +19304 +14603 +20959 +249 +20960 +20961 +20962 +228 +222 +20963 +20964 +17251 +15718 +43 +6121 +32 +20965 +4752 +12202 +616 +20966 +8351 +14388 +20967 +4544 +736 +2577 +10031 +20968 +4963 +20969 +1051 +20970 +20971 +736 +20972 +20973 +9 +20448 +10 +19 +155 +8255 +5823 +1559 +448 +155 +358 +4364 +20974 +7145 +20975 +286 +16981 +20976 +12005 +1442 +849 +20977 +17872 +20978 +20979 +590 +736 +20980 +764 +736 +20981 +402 +20982 +20983 +3546 +20984 +12005 +20985 +13807 +20986 +11087 +209 +809 +20987 +11335 +43 +1465 +20988 +292 +2459 +20989 +7053 +715 +18951 +4766 +19 +43 +20990 +18956 +1817 +19 +590 +20991 +1716 +14 +155 +20572 +20992 +15718 +14477 +20993 +20994 +20 +20995 +20996 +19655 +14477 +3543 +20997 +5267 +590 +20998 +20999 +35 +3995 +21000 +647 +2733 +823 +7238 +21001 +683 +21002 +595 +826 +2577 +155 +19618 +2330 +3546 +34 +14527 +823 +43 +155 +3421 +21003 +815 +548 +164 +694 +21004 +6251 +369 +155 +2790 +43 +21005 +21006 +971 +357 +21007 +25 +18982 +21008 +14 +397 +21009 +43 +20326 +188 +21010 +21011 +43 +1364 +21012 +21013 +17571 +11995 +21014 +1314 +2029 +16535 +21015 +10439 +38 +12067 +2804 +1090 +590 +665 +14 +6095 +21016 +57 +9 +21017 +11754 +272 +32 +21018 +21019 +13874 +21020 +21021 +21022 +15744 +14001 +12743 +3095 +21023 +14 +1048 +349 +349 +2804 +677 +915 +13564 +21024 +8743 +349 +2124 +19618 +3978 +21021 +43 +9 +272 +1112 +18120 +19 +3546 +21025 +10004 +21026 +2314 +590 +43 +21027 +21028 +21029 +2314 +19 +3546 +21030 +19 +286 +21031 +6095 +21032 +15718 +2314 +14 +21033 +590 +21034 +21035 +14 +21036 +19655 +554 +590 +17635 +736 +20 +399 +21037 +2164 +21038 +736 +21039 +155 +14351 +21040 +3484 +417 +9 +5533 +4029 +3546 +21041 +21042 +14 +736 +196 +15718 +21043 +647 +1226 +43 +21044 +13039 +16788 +3546 +3316 +4387 +21045 +21046 +43 +123 +4278 +21047 +20555 +16240 +21048 +2314 +15193 +1566 +21049 +7537 +21050 +21051 +155 +21052 +21053 +21054 +554 +10 +1168 +21055 +21056 +21057 +3239 +57 +671 +15809 +21058 +14 +3119 +399 +597 +21059 +43 +14363 +14770 +21060 +201 +43 +11274 +1013 +21061 +3546 +19 +3546 +2859 +58 +21062 +345 +21063 +21064 +15718 +19618 +201 +43 +14 +21065 +20206 +43 +19 +19618 +1013 +21066 +21067 +18100 +14 +823 +21068 +345 +2476 +21069 +8210 +1824 +3239 +21070 +345 +20774 +20 +519 +21071 +43 +590 +12761 +3743 +514 +21072 +590 +19618 +6950 +827 +21073 +554 +788 +736 +16437 +15 +12203 +21074 +21075 +554 +15845 +7053 +568 +823 +14 +21076 +14 +6732 +21077 +21078 +104 +345 +736 +43 +19655 +12987 +14 +201 +21079 +21080 +19792 +3546 +7137 +6617 +21081 +5344 +486 +155 +20 +17082 +19 +104 +21082 +2733 +647 +43 +21083 +57 +21084 +21085 +21086 +201 +21087 +21088 +43 +19695 +15718 +21089 +21090 +286 +21091 +21092 +19792 +590 +16437 +21093 +1991 +21094 +21095 +21096 +21097 +345 +21098 +21099 +21100 +18806 +20 +21101 +57 +4227 +43 +14604 +42 +9410 +21102 +3 +2459 +15592 +43 +18283 +16180 +21103 +21104 +12788 +21105 +43 +11483 +3236 +16681 +17670 +21106 +21107 +6283 +7815 +21108 +1051 +19404 +20737 +21109 +1889 +22 +21110 +3546 +21111 +2830 +155 +21112 +278 +21113 +590 +43 +18637 +32 +21114 +349 +11762 +32 +1870 +188 +57 +778 +21115 +14 +764 +349 +99 +21116 +2728 +43 +1310 +19752 +6571 +1961 +21117 +21118 +19618 +2019 +21119 +21120 +8967 +4126 +21121 +2260 +8214 +14 +7917 +5495 +5299 +14 +20343 +2042 +7053 +1508 +2009 +21122 +21123 +196 +17911 +21124 +2804 +4414 +21125 +827 +19806 +43 +15168 +736 +21126 +21127 +21128 +5601 +6441 +20773 +21129 +1992 +21130 +21131 +21132 +21133 +21134 +16790 +21135 +3406 +1765 +554 +1543 +21136 +7045 +14477 +43 +533 +11762 +1605 +155 +736 +21137 +21138 +155 +14477 +6571 +2657 +19 +286 +3772 +155 +5410 +21139 +43 +21140 +2260 +43 +21141 +4367 +21142 +4929 +4793 +20340 +21143 +3546 +14933 +4808 +765 +21144 +11087 +1716 +323 +141 +43 +3978 +1749 +155 +21145 +519 +35 +10439 +22 +5204 +2537 +5877 +21146 +1027 +13566 +16780 +9 +590 +21147 +21148 +59 +32 +21149 +20555 +590 +823 +590 +3559 +21150 +3546 +14240 +713 +21151 +823 +21152 +19806 +43 +21153 +137 +349 +21031 +7053 +185 +21154 +141 +597 +7146 +590 +21155 +21156 +14192 +5318 +21157 +887 +21158 +21159 +21160 +2944 +21161 +21162 +32 +21163 +7053 +13710 +21164 +10727 +15 +21165 +21166 +5908 +6776 +19618 +32 +21167 +21168 +9 +1648 +1224 +3546 +21169 +2356 +3354 +10 +349 +57 +1710 +43 +21170 +21171 +3476 +19 +21172 +20952 +14 +43 +4414 +8743 +11362 +21173 +590 +17879 +21174 +1091 +590 +104 +7053 +21175 +18047 +736 +10 +21176 +197 +736 +4682 +683 +19 +5027 +1021 +2694 +3 +15497 +13973 +345 +21177 +13974 +8380 +745 +1056 +345 +19618 +19618 +349 +155 +9934 +21178 +21179 +9123 +15824 +21180 +694 +21181 +104 +21182 +2260 +20384 +286 +20572 +1011 +14792 +9 +14 +21183 +8392 +2 +317 +245 +21184 +21185 +590 +736 +21186 +98 +823 +21187 +16890 +1222 +272 +736 +21188 +21189 +21190 +3546 +32 +13624 +16899 +13566 +155 +1961 +17635 +21191 +21192 +21193 +21194 +201 +21195 +16 +14844 +19404 +15406 +21196 +21197 +21198 +19 +155 +2285 +1655 +10 +9873 +19618 +18798 +21199 +823 +8210 +21200 +15561 +18951 +2318 +21201 +21202 +590 +6617 +43 +19271 +21203 +464 +14 +19618 +14797 +274 +21204 +17136 +21205 +21206 +12987 +5582 +66 +21207 +21208 +21209 +736 +377 +16437 +648 +1847 +21210 +823 +21211 +21212 +43 +8297 +869 +33 +3546 +21213 +379 +21214 +2476 +21215 +3995 +17947 +17981 +21216 +590 +21217 +5650 +2804 +21218 +823 +21219 +554 +16387 +14215 +20 +590 +21220 +19618 +197 +21221 +21222 +21223 +43 +21224 +21225 +9 +19439 +13484 +21226 +1224 +21227 +21228 +19618 +43 +1154 +1503 +14603 +19883 +14102 +2415 +1013 +19 +43 +21229 +809 +1965 +19 +21230 +7935 +10439 +11762 +16850 +21231 +21232 +1716 +2540 +209 +21233 +14 +21234 +21235 +3546 +554 +21236 +43 +590 +590 +1160 +970 +19918 +270 +590 +21237 +4812 +1160 +19 +21238 +43 +21239 +21240 +21241 +15718 +21242 +590 +286 +21232 +19655 +77 +5438 +14 +194 +286 +21243 +412 +32 +21244 +17670 +11702 +1224 +707 +19618 +20 +21245 +21246 +7379 +21247 +2879 +14 +21248 +21249 +1042 +43 +21250 +14 +57 +188 +736 +1502 +10356 +21251 +2 +21252 +21253 +730 +12067 +736 +21254 +3546 +43 +1716 +7053 +14 +1696 +6504 +21255 +317 +286 +21256 +1749 +21257 +1051 +20952 +19 +21258 +20 +15718 +19965 +1082 +57 +509 +1533 +20600 +536 +6571 +21259 +8270 +138 +4288 +647 +19404 +21260 +9 +14 +19618 +14477 +15718 +21261 +1107 +345 +14 +20291 +8512 +21262 +15595 +590 +7799 +6571 +39 +373 +21263 +21264 +21265 +18455 +19 +21266 +3546 +873 +21267 +15718 +5780 +21268 +20 +21269 +20657 +21270 +7855 +736 +3546 +21271 +21272 +155 +21273 +10 +19618 +21274 +14 +21275 +21276 +10439 +7270 +155 +5780 +828 +21277 +19 +4315 +6071 +32 +14 +286 +3546 +201 +14 +21278 +11754 +14524 +19 +14520 +21279 +19618 +590 +345 +21280 +533 +20 +12158 +15592 +21281 +21282 +21283 +21284 +2006 +590 +21285 +21286 +21287 +119 +3669 +9402 +2762 +12987 +533 +2593 +9 +20572 +21288 +3395 +669 +720 +21289 +19404 +21290 +590 +15592 +686 +21291 +590 +21292 +21293 +17473 +1559 +21294 +590 +19618 +185 +10117 +1090 +10303 +7137 +21295 +9162 +2577 +21296 +19 +274 +286 +15718 +209 +21297 +1696 +19618 +3546 +21298 +590 +761 +21299 +15971 +21300 +5203 +4 +140 +6533 +14 +21301 +11707 +9 +16589 +14477 +21302 +8249 +13569 +21303 +21304 +32 +15718 +19618 +345 +19 +11762 +21305 +12005 +21306 +21307 +4907 +590 +13801 +3990 +286 +345 +1517 +3341 +21308 +21309 +228 +379 +21310 +21311 +21312 +21313 +5780 +21314 +21315 +21316 +10 +13538 +5627 +155 +43 +15718 +19 +21317 +349 +21318 +14604 +2287 +21319 +1012 +1154 +12684 +9 +21320 +5780 +19 +6776 +17608 +20 +20 +1164 +21321 +16118 +21322 +14 +8668 +21323 +21324 +10230 +57 +17228 +1976 +21325 +9 +22 +21326 +155 +8789 +19852 +21327 +21328 +10 +18283 +21329 +13624 +764 +209 +21330 +14363 +19048 +5803 +1109 +590 +99 +338 +21331 +14 +720 +14001 +20127 +201 +19 +21332 +2 +21333 +514 +21334 +201 +1716 +12989 +21335 +21336 +1013 +21337 +14 +823 +14 +538 +222 +21338 +1442 +554 +19 +21339 +9 +10028 +21340 +43 +21341 +21342 +345 +21343 +21344 +21345 +21346 +19 +4118 +15 +21347 +590 +495 +554 +19 +323 +21348 +21349 +286 +21350 +14 +21351 +18919 +5601 +43 +29 +2550 +19618 +21352 +5803 +21353 +19 +4518 +21354 +3213 +21355 +21356 +21357 +14 +19 +7835 +21358 +16180 +228 +21359 +21360 +179 +1139 +595 +8249 +11754 +8301 +4278 +11754 +21361 +19 +21362 +764 +21363 +12987 +21364 +43 +4 +21365 +16437 +5803 +349 +4278 +21366 +21367 +15718 +43 +5627 +60 +21368 +21369 +43 +19404 +21370 +613 +568 +3839 +21371 +736 +21372 +11308 +495 +19618 +21373 +21374 +14 +21375 +16126 +18045 +43 +21376 +16437 +21377 +21378 +14 +21379 +12561 +15356 +286 +19618 +196 +873 +11362 +21380 +18095 +32 +21381 +14 +21382 +849 +14 +43 +1668 +286 +16883 +5582 +21383 +21384 +11483 +1157 +66 +3842 +21385 +1517 +21386 +10222 +7053 +887 +155 +15720 +20 +9 +21168 +590 +14 +647 +21387 +222 +7379 +21388 +21389 +1870 +736 +14 +2349 +2 +17670 +3978 +21390 +1559 +21391 +21392 +533 +21393 +2446 +19618 +21336 +286 +590 +1765 +43 +3546 +10236 +21394 +16437 +38 +21395 +99 +845 +736 +16437 +21396 +21397 +590 +43 +21398 +17144 +43 +13285 +1013 +1765 +345 +2134 +21399 +17571 +1208 +21400 +21401 +21402 +21403 +21404 +10699 +7896 +21405 +32 +20 +1013 +19 +19404 +14 +1012 +19655 +536 +286 +15054 +19618 +20941 +5780 +10 +346 +21088 +872 +176 +21406 +16437 +20702 +21407 +17119 +21408 +3484 +43 +20677 +21409 +21410 +21411 +19 +6877 +21412 +57 +8668 +10 +21413 +21414 +43 +21415 +12807 +43 +3546 +2733 +736 +21416 +10439 +21417 +8188 +1991 +21418 +21419 +21420 +3546 +583 +590 +14 +21421 +915 +5318 +590 +764 +21422 +104 +19618 +57 +21423 +18896 +21424 +21425 +345 +683 +21426 +9 +2694 +736 +18951 +21427 +138 +21428 +1465 +21429 +2018 +21430 +176 +2064 +16389 +21431 +19404 +3546 +9144 +9934 +21432 +398 +19 +35 +21433 +7653 +3251 +18047 +284 +7053 +21434 +248 +3353 +7536 +155 +21435 +21436 +21437 +736 +12185 +14 +21438 +21439 +1013 +8668 +827 +14 +48 +1051 +736 +213 +25 +18283 +16437 +21440 +8041 +14 +14 +19618 +17229 +21441 +15718 +21442 +21443 +872 +1870 +57 +21444 +21445 +19 +19 +15718 +213 +5211 +21446 +14 +248 +21447 +14603 +17519 +823 +21448 +1991 +21449 +1190 +248 +590 +21450 +21451 +21405 +21452 +1912 +19 +21453 +1696 +15718 +1425 +12987 +1224 +16640 +15 +21454 +14 +323 +3546 +590 +12404 +19404 +21455 +590 +248 +6439 +1612 +10640 +176 +5344 +590 +10230 +16437 +590 +21456 +201 +21457 +5134 +21458 +19404 +32 +823 +9 +21459 +14 +21460 +8668 +19618 +21461 +303 +1385 +36 +11762 +35 +14604 +823 +349 +345 +21462 +7231 +21463 +21464 +21465 +305 +9 +21466 +19 +21467 +20 +13230 +337 +21468 +21469 +2314 +1559 +16429 +21176 +14 +20 +43 +20 +14 +8249 +15975 +21470 +303 +104 +14 +736 +14 +21471 +196 +6571 +915 +155 +43 +21472 +21473 +3546 +337 +21474 +21475 +21476 +21477 +20803 +21478 +284 +18139 +21479 +21480 +19 +15718 +14020 +286 +713 +10 +13207 +21481 +43 +590 +590 +16437 +12321 +32 +21482 +590 +21483 +21484 +1415 +21485 +21486 +43 +21487 +21488 +21489 +303 +345 +2281 +16437 +19618 +5801 +9102 +3768 +43 +21490 +21491 +21492 +705 +14603 +1082 +19 +4023 +6496 +21050 +1912 +4916 +1168 +8668 +19 +770 +21493 +21494 +8208 +15718 +11754 +349 +720 +303 +1234 +9 +15718 +20794 +2537 +21495 +21496 +21497 +21498 +57 +14 +21499 +19404 +21500 +446 +19 +14 +21501 +665 +11754 +21502 +17698 +43 +19404 +21503 +248 +185 +21504 +5780 +21505 +4278 +564 +43 +21506 +590 +590 +21507 +590 +155 +4126 +21508 +305 +8280 +3978 +2243 +21509 +683 +15384 +22 +20181 +21510 +19618 +16887 +19918 +21511 +19 +21512 +19 +21513 +915 +21514 +554 +248 +43 +14 +21515 +590 +21516 +19 +112 +21517 +2790 +19618 +20 +8668 +21518 +21519 +1012 +8403 +1208 +21520 +3964 +21521 +647 +4907 +19618 +21522 +21523 +272 +21524 +337 +349 +21525 +248 +21526 +21527 +278 +155 +5592 +303 +18045 +21528 +12987 +8367 +21529 +21530 +345 +21531 +21532 +21533 +573 +3546 +4 +315 +21534 +21535 +323 +9410 +590 +284 +21536 +21537 +14604 +1047 +21538 +13364 +13913 +379 +10222 +237 +19 +659 +21539 +1655 +17136 +411 +21540 +19404 +21541 +43 +43 +21542 +19618 +20 +19 +57 +989 +21543 +43 +15718 +590 +18780 +21544 +1927 +9 +2841 +305 +3 +21545 +21546 +2412 +21547 +13111 +2310 +21548 +14 +43 +1559 +3546 +21549 +21550 +21551 +15720 +3601 +201 +15718 +8849 +14477 +19618 +3944 +13566 +21552 +21553 +9628 +43 +155 +43 +286 +21554 +2314 +137 +14 +21555 +155 +21556 +8392 +21557 +345 +464 +5211 +21558 +21559 +21560 +15 +495 +21561 +5780 +21562 +2463 +15 +5780 +43 +8098 +590 +2 +842 +1364 +21563 +21564 +823 +590 +21565 +43 +19456 +286 +19 +21566 +2286 +345 +10111 +14020 +21567 +21568 +21569 +14477 +536 +770 +21570 +21571 +21572 +12668 +103 +21573 +21574 +337 +14 +590 +21575 +19 +19404 +248 +137 +14 +15274 +21576 +19618 +21577 +323 +21578 +21579 +1382 +5725 +337 +21580 +21581 +2 +770 +25 +16511 +590 +10727 +19241 +9 +188 +9 +21582 +237 +14477 +17871 +736 +21583 +6096 +349 +21584 +99 +1119 +138 +21585 +286 +3546 +590 +14 +43 +18695 +57 +21586 +590 +19664 +21587 +21588 +17602 +178 +19618 +32 +11754 +16826 +741 +1153 +8188 +21589 +185 +3546 +77 +14 +21590 +540 +21591 +5780 +736 +3376 +196 +21592 +1991 +52 +6217 +21593 +242 +21594 +14420 +32 +21595 +21596 +14477 +21597 +21598 +21599 +21600 +4083 +2314 +5498 +14 +57 +6883 +21601 +89 +15 +2577 +21602 +736 +16991 +43 +10 +164 +43 +590 +25 +1090 +21603 +284 +21604 +18695 +21605 +21606 +14477 +21607 +21608 +21609 +915 +250 +736 +21610 +284 +21611 +286 +19655 +18047 +19838 +21612 +21613 +736 +349 +14477 +9 +15 +14 +345 +14523 +21614 +21615 +10591 +20600 +303 +21616 +12987 +536 +827 +21617 +19618 +9 +790 +21618 +80 +21619 +14 +21620 +213 +2004 +21621 +590 +3601 +21622 +43 +19618 +16461 +1559 +250 +437 +20576 +1310 +14 +21623 +15720 +12987 +20315 +21624 +21625 +357 +873 +21626 +22 +5780 +21627 +656 +21628 +3100 +248 +554 +284 +18045 +349 +21629 +286 +337 +21630 +345 +1013 +21631 +89 +554 +6363 +21632 +2135 +43 +21633 +21634 +21635 +11087 +21636 +1831 +440 +104 +823 +21637 +21638 +303 +554 +19460 +1011 +21639 +5780 +188 +2 +21640 +9 +14 +3480 +339 +21641 +21642 +114 +845 +115 +21643 +21644 +21645 +2 +305 +337 +21646 +248 +2 +21647 +21648 +21649 +21650 +57 +590 +736 +3546 +43 +15718 +286 +736 +21651 +14 +13361 +7053 +1648 +971 +21652 +16437 +358 +21653 +1961 +21654 +1531 +15718 +2832 +21655 +21656 +18283 +15718 +4606 +303 +21657 +21658 +21659 +21660 +21661 +19618 +21662 +21663 +21664 +21665 +155 +712 +21666 +43 +20952 +21667 +2476 +19618 +248 +10787 +43 +21668 +21669 +10439 +736 +21670 +1018 +3354 +823 +43 +2287 +13409 +21671 +3575 +205 +21672 +3546 +20 +8809 +2733 +21673 +21674 +248 +440 +9 +14 +665 +19 +286 +21675 +43 +10439 +15718 +177 +20383 +66 +4963 +17602 +12987 +665 +15592 +2121 +8188 +21676 +645 +57 +590 +21677 +9 +21678 +284 +21679 +21680 +21681 +19 +17372 +19618 +21682 +17834 +5208 +43 +43 +823 +16180 +373 +43 +823 +17608 +278 +365 +21683 +345 +715 +12987 +2 +736 +21684 +21685 +2029 +286 +21686 +2787 +21687 +21688 +10439 +791 +21689 +19618 +770 +3546 +17698 +2694 +18695 +21690 +3204 +19 +21691 +14 +590 +8297 +15718 +14 +19618 +1503 +736 +21692 +21693 +1382 +2414 +1316 +21694 +21695 +3546 +155 +21696 +270 +104 +19 +15349 +18695 +19 +21697 +536 +21698 +21699 +21700 +284 +21701 +3239 +14 +13566 +21276 +8668 +43 +21702 +21703 +21704 +15718 +17625 +1012 +491 +3369 +43 +10880 +590 +764 +21705 +5075 +3553 +590 +19218 +36 +21706 +1606 +43 +21707 +21708 +14 +2029 +21709 +21710 +10727 +2117 +17039 +4128 +2944 +43 +15971 +11754 +823 +15 +5169 +21711 +12479 +6341 +5117 +21712 +11822 +14 +19199 +16725 +823 +19618 +15275 +21713 +3546 +1385 +10439 +21714 +13375 +21715 +1817 +823 +43 +21716 +1224 +590 +770 +8297 +345 +14 +286 +845 +3546 +21717 +19618 +1382 +21718 +21719 +15054 +3435 +19 +19618 +590 +21720 +21721 +14 +249 +14 +48 +21722 +5387 +15989 +13973 +43 +373 +9 +20 +19 +2804 +21723 +1249 +7835 +43 +736 +18597 +692 +8508 +17698 +21724 +11762 +21725 +398 +13151 +2837 +19 +14363 +6627 +736 +21726 +3484 +19218 +6518 +21727 +15718 +720 +286 +1442 +43 +345 +19852 +21728 +6430 +9 +14079 +32 +377 +43 +213 +192 +2314 +21729 +736 +21730 +20 +19618 +21731 +14 +21732 +18283 +21733 +3546 +3045 +20 +46 +823 +15914 +736 +3546 +21734 +2197 +43 +43 +21735 +3546 +21736 +21737 +345 +19618 +971 +3995 +379 +21738 +2540 +6595 +7011 +178 +1157 +1047 +21739 +8501 +57 +4269 +21740 +38 +2 +7053 +21741 +21742 +21743 +19 +15718 +201 +590 +43 +21744 +21745 +21746 +176 +21747 +11995 +21748 +590 +21749 +1082 +16437 +21750 +9 +21751 +21752 +21753 +1224 +21754 +7137 +416 +7053 +188 +14 +2302 +21755 +13988 +21756 +19 +21757 +21758 +19 +80 +21759 +21760 +14986 +11762 +21761 +21762 +43 +665 +43 +21763 +21764 +424 +21765 +21766 +19618 +14 +21767 +2316 +21768 +19 +21769 +13266 +3324 +21770 +21771 +21772 +14477 +21773 +21774 +21775 +21776 +15220 +21777 +21778 +21779 +736 +3546 +5197 +21780 +21781 +15718 +14 +19585 +21782 +10913 +21783 +21784 +21785 +13150 +21786 +1107 +770 +13361 +1991 +21787 +21788 +15535 +21789 +21790 +19 +2734 +9 +16917 +2459 +4313 +21791 +11483 +16389 +3546 +317 +11754 +21792 +21793 +21794 +98 +9 +7045 +4185 +770 +21795 +19404 +21796 +5780 +3353 +21797 +21798 +21799 +21800 +21801 +21802 +14342 +3 +21803 +21804 +352 +21805 +1166 +21806 +155 +21807 +345 +155 +5169 +14 +16 +21350 +14 +4665 +21808 +21809 +155 +1578 +193 +7137 +6571 +18418 +21810 +583 +736 +19618 +19618 +3546 +15718 +415 +21811 +21812 +21813 +21814 +21815 +19304 +21816 +683 +1109 +590 +57 +3755 +2314 +22 +20586 +21817 +1542 +3546 +1021 +3546 +19404 +153 +20340 +188 +21818 +32 +9 +21819 +21820 +3546 +6095 +21821 +1961 +21822 +21823 +18047 +21824 +22 +213 +284 +19 +21825 +21826 +20 +76 +21827 +286 +21828 +21829 +35 +3546 +21830 +21831 +21832 +21833 +1612 +14856 +349 +21834 +43 +5438 +590 +21835 +21836 +19 +736 +10239 +6950 +1090 +155 +16619 +21837 +1817 +43 +35 +4414 +665 +18982 +19404 +248 +12118 +19 +18453 +19918 +20 +59 +21838 +809 +22 +8876 +8668 +349 +3546 +21839 +213 +16447 +21840 +2 +21841 +21842 +18695 +2039 +14 +21843 +20803 +164 +1208 +248 +303 +303 +15 +21844 +21845 +21846 +349 +1615 +21847 +155 +21848 +536 +21849 +43 +1384 +284 +21850 +14 +248 +3978 +345 +284 +21851 +14604 +14 +21852 +21853 +303 +19618 +178 +21854 +193 +15718 +3546 +590 +337 +337 +19 +21855 +736 +533 +209 +736 +213 +21856 +21857 +21858 +345 +179 +1364 +284 +21859 +19 +303 +213 +20888 +21860 +21861 +284 +1425 +590 +18695 +21862 +248 +21863 +21864 +1295 +1442 +3470 +5326 +21865 +4750 +491 +358 +9 +21866 +20 +3978 +10497 +21867 +34 +21868 +21869 +5083 +21870 +736 +21871 +5075 +14 +14 +15718 +6086 +322 +21872 +15939 +22 +11483 +21873 +21874 +248 +3216 +1481 +554 +590 +9 +590 +14660 +21875 +272 +21876 +222 +10 +14 +1529 +21877 +20952 +337 +21878 +1648 +16 +21879 +43 +270 +21880 +971 +21579 +3228 +7835 +4028 +21881 +1559 +43 +21882 +14240 +21883 +12864 +21884 +14299 +21885 +222 +15718 +21886 +21887 +21888 +590 +11482 +19413 +303 +14 +29 +1765 +12222 +651 +1217 +21889 +5755 +21890 +43 +21891 +5085 +6214 +138 +6841 +5561 +21892 +43 +21893 +21894 +20825 +80 +21895 +209 +21896 +12772 +13721 +99 +1066 +21897 +21898 +345 +21899 +10117 +21900 +646 +21901 +2804 +7137 +590 +21902 +14 +21903 +154 +1082 +21904 +21905 +21906 +17112 +21907 +21908 +21909 +21910 +21911 +823 +5780 +17136 +790 +57 +21912 +18683 +736 +19618 +57 +13721 +21913 +9804 +3858 +590 +57 +21914 +1566 +21915 +21916 +21917 +14369 +32 +13748 +21918 +1189 +21919 +21920 +345 +424 +21921 +14 +13721 +43 +21922 +3452 +1442 +155 +2655 +13721 +21923 +590 +21855 +9900 +2577 +16981 +1208 +9 +19119 +21924 +21925 +19655 +9 +8351 +21926 +10 +1056 +21927 +201 +25 +4414 +21928 +21929 +590 +19 +19 +19618 +590 +21930 +11683 +19 +21931 +21932 +21933 +13721 +15718 +345 +3546 +4651 +20 +21934 +43 +590 +10287 +8210 +2537 +43 +21935 +16437 +19404 +21936 +21937 +21938 +19618 +21939 +533 +15718 +21940 +14 +43 +21941 +770 +1559 +349 +18418 +13045 +112 +20 +21942 +646 +21943 +21944 +36 +21945 +573 +21946 +21947 +14 +201 +14 +651 +1765 +2314 +9 +32 +15718 +915 +21948 +4028 +14 +21949 +21950 +19852 +590 +1134 +1310 +6877 +19618 +20572 +590 +5719 +15141 +9 +250 +590 +1481 +21951 +2324 +19852 +823 +21952 +554 +21953 +19655 +286 +590 +21954 +13803 +15649 +21955 +115 +10 +7172 +17277 +373 +683 +21956 +1049 +21957 +14 +20 +21958 +21959 +1536 +6997 +21960 +57 +21961 +590 +2419 +13721 +21947 +5197 +21962 +5085 +4634 +2 +21963 +3546 +6950 +21964 +21965 +21966 +21967 +822 +21968 +18327 +13411 +21969 +317 +7053 +14629 +10 +3270 +7053 +19342 +20600 +6877 +21970 +21971 +21972 +57 +3086 +5839 +3095 +9837 +21973 +188 +21974 +17635 +2358 +21975 +19 +21976 +4873 +16437 +17749 +21689 +13570 +21947 +15718 +12053 +21977 +21978 +568 +19618 +19 +16437 +1508 +590 +14 +21979 +21980 +6341 +43 +21981 +19618 +345 +21982 +43 +19 +14 +868 +196 +19618 +1817 +209 +11471 +1612 +21983 +172 +2035 +736 +9 +345 +357 +155 +590 +349 +21373 +21984 +155 +19500 +21985 +21986 +345 +1912 +19618 +573 +3548 +9 +21987 +797 +21988 +10789 +21947 +14001 +21989 +15718 +286 +736 +4028 +1300 +8334 +2372 +3546 +2260 +21990 +21991 +736 +736 +2733 +43 +4364 +19 +21992 +5085 +14 +21993 +21994 +3546 +21995 +345 +21996 +155 +683 +14477 +38 +21997 +43 +21998 +19472 +21999 +736 +736 +7053 +14 +22000 +22001 +7032 +22002 +22003 +14 +686 +19 +22004 +648 +590 +43 +22005 +16437 +22006 +272 +22 +21631 +134 +1481 +22007 +9 +827 +5438 +3978 +22008 +345 +19 +3296 +22009 +10791 +19618 +21947 +43 +15461 +1542 +22010 +43 +22011 +9 +9 +12005 +22012 +887 +1765 +19404 +22013 +14 +14604 +21947 +22014 +57 +12788 +15220 +22015 +22016 +4 +21681 +11282 +19 +4 +12166 +2734 +22017 +3546 +590 +21698 +22018 +22019 +21776 +14 +22020 +13564 +345 +2 +22021 +155 +22022 +22023 +15595 +164 +22024 +57 +21088 +22025 +16205 +862 +9 +22026 +53 +22027 +3546 +22028 +57 +22029 +4388 +22030 +22031 +104 +8244 +1425 +22032 +22033 +22034 +80 +2289 +22035 +21689 +14363 +15718 +22036 +1604 +38 +823 +5083 +22037 +14 +21947 +22038 +2234 +21947 +22039 +19 +590 +936 +345 +2197 +6776 +22040 +22041 +15718 +17515 +16609 +32 +22042 +22043 +48 +22044 +137 +8307 +14 +590 +22045 +21315 +2935 +22046 +15718 +22047 +22048 +3546 +872 +22049 +554 +22050 +7717 +2 +590 +22051 +590 +22 +22052 +9688 +13721 +22053 +5780 +22054 +357 +1310 +22055 +4 +22056 +284 +19 +35 +19 +19 +519 +19 +248 +22057 +16437 +590 +22058 +14477 +2476 +1870 +20555 +3546 +22059 +22060 +13361 +11321 +1961 +2561 +16437 +19 +22061 +19 +13721 +22062 +22063 +16693 +21689 +1049 +58 +21947 +22064 +3546 +6741 +1696 +22065 +3598 +284 +248 +9 +590 +14 +14 +22066 +22067 +590 +13529 +1109 +22068 +21947 +22069 +590 +16484 +213 +22070 +22071 +4055 +22072 +22073 +22074 +19939 +22075 +20199 +590 +3546 +736 +22076 +19655 +17571 +22077 +303 +80 +13675 +22078 +11471 +8351 +7716 +9 +736 +22079 +1047 +14 +22080 +46 +18209 +22081 +7078 +3546 +303 +21947 +8668 +500 +590 +365 +4502 +20 +2804 +22082 +43 +2064 +14001 +14363 +337 +228 +22083 +22084 +22085 +1013 +3546 +201 +8226 +250 +22086 +2640 +474 +22087 +22088 +6496 +43 +22089 +19618 +21947 +1559 +3 +1425 +1066 +358 +11321 +22090 +22091 +8668 +22092 +9 +22093 +22094 +22095 +14603 +155 +681 +840 +15718 +1181 +22096 +10407 +209 +269 +9 +3317 +554 +14477 +21947 +22097 +213 +595 +701 +21947 +209 +2550 +22098 +354 +22099 +22100 +20305 +590 +22101 +5457 +436 +21947 +8668 +14 +248 +155 +15718 +16844 +16443 +13150 +15 +2733 +201 +19 +22102 +22103 +590 +22104 +22105 +209 +22106 +19 +1091 +20803 +22107 +1160 +10 +317 +590 +22108 +22109 +19618 +4056 +14 +14000 +22110 +823 +4752 +22111 +484 +43 +24 +4414 +22112 +22113 +22114 +11685 +2764 +9705 +21776 +15476 +22115 +1710 +22116 +22117 +5085 +22118 +22119 +19404 +22120 +57 +2577 +11762 +43 +3353 +1208 +22121 +22122 +1352 +736 +57 +15 +22123 +22124 +12987 +22125 +155 +22126 +2733 +3875 +3684 +14 +2139 +13721 +22127 +22128 +671 +22129 +19 +22130 +2577 +22131 +869 +15 +22132 +6571 +736 +171 +22133 +1384 +707 +1502 +22134 +43 +764 +3 +14 +43 +12603 +169 +22135 +22136 +29 +3546 +77 +5204 +22137 +22138 +43 +22139 +4055 +21947 +3220 +196 +22140 +22141 +22142 +8297 +14 +43 +14603 +1680 +16234 +22143 +22144 +21947 +155 +22145 +36 +2911 +12588 +22146 +21947 +22147 +1605 +9 +19 +22148 +6612 +1199 +22149 +21947 +22150 +1332 +43 +19404 +22151 +21947 +349 +16826 +22152 +4174 +7137 +1863 +3546 +22153 +1384 +14604 +2476 +1181 +22154 +22155 +3601 +8668 +13961 +20 +89 +22156 +20 +22157 +22158 +21338 +8234 +4979 +22159 +22160 +21947 +694 +665 +16450 +2410 +22161 +13721 +14 +22162 +345 +250 +22163 +1300 +19218 +22164 +22165 +19 +519 +14 +21745 +5976 +7053 +736 +22166 +22167 +38 +20952 +554 +15718 +286 +22168 +14 +21778 +22169 +3553 +22015 +22170 +22171 +345 +7855 +8566 +2577 +22172 +3546 +671 +1011 +21689 +19618 +22173 +22174 +286 +22175 +11754 +1326 +22176 +22177 +18695 +377 +554 +22178 +21869 +736 +22179 +11212 +13566 +43 +286 +14 +590 +22180 +98 +22181 +22182 +22183 +19209 +22184 +22185 +17011 +1316 +22186 +590 +22187 +169 +14 +22188 +15718 +20 +22189 +5209 +22190 +22191 +22192 +209 +14856 +3546 +22193 +22194 +22195 +22196 +4028 +43 +1864 +286 +14604 +5780 +22197 +22198 +237 +19618 +4552 +1090 +43 +22199 +8214 +7747 +576 +21904 +1181 +43 +19 +22200 +22201 +16826 +22202 +32 +22203 +22204 +22205 +13493 +699 +19635 +22 +21947 +22206 +11341 +22207 +646 +1742 +19 +22208 +1853 +19618 +5344 +43 +14 +22209 +591 +22210 +2260 +22211 +2561 +14477 +4450 +13721 +19519 +590 +22212 +2035 +22213 +9095 +12404 +7835 +19618 +823 +22214 +19618 +43 +22215 +1112 +22216 +22217 +15583 +3995 +57 +22218 +19 +22219 +3601 +448 +14363 +19844 +1112 +22220 +8255 +22221 +14477 +9 +736 +22222 +736 +10 +910 +14 +155 +10392 +21947 +725 +2872 +16822 +22223 +15586 +22224 +22225 +1425 +43 +1013 +22226 +22227 +22228 +764 +22229 +22230 +22231 +43 +21947 +13721 +22232 +19 +22233 +19 +590 +19404 +2577 +22234 +22235 +57 +22236 +22237 +18982 +2577 +3470 +43 +22238 +19618 +22239 +519 +345 +1154 +736 +6095 +22240 +3172 +13721 +20058 +19 +590 +22241 +12300 +22242 +22243 +17670 +29 +19618 +7053 +590 +4650 +10 +43 +15718 +3330 +2577 +19 +22244 +1134 +8936 +286 +21031 +14 +2830 +931 +14420 +15044 +3369 +142 +21999 +13355 +22245 +22246 +15718 +736 +22247 +20572 +14604 +3546 +20679 +19618 +2790 +17464 +8668 +2042 +8351 +7037 +22248 +22249 +1364 +22250 +14 +14102 +19618 +22251 +43 +22158 +2449 +1559 +22252 +209 +22253 +43 +22254 +19 +1425 +22255 +22 +22256 +2415 +9194 +22257 +22258 +22259 +590 +22260 +19852 +22261 +2928 +22262 +720 +22263 +19404 +713 +19655 +590 +7379 +21698 +554 +22264 +43 +8188 +8297 +3601 +185 +18695 +3546 +7516 +8037 +201 +1563 +22265 +3546 +21947 +22266 +14482 +22267 +22268 +590 +22269 +613 +57 +155 +3657 +625 +22270 +22271 +20 +1066 +22272 +764 +2561 +21947 +18798 +14 +196 +22273 +22274 +22275 +22276 +21947 +22277 +21947 +14 +22278 +5773 +22279 +155 +11762 +3 +22280 +4028 +167 +379 +14856 +6096 +57 +2065 +15718 +2 +22281 +14603 +21338 +2 +1100 +16589 +22282 +22283 +22284 +590 +345 +1912 +338 +22285 +22286 +764 +22287 +823 +590 +15569 +20 +13943 +57 +3546 +21088 +22288 +3546 +5438 +19342 +22289 +17687 +345 +21947 +14 +14 +286 +4441 +22290 +15 +22291 +185 +22292 +14 +22293 +20 +22294 +22295 +2764 +22296 +22297 +21947 +19404 +736 +15324 +22298 +13721 +873 +21947 +1115 +22299 +21947 +22300 +13566 +2 +11471 +345 +155 +11762 +21947 +179 +22301 +22302 +4075 +17602 +2733 +22303 +8188 +1508 +21947 +16102 +14 +7242 +736 +22304 +19655 +22305 +137 +43 +43 +22306 +2 +22307 +3546 +13111 +22308 +22309 +15229 +14 +3546 +22310 +80 +14 +286 +4502 +1095 +6335 +8668 +15 +43 +2121 +22311 +18503 +286 +412 +22312 +22313 +11966 +15 +286 +22314 +11341 +22315 +15054 +253 +15054 +14524 +43 +8367 +2019 +21947 +22316 +7053 +2629 +19 +22317 +22318 +22319 +178 +2537 +5773 +20555 +22320 +9 +22321 +22322 +22323 +8021 +20877 +736 +554 +22324 +22325 +3546 +21947 +21947 +21947 +89 +13721 +22326 +1533 +2882 +19 +272 +43 +3559 +22327 +22328 +22329 +6766 +22330 +22331 +3546 +22332 +20616 +22333 +12987 +22334 +19618 +22335 +677 +22336 +349 +22337 +21689 +707 +8668 +590 +7855 +22338 +1529 +345 +22339 +22340 +89 +6766 +9 +22341 +9 +20991 +22342 +22343 +1011 +15683 +590 +140 +1051 +176 +20952 +22344 +12696 +13721 +2287 +21947 +19472 +1529 +165 +21947 +8297 +22345 +22346 +22347 +3546 +22348 +7137 +677 +22349 +14 +7137 +2 +242 +1364 +9389 +67 +21947 +22350 +22351 +22352 +22353 +22354 +22355 +21689 +22356 +16340 +5085 +43 +43 +22357 +4502 +43 +8668 +22041 +345 +14 +248 +22358 +10793 +22359 +22360 +22361 +665 +1571 +13260 +14 +22362 +167 +22363 +823 +22364 +22365 +21947 +22366 +16453 +19852 +1208 +590 +43 +736 +1961 +7053 +14532 +16437 +21947 +1112 +22367 +22368 +17340 +345 +19797 +1013 +29 +43 +823 +46 +9 +21947 +7053 +22369 +8220 +22370 +19404 +43 +172 +14 +22371 +19404 +22372 +228 +21947 +12584 +3546 +22373 +677 +22374 +21777 +9 +8508 +22375 +5039 +22376 +9 +12404 +20803 +8297 +19404 +915 +21889 +43 +22377 +590 +9 +237 +495 +15308 +1961 +22378 +20876 +2593 +9 +22379 +22380 +43 +720 +22381 +34 +22382 +22383 +3775 +15 +7137 +554 +22384 +345 +43 +98 +7183 +7176 +14 +15718 +590 +345 +38 +22385 +22386 +286 +22387 +590 +5780 +1423 +22388 +22389 +983 +2310 +22390 +1316 +155 +1169 +4756 +6560 +19655 +1976 +22391 +14 +590 +9024 +22392 +22393 +22394 +7835 +14477 +7174 +22395 +22396 +22397 +590 +915 +1696 +1214 +22398 +19404 +21031 +515 +22399 +1307 +22400 +21507 +14524 +872 +12596 +22401 +21947 +22402 +2537 +15 +15718 +22403 +22404 +22405 +825 +590 +43 +22406 +7855 +8458 +22407 +22408 +379 +22409 +19618 +21947 +22410 +22411 +9 +22412 +3978 +22413 +22414 +209 +15 +16378 +3546 +2795 +22415 +32 +22416 +22417 +20199 +1091 +3546 +14363 +22418 +22419 +22420 +6095 +22421 +590 +21689 +22422 +43 +22423 +3353 +22424 +15238 +32 +2577 +14363 +22425 +22426 +22427 +22428 +7855 +1834 +13721 +176 +19655 +22429 +21947 +2019 +14 +22430 +20199 +22065 +19618 +14 +3546 +514 +22431 +22432 +22433 +22434 +590 +736 +22435 +20952 +18045 +6939 +22308 +22196 +665 +17277 +1316 +7835 +14689 +22436 +586 +29 +677 +22437 +17247 +22438 +2 +19057 +16609 +22439 +22440 +415 +13721 +22441 +590 +736 +22442 +17920 +19655 +13375 +19793 +14 +8465 +1765 +6950 +20819 +22443 +22444 +22307 +22445 +13030 +19655 +22446 +22447 +13721 +15718 +32 +22448 +193 +22449 +9410 +43 +590 +3553 +3251 +22450 +22451 +2314 +22452 +5780 +345 +533 +736 +15 +22453 +3546 +155 +2410 +66 +4313 +3546 +13721 +736 +19 +22454 +14 +178 +809 +22455 +22456 +736 +22457 +14604 +1688 +22458 +22459 +1112 +19 +22460 +2514 +21776 +11754 +10004 +17151 +598 +22461 +10381 +345 +14025 +284 +15718 +872 +155 +7053 +14 +1559 +22462 +22463 +22464 +1203 +22465 +22466 +22467 +5764 +5314 +13721 +9 +14001 +18184 +19 +22468 +1745 +286 +18823 +358 +15718 +22469 +12220 +13474 +21045 +22470 +8668 +57 +590 +22471 +22472 +12864 +303 +32 +2135 +14477 +22473 +22474 +2459 +22475 +22476 +11934 +22477 +248 +22478 +22479 +736 +349 +43 +22480 +22481 +22482 +590 +121 +22483 +22484 +22485 +14603 +19119 +14 +14 +20228 +22486 +14 +7987 +286 +3192 +1234 +14 +22487 +248 +21107 +3416 +22488 +568 +21947 +14477 +22489 +5387 +736 +11428 +9 +22490 +213 +3978 +14603 +17470 +5502 +32 +17277 +14603 +4747 +10 +22491 +213 +14 +13721 +22492 +76 +337 +22493 +21947 +16826 +17302 +213 +9 +3421 +337 +176 +21947 +22494 +22495 +2064 +2356 +22496 +22497 +22498 +20708 +18047 +736 +22499 +345 +3546 +21947 +21947 +22500 +4 +5420 +21947 +590 +22501 +345 +1961 +14 +15718 +43 +736 +43 +20 +3407 +590 +21947 +155 +43 +22502 +22308 +22503 +201 +22504 +1559 +22505 +158 +22506 +554 +22507 +9 +13721 +5441 +22508 +22509 +43 +22510 +43 +1038 +22511 +303 +22512 +823 +11754 +22513 +5780 +21031 +43 +17412 +22514 +22515 +7053 +1820 +17871 +8668 +22 +22516 +590 +22517 +32 +2577 +14 +22518 +22519 +19655 +13721 +1442 +21947 +13150 +22520 +8961 +22521 +22522 +1060 +590 +13495 +17911 +22523 +22524 +22525 +22526 +12117 +22527 +15356 +21947 +22528 +286 +52 +2 +14179 +286 +14363 +22529 +22530 +22308 +19 +1508 +1696 +16826 +22012 +22531 +7053 +22532 +8094 +22533 +15207 +22534 +6171 +19624 +17062 +19655 +3546 +936 +22535 +22536 +43 +590 +22537 +15718 +323 +2310 +590 +22538 +22539 +9 +3 +399 +13150 +22540 +57 +22541 +13913 +868 +22542 +3546 +19618 +590 +323 +19618 +13721 +286 +19939 +5780 +22420 +19618 +15718 +3546 +21947 +1508 +21947 +22543 +248 +22544 +15718 +14 +22545 +790 +9123 +1423 +4502 +345 +18045 +5085 +22546 +22547 +22548 +5344 +4 +22549 +22550 +153 +43 +4765 +2035 +7053 +14 +2593 +301 +22551 +22552 +2804 +22553 +1180 +43 +1514 +57 +99 +18882 +22554 +345 +57 +349 +19995 +22555 +5080 +5601 +57 +3978 +323 +22556 +665 +43 +22557 +1115 +15718 +22558 +43 +337 +21947 +22559 +22560 +35 +16258 +10 +22561 +13721 +1090 +345 +14079 +5908 +19618 +14343 +1961 +14 +272 +17608 +590 +411 +19618 +22562 +19 +16437 +22563 +19404 +19220 +22564 +22565 +2 +14 +20 +22566 +16437 +22567 +43 +10245 +15 +22568 +22569 +4403 +2851 +6468 +2818 +14808 +872 +2015 +713 +7991 +2579 +7291 +21947 +22570 +6372 +9 +597 +25 +2694 +22571 +586 +22572 +22573 +1666 +22268 +14856 +2577 +22574 +43 +22575 +14 +19852 +3546 +22576 +22577 +22578 +536 +22579 +22580 +22581 +19 +1364 +19 +22582 +22583 +19740 +46 +22584 +22585 +736 +14477 +9 +22586 +20555 +19618 +1048 +13721 +155 +18038 +19838 +3452 +13721 +22587 +22588 +222 +22589 +22 +398 +2446 +286 +22590 +8685 +22591 +3908 +823 +17136 +57 +303 +16992 +16443 +1415 +22592 +3491 +22593 +22594 +272 +14477 +19618 +22595 +12404 +6122 +201 +22596 +20765 +519 +1914 +303 +43 +2919 +15 +57 +22597 +398 +3484 +43 +590 +590 +14 +19618 +201 +22598 +5100 +14 +647 +21107 +16826 +17267 +18517 +823 +3553 +770 +10 +22599 +22600 +22601 +464 +225 +22602 +43 +1011 +57 +22603 +19 +22604 +1524 +284 +1224 +22605 +18503 +43 +284 +14 +43 +22606 +22607 +286 +22608 +345 +15718 +22609 +29 +7835 +14604 +22610 +286 +22611 +213 +17855 +22612 +14 +22613 +22614 +2316 +43 +16437 +1442 +22615 +22616 +4441 +22617 +22618 +303 +519 +22619 +43 +15845 +155 +736 +345 +9 +349 +22620 +677 +590 +22621 +12404 +22622 +10 +22623 +22624 +15881 +590 +16899 +590 +12858 +4907 +8668 +22625 +16798 +22626 +548 +17859 +345 +14 +18686 +1287 +647 +22627 +22628 +43 +21053 +22629 +399 +590 +22630 +10999 +4441 +22631 +22632 +13721 +21947 +15718 +2769 +22633 +22634 +823 +21947 +22635 +22636 +209 +2 +188 +345 +8981 +18978 +7577 +20575 +284 +303 +345 +1222 +22637 +19618 +22638 +18896 +22639 +6095 +22640 +22641 +22268 +15645 +2 +20 +179 +22642 +1048 +17136 +345 +14477 +22643 +21947 +43 +10318 +3546 +38 +8351 +8355 +19 +22644 +22645 +22308 +9 +6877 +1696 +2446 +22646 +590 +1823 +16975 +22647 +21947 +15951 +11822 +590 +22648 +1300 +349 +1605 +22649 +22650 +15718 +276 +15914 +21947 +14 +22651 +46 +22652 +22653 +14420 +21947 +590 +19404 +337 +2561 +22654 +21689 +22655 +201 +484 +2 +248 +22656 +19404 +10 +270 +22657 +22658 +6741 +279 +345 +14604 +22659 +22660 +22661 +345 +20555 +22662 +8351 +554 +6776 +19 +12404 +21947 +17404 +519 +13807 +43 +590 +1927 +22663 +1531 +22664 +9 +5117 +1226 +11321 +590 +2756 +22665 +22666 +57 +303 +345 +337 +22667 +22668 +43 +16947 +3491 +22669 +22670 +286 +43 +22671 +22672 +35 +2356 +9837 +436 +22673 +6505 +671 +22674 +286 +22675 +8668 +16322 +2015 +22676 +22677 +22678 +22679 +13700 +43 +538 +22680 +12684 +22681 +7053 +590 +19618 +5780 +2577 +43 +9 +16437 +9 +683 +21947 +22682 +740 +22683 +11762 +286 +5119 +18869 +43 +155 +1203 +22684 +5780 +22685 +7276 +60 +590 +22686 +1955 +32 +10230 +22687 +323 +22688 +303 +1423 +2768 +21889 +349 +20 +284 +22689 +590 +7379 +2 +1577 +22690 +823 +3546 +6096 +43 +736 +57 +541 +22028 +3546 +19618 +1013 +10782 +1739 +22691 +57 +196 +15718 +22692 +22693 +22694 +43 +6496 +1465 +2310 +1091 +15690 +20 +43 +18257 +22695 +20 +43 +2550 +358 +411 +448 +13721 +7053 +22696 +22697 +209 +284 +22698 +17956 +13721 +22699 +849 +495 +12152 +14 +345 +30 +22700 +14 +22701 +21694 +590 +345 +21947 +3 +8246 +22702 +9 +20 +22703 +20132 +9 +7585 +541 +22704 +5085 +373 +22705 +823 +155 +32 +272 +6950 +22706 +7855 +19 +16102 +13578 +22707 +22708 +22709 +98 +4827 +2035 +11762 +22710 +22711 +14477 +22712 +22713 +22714 +6496 +3546 +6114 +19136 +14 +22715 +6518 +14 +22716 +20572 +1637 +13452 +14 +22717 +57 +22718 +331 +22719 +22720 +21947 +43 +22721 +22722 +18792 +22723 +22724 +15718 +22725 +344 +2764 +57 +32 +77 +14604 +22726 +959 +823 +1765 +590 +19655 +22727 +14 +3866 +21947 +2577 +22728 +21689 +9 +19852 +21947 +9 +4502 +286 +22729 +22730 +14 +22731 +2 +2 +1082 +3601 +823 +19 +22732 +15 +22 +22268 +21947 +22733 +22734 +2260 +22735 +19618 +3546 +13721 +22268 +19655 +1720 +720 +25 +32 +1792 +286 +519 +22736 +22737 +21947 +21331 +22738 +2 +11482 +22739 +21947 +15718 +3601 +590 +590 +1364 +1648 +22740 +8668 +1203 +22741 +22742 +9738 +18064 +22743 +15718 +22744 +22745 +43 +10274 +9 +18695 +19266 +2009 +18798 +13721 +1765 +5791 +19618 +15720 +22746 +278 +22747 +9 +22748 +22749 +19229 +9563 +22750 +20499 +22308 +22751 +22752 +19618 +345 +19618 +22753 +22754 +22755 +790 +22756 +22757 +14856 +18484 +21947 +22758 +22759 +19618 +5267 +1559 +22760 +43 +10848 +7624 +9 +2790 +397 +1229 +18512 +5085 +20657 +19 +22761 +19618 +18896 +22762 +1991 +22763 +1524 +22764 +13801 +22765 +22766 +22767 +19970 +5489 +22768 +13405 +590 +9 +19618 +12230 +14477 +1234 +19491 +263 +22769 +3546 +1364 +22770 +21947 +22771 +358 +22772 +1571 +43 +22773 +249 +4684 +2744 +29 +22774 +60 +15914 +1559 +286 +8249 +22775 +10848 +265 +22776 +15167 +22777 +22778 +7046 +3546 +22599 +14 +19 +15618 +22779 +554 +13179 +20 +85 +2259 +286 +22780 +8668 +2577 +3978 +1352 +736 +2733 +397 +5438 +22781 +1051 +22782 +1423 +188 +5197 +5773 +22783 +22784 +22785 +15 +14079 +15031 +178 +736 +770 +22786 +519 +22787 +21947 +19655 +10790 +22788 +22789 +5299 +22790 +1107 +345 +2243 +137 +22791 +19 +22792 +21947 +19655 +1109 +19 +9 +16 +21947 +22793 +17973 +2 +21947 +22794 +22795 +35 +9837 +22796 +2 +43 +22797 +22798 +2697 +4125 +3546 +5085 +22799 +22800 +188 +1612 +11822 +22801 +13508 +9913 +22802 +590 +22803 +22804 +22805 +22806 +4765 +22807 +14 +22808 +736 +11509 +1423 +345 +14079 +22809 +15718 +4367 +22810 +22811 +57 +15914 +286 +21947 +22812 +19852 +373 +22813 +13721 +22814 +22815 +22816 +22817 +19160 +22818 +14 +19792 +822 +7835 +155 +349 +22819 +22820 +345 +22821 +10137 +32 +2040 +2577 +21947 +22822 +1553 +20 +18047 +22823 +155 +13721 +21947 +3067 +14 +155 +15 +22824 +22825 +1812 +22826 +345 +2577 +7451 +992 +22827 +22828 +22829 +1157 +10146 +590 +1214 +21947 +590 +22830 +80 +22831 +1112 +5650 +2042 +736 +22832 +21947 +22833 +22 +176 +21841 +22834 +22835 +13143 +7256 +21947 +18683 +32 +22836 +43 +6480 +590 +8508 +4990 +1109 +11029 +7053 +22837 +22838 +19618 +99 +22839 +345 +20 +15718 +22840 +936 +22841 +3978 +14524 +8999 +349 +22842 +345 +3546 +19618 +22843 +22844 +484 +597 +12194 +22845 +10031 +345 +137 +43 +22846 +19 +22847 +22308 +7855 +464 +3543 +43 +265 +32 +22 +22848 +22849 +13721 +15824 +22850 +22851 +14276 +22852 +19618 +16695 +22853 +17385 +16402 +915 +4906 +5599 +19618 +736 +6627 +59 +46 +43 +5326 +286 +2577 +22124 +22854 +22855 +22856 +590 +9143 +16437 +5649 +22857 +22858 +22859 +272 +14 +345 +22860 +43 +213 +213 +22861 +590 +21947 +22862 +15068 +736 +21947 +22863 +89 +22864 +10737 +2694 +14604 +9 +2410 +22865 +665 +22866 +18896 +21947 +713 +736 +22867 +19160 +21030 +345 +22868 +4227 +5780 +22869 +284 +286 +9 +22870 +22871 +22872 +8465 +2310 +14363 +213 +9 +22873 +17790 +3546 +20942 +22874 +19737 +22875 +915 +9 +22876 +138 +22877 +22878 +1559 +272 +823 +22879 +22420 +22880 +22881 +22882 +22883 +590 +1290 +22884 +2804 +14 +9 +2000 +22885 +484 +18951 +22886 +1090 +770 +248 +19 +22308 +22887 +22888 +22268 +6883 +13528 +21689 +115 +2415 +43 +7835 +22889 +14 +4313 +18798 +22890 +1901 +21947 +14 +22891 +22892 +22893 +14 +19618 +590 +22894 +14 +19618 +5837 +20572 +10 +9 +1091 +770 +538 +379 +19 +590 +20 +43 +22895 +4364 +22896 +19792 +22897 +11480 +5780 +22898 +19618 +13721 +22899 +736 +590 +19852 +57 +10256 +590 +8849 +22900 +15167 +13721 +8566 +14404 +14477 +22901 +345 +22902 +14477 +21947 +1385 +6950 +22903 +22904 +8393 +15718 +35 +845 +19618 +286 +4808 +22905 +3095 +3546 +2260 +694 +7231 +13721 +22906 +7364 +22907 +43 +22908 +22909 +2314 +155 +15718 +20 +345 +554 +22910 +10151 +3291 +1082 +22911 +533 +22912 +1012 +2804 +22865 +5791 +22913 +11754 +22914 +22915 +1920 +3544 +22916 +14477 +4414 +43 +43 +22917 +98 +22918 +22919 +14 +3435 +22920 +648 +20949 +736 +22921 +22922 +20803 +19 +3546 +9 +303 +22923 +22924 +19 +736 +3406 +138 +19618 +337 +12621 +22925 +17466 +22926 +5085 +590 +9156 +22927 +3546 +616 +8249 +22928 +3546 +22929 +9578 +14604 +43 +22930 +19404 +66 +20572 +22931 +22407 +15419 +22932 +22933 +590 +764 +53 +22934 +519 +22935 +365 +13721 +736 +5725 +18061 +284 +19478 +9410 +22936 +19 +32 +21947 +554 +590 +22937 +764 +19 +349 +14363 +24 +22938 +22939 +4441 +21947 +616 +22940 +22941 +19618 +2243 +18448 +590 +15914 +22942 +1437 +712 +22943 +22944 +286 +22945 +58 +712 +248 +8103 +14679 +1716 +21947 +1943 +22946 +114 +22947 +3546 +1606 +19 +11754 +22948 +4263 +15989 +19618 +16102 +22949 +22950 +19618 +22951 +19 +337 +1612 +19206 +19618 +8566 +17687 +3553 +22855 +43 +19618 +730 +2253 +15718 +1021 +22952 +17043 +22953 +274 +22954 +21693 +14 +1310 +345 +22955 +15973 +22956 +22957 +303 +14770 +196 +19 +19852 +22958 +7137 +21947 +17553 +3291 +44 +303 +21947 +22959 +22960 +1082 +4502 +10239 +5476 +22961 +13721 +2834 +3546 +19 +736 +14 +345 +29 +19655 +22962 +22963 +5215 +22964 +209 +590 +22965 +22409 +22966 +590 +222 +22967 +18345 +533 +4518 +32 +915 +14001 +22968 +4683 +1100 +1605 +22969 +736 +2419 +43 +22970 +7835 +533 +597 +15623 +1503 +14604 +19 +345 +873 +1289 +66 +57 +22971 +19 +4278 +22972 +19 +3626 +915 +9 +22973 +22974 +19797 +5764 +9986 +22975 +6883 +22976 +57 +19618 +14 +21947 +22977 +3546 +11321 +2926 +736 +500 +3546 +222 +21947 +21947 +16024 +22978 +22979 +3276 +17112 +8668 +736 +22980 +22981 +22982 +60 +22983 +22984 +22985 +22986 +22987 +9 +15718 +22988 +22989 +538 +22990 +7835 +20390 +22991 +14 +1115 +43 +29 +286 +19 +12743 +19924 +22992 +22993 +22994 +4441 +7053 +9 +18440 +22995 +761 +19489 +22996 +22997 +22998 +5780 +3626 +3546 +22999 +142 +23000 +23001 +23002 +286 +15 +3546 +23003 +23004 +14603 +286 +3491 +13721 +21947 +17799 +16437 +23005 +23006 +43 +303 +23007 +13168 +323 +3973 +379 +14477 +23008 +827 +23009 +22308 +23010 +1012 +23011 +1612 +665 +16826 +43 +23012 +2243 +720 +16981 +23013 +7835 +23014 +23015 +12916 +23016 +248 +284 +284 +1905 +46 +590 +590 +209 +2577 +23017 +23018 +19965 +23019 +19 +823 +590 +15718 +354 +412 +10338 +23020 +18882 +19 +15 +35 +21045 +15068 +1513 +23021 +19 +19618 +1688 +23022 +21947 +23023 +22 +15718 +23024 +2983 +337 +20280 +284 +19918 +11192 +13721 +284 +16477 +11274 +22268 +345 +12987 +8460 +3816 +671 +4808 +23025 +249 +286 +23026 +213 +6095 +14 +15513 +23027 +23028 +15 +23029 +1442 +19655 +19404 +23030 +1356 +1513 +23031 +12560 +6766 +32 +23032 +21947 +23033 +272 +9396 +23034 +23035 +338 +2459 +22922 +284 +7032 +14 +23036 +736 +1765 +337 +23037 +21947 +8255 +590 +248 +23038 +23039 +248 +2 +590 +23040 +250 +8566 +23041 +10781 +11762 +23042 +1870 +137 +23043 +590 +21947 +57 +16437 +32 +745 +5990 +10063 +7444 +2790 +2135 +43 +21947 +19965 +15718 +57 +3546 +23044 +9 +721 +23045 +213 +23046 +23047 +32 +19 +23048 +2 +13908 +15496 +11754 +3546 +98 +23049 +23050 +23051 +23052 +23053 +23054 +18695 +2197 +14 +19618 +23055 +286 +590 +23056 +15845 +19 +1698 +14477 +23057 +23058 +13570 +514 +23059 +23060 +23061 +7208 +23062 +1021 +23063 +23064 +43 +43 +23065 +286 +1559 +23066 +9 +13721 +8188 +9 +23067 +18744 +736 +7666 +23068 +155 +14 +345 +23069 +23070 +23071 +3551 +32 +286 +23072 +720 +5085 +23073 +736 +240 +2008 +23074 +2042 +19 +2476 +23075 +5119 +23076 +910 +1529 +21947 +23077 +1172 +349 +12337 +1100 +23078 +18695 +6449 +23079 +16 +9 +2260 +8188 +23080 +6786 +736 +23081 +23082 +590 +19 +23083 +13801 +23084 +15718 +109 +736 +19618 +23085 +23086 +43 +13721 +286 +14 +11283 +3601 +23087 +23088 +8668 +1090 +590 +23089 +12531 +9 +3546 +2561 +20 +18792 +823 +1386 +23090 +23091 +2561 +2026 +20087 +35 +14 +338 +23092 +345 +8297 +4441 +9 +345 +23093 +286 +21947 +32 +23094 +3601 +23095 +23096 +23097 +790 +11321 +1300 +713 +23098 +533 +20442 +23099 +17903 +4166 +9 +15 +2309 +21947 +23100 +23101 +10 +23102 +23103 +23104 +2 +3543 +23105 +1082 +22236 +14 +23106 +23063 +11762 +16178 +15720 +2260 +21947 +9 +2944 +23107 +764 +23108 +19618 +14343 +10163 +286 +23109 +23110 +23111 +1310 +4634 +554 +23112 +21947 +349 +1051 +586 +9788 +386 +3946 +18503 +23113 +23114 +12307 +18503 +1169 +398 +1051 +345 +590 +43 +19456 +23115 +345 +86 +590 +17360 +96 +250 +23116 +23117 +14477 +1181 +707 +23118 +13721 +43 +32 +137 +21689 +23119 +23120 +23121 +89 +21947 +21947 +7053 +23122 +274 +43 +915 +23123 +590 +23124 +519 +23125 +23126 +5611 +9 +53 +23127 +1524 +13754 +23128 +21947 +6571 +23129 +23130 +1425 +23131 +43 +1688 +349 +23132 +590 +1765 +19 +3546 +155 +179 +9410 +1190 +317 +9 +23133 +23134 +23135 +17670 +12402 +23136 +1356 +9577 +18807 +12479 +20952 +23137 +349 +23138 +645 +3978 +19618 +23139 +23140 +23141 +23142 +1559 +19 +11341 +10 +23143 +14 +5326 +23144 +23145 +5110 +12203 +23146 +23147 +14 +590 +23148 +15718 +3601 +3649 +20785 +155 +23149 +3544 +1605 +23150 +19 +3546 +868 +23151 +23152 +23153 +14477 +586 +1051 +23154 +23155 +1224 +6095 +14 +57 +590 +736 +3546 +23156 +8566 +57 +3546 +1095 +46 +19 +21947 +209 +23157 +9 +23158 +590 +23159 +23160 +3385 +23161 +23162 +683 +16826 +2 +18862 +23163 +1052 +23164 +590 +4677 +21689 +720 +19404 +23165 +23166 +2 +377 +5099 +19618 +736 +9 +23167 +2121 +590 +32 +736 +1382 +379 +3546 +14342 +274 +23168 +20803 +23169 +14 +178 +560 +23170 +23171 +18695 +23172 +19 +22 +1612 +590 +22474 +14604 +2414 +16437 +823 +3546 +43 +23173 +23174 +19 +2577 +7137 +8297 +14 +15810 +23175 +21031 +14693 +345 +23176 +19795 +18978 +209 +832 +20803 +2 +249 +14621 +23177 +590 +23178 +1310 +736 +23179 +23180 +3553 +43 +1710 +13721 +57 +9422 +14 +21947 +43 +23181 +16 +22 +1517 +23182 +7940 +9 +19095 +11522 +23183 +809 +23184 +23185 +23186 +23187 +32 +1593 +3034 +23188 +23189 +32 +736 +15914 +15 +23190 +3546 +23191 +23192 +20 +2 +23193 +9 +23194 +1149 +2 +21947 +5780 +23195 +23196 +32 +616 +22282 +23197 +23198 +1847 +286 +250 +23199 +201 +23200 +21947 +222 +23201 +12005 +790 +23202 +827 +23203 +14 +15471 +573 +11 +703 +23204 +43 +23205 +399 +19618 +9 +43 +23206 +736 +3559 +590 +2234 +2061 +16437 +18503 +823 +57 +23207 +272 +23208 +7208 +23209 +6480 +23210 +22057 +1812 +23211 +57 +345 +9 +155 +32 +590 +23212 +377 +23213 +8668 +365 +14 +23214 +5218 +4441 +20 +1698 +21947 +20555 +43 +21947 +23215 +272 +20373 +3546 +23216 +2476 +9 +19 +23217 +286 +20864 +9 +14814 +2550 +1332 +23218 +43 +8392 +18798 +15718 +14477 +23219 +35 +20616 +15718 +23220 +23221 +23222 +19 +7835 +370 +19404 +4816 +23223 +1517 +19618 +23224 +23225 +23226 +16102 +23227 +590 +14001 +18695 +3119 +16825 +9 +23228 +357 +23229 +14 +842 +43 +823 +323 +286 +32 +23230 +23231 +23232 +23233 +3 +345 +1992 +43 +13721 +43 +971 +15 +23234 +7945 +12120 +23235 +23208 +23236 +13721 +16437 +822 +43 +2 +23237 +23238 +1513 +23239 +9 +14477 +23240 +20085 +23241 +8392 +23242 +8476 +23243 +23244 +14 +19618 +13207 +23245 +22618 +23246 +19 +23247 +23248 +23249 +9 +23250 +23251 +7167 +14343 +11551 +23252 +3546 +9 +23103 +3 +23253 +23254 +23255 +18376 +1823 +19404 +19 +1051 +14 +23256 +286 +590 +613 +16121 +43 +23257 +23258 +2249 +23259 +19 +23260 +736 +19618 +23261 +14001 +683 +60 +21689 +5614 +9939 +43 +23262 +5757 +3546 +590 +43 +1867 +590 +35 +720 +13721 +23263 +11209 +21627 +19335 +5851 +13721 +23264 +23265 +13484 +23266 +13721 +23267 +14 +21947 +23268 +15 +558 +43 +13150 +19404 +22041 +23269 +23270 +15 +23271 +15914 +7962 +23272 +15541 +15167 +6354 +590 +15718 +23273 +23274 +17571 +23275 +1051 +23226 +349 +19618 +5022 +155 +142 +23276 +23277 +18778 +736 +9 +286 +155 +23278 +23279 +19143 +23280 +23281 +15718 +647 +23282 +23111 +10 +23283 +1716 +4775 +358 +201 +541 +265 +23284 +17698 +13638 +23285 +5780 +915 +23286 +23287 +5085 +23288 +43 +3546 +23289 +23290 +809 +21791 +23291 +23292 +14363 +23293 +1116 +9 +13375 +23294 +23295 +1100 +23296 +1739 +43 +21947 +23297 +14846 +23298 +3546 +23299 +736 +23300 +23301 +2577 +21535 +19 +20 +349 +2035 +23302 +23303 +19618 +9 +1765 +23304 +5085 +2625 +5820 +18914 +265 +12005 +3002 +20 +89 +2410 +5410 +19655 +23063 +43 +23305 +23306 +590 +3546 +23307 +5837 +23308 +23309 +3787 +345 +201 +23310 +23311 +201 +1559 +23312 +14 +23313 +349 +349 +21947 +23314 +3543 +23315 +19091 +590 +23316 +4765 +21947 +23317 +1332 +18003 +10791 +19618 +22276 +23318 +9 +5627 +23319 +23320 +38 +3546 +6533 +23321 +23322 +23323 +15595 +2260 +23324 +3325 +23325 +201 +736 +17571 +1834 +23326 +23327 +23328 +17815 +14122 +872 +21947 +590 +32 +122 +3 +1696 +12067 +23329 +20 +23330 +23331 +2 +222 +23332 +14 +4292 +13721 +736 +19618 +155 +23333 +23334 +23335 +23336 +23337 +21947 +23338 +23339 +286 +2243 +11735 +5085 +692 +23340 +23341 +23342 +5326 +342 +32 +10349 +23343 +23344 +23345 +35 +23346 +1012 +989 +3601 +15483 +590 +23347 +23348 +317 +23349 +32 +179 +3559 +538 +23350 +554 +14856 +43 +3546 +1056 +23351 +21947 +484 +357 +23352 +19 +19 +21689 +3598 +590 +13412 +23353 +823 +23354 +23355 +21947 +736 +23356 +6341 +20776 +23357 +43 +19965 +13721 +17380 +46 +23358 +23359 +3155 +23360 +10946 +23361 +1716 +43 +272 +23362 +10356 +23363 +155 +13361 +9591 +23364 +21947 +11364 +14846 +19 +22865 +19792 +1423 +23365 +14 +15 +89 +8149 +13721 +13721 +101 +736 +14 +57 +13721 +21669 +140 +23366 +19 +23367 +15914 +15442 +17871 +57 +19618 +23368 +23369 +14 +23370 +3958 +12359 +209 +9 +13721 +20 +23371 +21947 +4263 +590 +19404 +573 +23372 +23373 +23374 +12534 +19618 +3030 +13721 +13976 +23375 +23376 +4824 +7379 +21689 +2 +23377 +14604 +23378 +21947 +23379 +3759 +554 +586 +590 +3 +43 +10 +9 +21947 +23380 +23381 +23382 +23383 +3546 +21947 +23384 +21031 +23385 +8460 +3638 +19404 +14 +22688 +416 +14 +23386 +23387 +23388 +43 +17809 +23389 +424 +21947 +23390 +10 +23391 +9 +43 +89 +23392 +23393 +4775 +21947 +9 +19 +23394 +23395 +23396 +2243 +23397 +23398 +9 +1696 +4764 +23399 +15824 +3543 +23400 +185 +21947 +21199 +1038 +23401 +43 +4441 +2459 +19 +5271 +823 +21947 +8855 +20 +1566 +155 +14363 +19 +19 +8356 +23402 +23403 +23404 +23405 +4702 +23406 +349 +554 +14 +23407 +4741 +9953 +14 +1316 +23408 +590 +3492 +23409 +32 +20 +23410 +21947 +15718 +3446 +712 +14 +286 +736 +2694 +19 +23411 +9118 +14 +6877 +590 +13721 +20952 +23412 +9 +23413 +9210 +590 +23414 +29 +12987 +16981 +43 +286 +1157 +12067 +590 +590 +12987 +23415 +1559 +188 +640 +23416 +43 +14 +14 +533 +10 +7291 +1529 +155 +23417 +7137 +23418 +3553 +20185 +349 +14420 +21947 +18982 +23419 +1465 +3546 +19 +736 +23420 +46 +23421 +21947 +23422 +4824 +19 +23423 +2 +15718 +23424 +23425 +23426 +7032 +23427 +9630 +5041 +286 +23428 +590 +1716 +337 +112 +19 +23429 +32 +19091 +23430 +345 +22042 +21947 +3473 +590 +23431 +6430 +3005 +19618 +13721 +14 +23432 +57 +43 +1870 +8789 +23433 +809 +178 +323 +23434 +22420 +331 +19 +178 +23417 +21947 +23435 +2804 +23436 +379 +23437 +23438 +23439 +25 +7053 +23440 +3059 +19918 +12845 +23441 +590 +23442 +9871 +4441 +8849 +179 +936 +23443 +590 +23444 +736 +137 +23445 +13129 +23446 +590 +736 +22010 +23314 +23447 +9 +13343 +1559 +2042 +12934 +5085 +736 +23448 +671 +23449 +23450 +768 +4296 +43 +23451 +1107 +23452 +683 +23453 +6571 +15718 +17466 +23454 +57 +4544 +19984 +23063 +379 +3543 +19404 +23455 +23456 +19 +2975 +6766 +14 +10737 +12307 +176 +23457 +23458 +683 +19413 +9396 +7291 +5780 +23459 +23460 +23461 +137 +23462 +19 +6055 +736 +21947 +736 +20952 +22587 +21947 +3251 +7053 +23226 +9 +823 +23463 +34 +665 +23464 +5085 +23465 +19 +32 +18995 +23466 +23467 +16780 +23468 +23469 +286 +23470 +19618 +14 +23471 +23472 +13049 +11966 +23473 +764 +18045 +23474 +23475 +23476 +20245 +19 +23477 +1559 +20785 +9177 +43 +23478 +23479 +23480 +1090 +1316 +18956 +590 +14 +23481 +6038 +15718 +23482 +259 +19 +43 +19618 +13566 +12976 +1091 +104 +495 +23483 +23484 +23485 +164 +3034 +16437 +23486 +272 +35 +5973 +23487 +416 +823 +23488 +23489 +2 +23490 +43 +720 +21947 +14 +23491 +23492 +21947 +23493 +201 +6571 +849 +590 +23494 +10028 +222 +14 +16437 +21947 +1013 +57 +15039 +736 +11995 +23495 +23496 +6011 +23497 +23498 +19 +23499 +23500 +23501 +1082 +22 +250 +19 +19 +23502 +23503 +155 +936 +23504 +16437 +590 +23505 +345 +23506 +19404 +23507 +43 +23508 +23509 +23510 +865 +377 +23511 +23512 +647 +21947 +19404 +23513 +286 +104 +23514 +23515 +213 +23516 +23517 +23518 +284 +43 +370 +21027 +20 +590 +12033 +23519 +23520 +345 +23521 +141 +8668 +3228 +10 +349 +5071 +2770 +2537 +23522 +284 +590 +1529 +590 +18951 +23523 +1018 +23524 +21849 +23525 +18978 +23526 +23527 +9054 +23528 +21947 +12893 +2260 +23529 +21947 +989 +23530 +20 +411 +586 +286 +736 +14477 +19618 +23531 +2 +23532 +590 +43 +23533 +4693 +23534 +1688 +15718 +12757 +17495 +43 +590 +349 +1716 +14079 +43 +9497 +345 +188 +379 +23535 +12579 +42 +43 +23536 +23537 +20340 +13566 +23538 +23539 +378 +13721 +3492 +248 +66 +248 +23540 +3842 +15718 +2202 +9 +21947 +279 +23541 +21947 +21947 +823 +38 +19618 +20 +14 +8668 +12404 +5780 +23542 +915 +3849 +22042 +495 +671 +2 +23543 +23544 +23545 +23546 +23547 +23548 +15699 +22666 +248 +23549 +13265 +43 +23550 +3 +20507 +13474 +16557 +303 +683 +13405 +15914 +23551 +23176 +23552 +23553 +6874 +23554 +23555 +23556 +23557 +248 +23558 +736 +17011 +23559 +23560 +3 +872 +14 +736 +80 +1364 +23359 +23561 +1107 +1604 +23103 +23562 +2561 +21811 +23563 +23564 +23565 +337 +7328 +18132 +323 +8566 +23566 +12987 +23567 +17698 +248 +23568 +23569 +284 +756 +23570 +38 +9 +23571 +1870 +11420 +5689 +112 +21947 +21947 +2449 +823 +823 +20952 +23572 +284 +23573 +23574 +23575 +1517 +2 +23576 +19618 +213 +2035 +23577 +1112 +23359 +23578 +19404 +248 +23579 +23580 +23504 +345 +23581 +5577 +13279 +23582 +23583 +11995 +23584 +23585 +21947 +560 +23586 +8566 +14 +284 +590 +5622 +15 +12466 +259 +14477 +15 +3 +1012 +9 +736 +15718 +8668 +23587 +23588 +23589 +23590 +14604 +23591 +43 +3546 +7835 +3553 +22403 +2804 +23592 +57 +23593 +43 +337 +16281 +371 +736 +3546 +23594 +8566 +827 +9 +590 +23595 +23063 +23596 +23597 +23103 +736 +23598 +23599 +23600 +13361 +19 +15718 +756 +14 +823 +1049 +13721 +19 +32 +19 +23601 +19655 +8668 +23602 +21947 +23603 +43 +23604 +1316 +19218 +96 +43 +1104 +18250 +736 +23605 +2197 +19405 +14 +23606 +23607 +7137 +338 +736 +936 +1157 +23608 +23609 +19 +43 +23610 +43 +209 +23611 +2159 +19 +4463 +23612 +23613 +345 +23614 +11762 +23615 +13616 +590 +178 +10356 +23616 +23617 +23618 +1502 +22308 +23619 +23620 +23621 +23622 +2769 +538 +249 +23623 +20533 +345 +23624 +865 +57 +23625 +77 +1604 +9 +23626 +590 +201 +23627 +20773 +16437 +19404 +8668 +19009 +23628 +5438 +11754 +23629 +5085 +9759 +20 +14 +23630 +23631 +57 +11321 +213 +23632 +770 +16866 +286 +5833 +23633 +53 +1961 +1520 +23634 +3081 +2919 +23635 +1352 +23313 +23636 +13943 +23637 +21947 +21947 +272 +16437 +16 +23638 +303 +32 +9 +23639 +1961 +48 +23640 +201 +16437 +23641 +43 +23642 +23643 +23644 +349 +14527 +43 +23645 +23646 +1508 +2 +15718 +647 +3396 +23647 +590 +15 +23648 +1100 +19852 +1442 +19 +23649 +5820 +2577 +823 +19618 +23650 +2593 +23651 +23652 +43 +165 +23653 +23654 +23655 +23656 +16437 +23657 +554 +43 +57 +18064 +23658 +1655 +4765 +10 +23659 +736 +22 +23660 +23661 +286 +14477 +23662 +14001 +19 +713 +23663 +6571 +1066 +23664 +23665 +1291 +23666 +3546 +225 +22 +590 +3546 +514 +23667 +18951 +15572 +3978 +23668 +8351 +19 +683 +5780 +6950 +19 +11210 +21947 +9 +23669 +4963 +303 +23670 +845 +936 +23671 +11341 +7236 +23672 +7053 +286 +122 +23673 +736 +23674 +3546 +23675 +736 +286 +21947 +5022 +21947 +16437 +4263 +5067 +21031 +23676 +188 +23677 +23678 +22075 +2 +23679 +23680 +16118 +21776 +21947 +17151 +43 +20803 +57 +19404 +2 +13721 +12827 +286 +272 +958 +2561 +23681 +23682 +720 +5780 +286 +402 +14816 +1082 +3 +590 +23683 +5415 +2824 +14216 +7379 +248 +23684 +14175 +23685 +23686 +1870 +349 +213 +399 +23687 +213 +8696 +590 +303 +89 +21947 +337 +2561 +23688 +9 +23689 +23690 +18045 +11762 +2577 +43 +23063 +23691 +1316 +23692 +213 +32 +23693 +23694 +21947 +13721 +2911 +23695 +23696 +21947 +21947 +23697 +13721 +43 +21947 +213 +1026 +23507 +22 +3252 +1559 +974 +10 +887 +21947 +2804 +14102 +23698 +337 +1991 +345 +1606 +823 +19 +20113 +9 +303 +176 +14 +32 +155 +23699 +23226 +23700 +23701 +590 +3034 +23702 +23703 +5438 +16253 +23704 +1042 +19091 +23705 +284 +554 +16826 +970 +23706 +248 +412 +345 +7835 +23707 +22865 +1316 +17151 +14001 +495 +21080 +14033 +23708 +21947 +5833 +23709 +15720 +23710 +23711 +21947 +23712 +7137 +23713 +9 +736 +3546 +188 +155 +14 +2694 +14 +20 +22371 +303 +23714 +345 +1905 +303 +248 +23715 +14586 +22963 +23716 +15820 +18823 +707 +2 +303 +23717 +23718 +14 +303 +284 +23719 +23720 +213 +23721 +21947 +23722 +22 +349 +21947 +12987 +20797 +1930 +9 +23723 +23724 +7053 +23725 +23726 +892 +349 +14477 +23727 +2790 +8610 +3876 +13129 +23728 +823 +736 +19618 +23729 +15 +519 +15718 +23730 +1212 +248 +23731 +23732 +20 +23733 +590 +5085 +155 +590 +1961 +23734 +823 +323 +14 +43 +12080 +23735 +9245 +23736 +23737 +23738 +590 +11762 +18234 +17064 +19618 +23739 +23740 +13476 +23741 +887 +23742 +19 +337 +284 +23743 +21849 +23744 +23745 +2281 +23746 +694 +213 +213 +15320 +22042 +21947 +7945 +4012 +4543 +23747 +23748 +9 +23749 +16144 +23750 +14 +23751 +284 +23752 +16190 +9 +23753 +57 +15713 +23754 +8566 +457 +104 +15820 +9 +17698 +337 +23755 +345 +301 +22986 +222 +18283 +19618 +213 +823 +23756 +23757 +5085 +317 +8244 +15718 +23758 +286 +10406 +13713 +23759 +5773 +23760 +155 +23761 +23762 +32 +5119 +137 +9 +1696 +23763 +303 +3026 +23764 +23765 +23766 +12431 +2567 +23767 +4128 +23768 +5908 +323 +23769 +317 +323 +9 +19 +23770 +323 +23771 +23772 +18816 +23773 +379 +21403 +590 +23774 +21689 +155 +736 +19 +23775 +4502 +23776 +23777 +43 +2975 +21947 +15054 +23778 +349 +10356 +1051 +35 +32 +23779 +23780 +23781 +35 +23782 +178 +1356 +590 +13721 +15068 +23783 +23784 +77 +43 +1901 +14 +14 +10096 +23785 +21947 +19618 +23786 +23787 +14020 +23788 +915 +23789 +648 +20 +23103 +19655 +23790 +590 +14603 +15 +590 +23791 +286 +1154 +345 +23792 +19 +23793 +1765 +22505 +21947 +21698 +3546 +22242 +23794 +43 +21310 +345 +23795 +788 +23796 +3724 +23797 +23798 +14599 +23799 +23800 +140 +23801 +19 +57 +349 +18695 +19486 +13361 +193 +3 +9 +13721 +23802 +43 +22187 +57 +57 +23803 +1517 +349 +14 +23804 +590 +23805 +17151 +23806 +16411 +23807 +19618 +9 +842 +1224 +23808 +337 +23809 +446 +19 +1027 +14 +10846 +23810 +23811 +15718 +23812 +1107 +17273 +7379 +23813 +15718 +2609 +23814 +19618 +43 +7183 +32 +57 +19 +2 +3669 +21947 +21947 +23815 +23816 +21947 +16573 +23817 +23818 +23819 +20143 +18616 +8668 +43 +23820 +573 +155 +23821 +3546 +19 +21947 +23822 +23823 +3546 +10177 +19404 +23824 +21107 +23825 +3275 +23826 +415 +861 +23827 +19618 +23828 +23829 +4306 +927 +43 +23168 +7053 +140 +1578 +19792 +23830 +13721 +303 +23831 +21947 +22 +43 +1384 +23832 +23833 +6907 +23834 +19655 +23835 +52 +98 +23836 +1226 +21049 +15460 +7053 +22 +20 +865 +23226 +349 +265 +188 +43 +707 +21947 +17151 +23837 +349 +19 +23838 +590 +19 +23839 +23840 +29 +16413 +15810 +23841 +7458 +586 +21947 +23842 +23843 +1223 +23844 +23845 +23846 +23847 +23848 +23842 +23849 +23850 +23851 +43 +155 +23852 +19 +23853 +358 +14175 +349 +3626 +23854 +19618 +19 +345 +23855 +736 +23856 +137 +23857 +590 +1384 +23858 +5085 +21947 +1112 +23859 +23860 +349 +5041 +23861 +2550 +3139 +495 +7448 +1867 +23862 +23863 +23864 +23865 +13279 +23866 +9 +23867 +533 +2415 +20 +845 +23868 +43 +23869 +23870 +23871 +23872 +23873 +19852 +23874 +491 +23875 +23464 +1307 +155 +23876 +7137 +16437 +1048 +2 +23877 +23878 +2859 +21947 +349 +23879 +15718 +23880 +736 +2537 +15951 +23881 +23426 +23882 +1082 +32 +43 +15384 +23883 +23884 +1696 +23885 +819 +590 +16102 +57 +23886 +23887 +8297 +17956 +11471 +89 +23888 +272 +736 +23889 +23890 +23891 +23892 +23893 +23894 +554 +1496 +23895 +14 +671 +1716 +23896 +9481 +23897 +9187 +6744 +57 +23898 +23899 +590 +19618 +137 +137 +21947 +22099 +5085 +23842 +7291 +1224 +22 +12987 +6784 +7053 +1154 +23900 +23901 +1768 +23902 +66 +19792 +1090 +23903 +7598 +14001 +1991 +1091 +23904 +1222 +19618 +17151 +23905 +9389 +21280 +21947 +23906 +4625 +286 +23907 +4827 +23908 +23909 +2694 +23910 +2769 +15442 +23911 +43 +3546 +9 +20572 +1942 +14 +23912 +7276 +9 +790 +12013 +566 +23913 +358 +23914 +11013 +19618 +2410 +1920 +11607 +21947 +15975 +21947 +647 +14 +21947 +590 +2577 +736 +23915 +89 +936 +9 +23916 +10 +1571 +249 +23917 +155 +2035 +286 +23918 +7053 +915 +13375 +5764 +32 +185 +823 +23919 +2561 +23920 +349 +730 +155 +57 +1442 +1012 +736 +23921 +23922 +1524 +19618 +1149 +4578 +3546 +23923 +7855 +9797 +23924 +19797 +22233 +5601 +80 +1442 +5331 +5075 +379 +23925 +7276 +16910 +2617 +237 +23926 +13721 +18982 +23927 +23928 +4368 +3059 +736 +23929 +89 +23930 +14392 +23931 +7778 +736 +23932 +3546 +590 +77 +19 +155 +4364 +23933 +23934 +19404 +23935 +23103 +10030 +14 +23936 +23937 +616 +345 +23938 +15718 +23939 +23940 +23941 +16885 +15718 +19618 +764 +806 +23942 +23943 +2804 +23944 +122 +23945 +3546 +43 +303 +13721 +23946 +647 +32 +23947 +23948 +1066 +23949 +1307 +23842 +188 +20785 +23950 +9 +23951 +17136 +89 +32 +554 +17635 +8297 +736 +345 +23952 +345 +14 +720 +2117 +3572 +303 +13721 +23953 +22666 +23220 +17151 +337 +213 +19160 +23954 +17151 +23955 +17698 +1508 +21999 +248 +43 +248 +23956 +9 +13807 +720 +23842 +284 +23957 +20773 +416 +21947 +23958 +23959 +21947 +23960 +23961 +23962 +23963 +23964 +647 +817 +10 +2577 +13721 +248 +2 +3544 +3546 +2117 +736 +284 +345 +23965 +23966 +736 +13566 +32 +339 +213 +1612 +18041 +9 +13655 +573 +23967 +248 +23968 +23969 +23970 +23971 +19618 +402 +23972 +1425 +3546 +248 +349 +23973 +14001 +43 +590 +23974 +15718 +23975 +43 +23976 +248 +23977 +23978 +10028 +872 +23979 +5085 +23980 +22986 +23981 +1300 +14001 +23358 +13721 +43 +21947 +398 +643 +1716 +23982 +790 +14147 +4278 +22891 +23983 +303 +22 +299 +20952 +23984 +19 +23985 +23986 +23987 +17151 +89 +4278 +23988 +23989 +23990 +23991 +43 +15718 +23992 +10004 +15718 +1314 +22 +1529 +43 +23993 +21947 +14 +464 +1150 +23994 +248 +7053 +23995 +12042 +29 +17151 +936 +23996 +23997 +23998 +21947 +21475 +23999 +43 +6817 +43 +14604 +491 +20 +7053 +38 +24000 +590 +24001 +43 +24002 +720 +24003 +60 +32 +1423 +345 +5316 +21947 +22639 +13150 +14 +349 +14909 +24004 +18664 +337 +2336 +24005 +24006 +24007 +19810 +20040 +14131 +24008 +3601 +24009 +24010 +14693 +19618 +6741 +736 +24011 +24012 +6364 +2841 +2 +24013 +19618 +24014 +416 +16736 +57 +21947 +317 +21947 +1824 +15718 +7053 +19 +201 +284 +57 +24015 +24016 +590 +345 +24017 +24018 +13848 +13721 +14477 +590 +21947 +21947 +24019 +7855 +24020 +303 +24021 +24022 +19618 +10789 +13038 +736 +24023 +22505 +24024 +24025 +24026 +24027 +590 +19 +7357 +9 +21947 +790 +22 +19618 +14591 +15 +345 +24028 +9 +554 +21947 +349 +24029 +590 +2 +9 +23226 +43 +24030 +22355 +519 +533 +637 +24031 +14 +14477 +10 +303 +19618 +24032 +736 +868 +9449 +24033 +24034 +60 +13361 +21627 +3842 +2859 +24035 +12618 +23842 +24036 +14013 +17638 +24037 +19218 +590 +21947 +7183 +21947 +9 +19218 +24038 +24039 +24040 +24041 +24042 +17151 +112 +20600 +17608 +815 +24043 +24044 +24045 +8807 +286 +12534 +2600 +24046 +15718 +13320 +24047 +24048 +114 +24049 +18798 +590 +590 +43 +7134 +1822 +17 +57 +1538 +2 +5907 +53 +18553 +8798 +155 +24050 +24051 +3978 +1612 +12701 +155 +24052 +24053 +590 +17151 +24054 +24055 +24056 +1011 +19 +736 +1090 +24057 +13343 +2260 +24058 +24059 +24060 +24061 +2577 +23688 +354 +16976 +24062 +590 +2694 +14 +24063 +24064 +18695 +1172 +23805 +248 +21947 +24065 +2009 +24066 +24067 +6741 +23196 +5780 +16826 +2 +24068 +2724 +5310 +38 +213 +9 +24069 +24070 +13721 +24071 +20 +24072 +14 +24073 +379 +24074 +19655 +7276 +17410 +6171 +13045 +3678 +24075 +60 +2859 +34 +21947 +7855 +20315 +21947 +21947 +21947 +373 +43 +21947 +495 +1612 +17670 +43 +21947 +24076 +16118 +3543 +10147 +189 +24077 +24078 +24079 +32 +24080 +4278 +24081 +823 +24082 +3546 +250 +19439 +17400 +23842 +1224 +7855 +958 +15993 +24083 +24084 +24085 +3684 +3256 +590 +8668 +1716 +349 +286 +24086 +683 +17670 +3599 +7855 +13721 +647 +7379 +24087 +3546 +24088 +15 +19404 +17119 +9713 +19618 +4407 +249 +22183 +24089 +24090 +20 +4461 +20 +1047 +10356 +17698 +24091 +2 +57 +20340 +1198 +24092 +533 +24093 +590 +2983 +209 +24094 +5085 +24095 +24096 +24097 +24098 +24099 +1991 +1531 +24100 +19 +57 +14914 +24101 +24102 +14000 +24103 +9759 +17151 +1026 +1559 +213 +24104 +213 +23842 +19 +24105 +57 +9 +24106 +201 +24107 +7208 +24108 +24109 +24110 +35 +7835 +3341 +21947 +284 +1559 +19 +24111 +24112 +284 +24113 +3876 +24114 +14216 +7960 +209 +14 +554 +98 +43 +29 +9 +9 +24115 +6501 +17151 +3546 +20600 +349 +2577 +22787 +590 +23571 +155 +24116 +1300 +24117 +19 +155 +24118 +19618 +24119 +590 +17340 +736 +32 +1044 +303 +349 +15971 +349 +19 +24120 +24121 +14 +32 +22442 +554 +349 +19618 +24122 +213 +1870 +345 +22417 +24123 +19618 +24124 +3546 +24125 +554 +284 +2415 +24126 +43 +24127 +1810 +2 +397 +8939 +5780 +4126 +24128 +24129 +15 +16437 +24130 +284 +24131 +15 +24132 +24133 +15718 +24134 +3251 +9 +155 +554 +24135 +24136 +43 +590 +6283 +24137 +595 +24138 +3553 +23842 +11057 +7117 +24139 +43 +9118 +1696 +24140 +20952 +24141 +349 +21486 +24142 +22 +16413 +23842 +21947 +2499 +220 +415 +15718 +15718 +1300 +57 +24143 +15 +3546 +598 +179 +201 +1300 +8766 +14 +43 +6408 +21947 +24144 +169 +19 +155 +24145 +24146 +213 +38 +24147 +21689 +32 +13721 +24148 +24149 +24150 +24151 +24152 +354 +24153 +6130 +9 +24154 +24155 +3599 +4024 +12214 +20952 +24156 +337 +24157 +5577 +14420 +5627 +2988 +24158 +22888 +4364 +24159 +19618 +21947 +24160 +3950 +9 +24161 +24162 +24163 +24164 +14 +15718 +303 +21031 +14 +245 +2197 +2609 +24165 +43 +24166 +43 +12987 +586 +5662 +19618 +24167 +20 +286 +9 +24168 +24169 +11966 +9 +24170 +10 +9 +2476 +286 +43 +24171 +7855 +32 +9 +1244 +43 +2356 +671 +1688 +5791 +345 +24172 +1220 +24173 +22 +18982 +1051 +24174 +24175 +24176 +323 +32 +19 +24177 +24178 +89 +32 +286 +21049 +18683 +19618 +13848 +22599 +19494 +1384 +590 +21947 +10031 +19091 +24179 +24180 +9 +16102 +16436 +24181 +24182 +5505 +24183 +9 +14 +24184 +9 +43 +12821 +5119 +15 +60 +19 +595 +4993 +14477 +21834 +17871 +21947 +942 +24185 +2556 +24186 +24187 +24188 +13131 +24189 +590 +1157 +2728 +19192 +53 +24189 +3546 +14982 +24190 +24191 +24192 +6480 +6400 +705 +286 +5601 +15797 +590 +24193 +24194 +24195 +590 +24196 +19 +720 +1578 +9 +24197 +24198 +3546 +24199 +24200 +24201 +4242 +379 +20 +1089 +24202 +24203 +573 +613 +24204 +24205 +1364 +24206 +24207 +872 +222 +24208 +1745 +323 +12425 +24209 +15914 +43 +24210 +155 +24211 +19 +32 +24212 +873 +17151 +24213 +720 +24214 +6950 +6531 +20040 +24215 +590 +24216 +24217 +566 +10789 +44 +2577 +43 +24218 +24219 +24220 +13582 +24221 +349 +713 +24222 +10559 +8171 +13721 +24223 +24224 +142 +43 +9363 +16413 +24225 +15 +15989 +38 +1696 +137 +616 +24226 +24227 +11087 +21947 +24228 +4296 +19573 +24229 +24230 +1700 +24231 +683 +24232 +24233 +1812 +24234 +15718 +24235 +24236 +10003 +14 +17596 +736 +21947 +7183 +43 +32 +19618 +21947 +19 +7053 +43 +3484 +14 +286 +4463 +272 +4306 +24237 +7291 +915 +597 +43 +1768 +5627 +24238 +32 +1648 +790 +24239 +24240 +13150 +3353 +249 +3601 +533 +4055 +1559 +9526 +24241 +5515 +24242 +23741 +4821 +8669 +590 +19 +590 +14 +24243 +1920 +590 +24244 +554 +42 +24245 +24246 +14 +3067 +2289 +17821 +21947 +24247 +349 +564 +24248 +24249 +10 +2733 +20 +809 +24250 +24251 +155 +378 +32 +24252 +43 +24253 +2769 +43 +24254 +16640 +57 +1251 +24255 +66 +24256 +4745 +1688 +24257 +77 +19 +9 +15512 +19 +24258 +18234 +17151 +24259 +24260 +1302 +3978 +43 +971 +15589 +8297 +16437 +24261 +2882 +142 +2 +24262 +11341 +24263 +446 +21698 +24264 +17151 +11364 +24265 +24266 +23573 +24267 +19939 +1382 +13361 +15720 +24268 +8593 +4185 +7053 +797 +24269 +17 +21947 +14240 +595 +15718 +24270 +1605 +11639 +1112 +24271 +509 +342 +12987 +24272 +24273 +24274 +24275 +48 +19618 +24276 +16437 +24277 +1749 +736 +286 +1082 +6571 +20 +24278 +24279 +22666 +24280 +8668 +24281 +24282 +35 +43 +24283 +11 +19797 +24284 +24285 +4 +15 +345 +24286 +24287 +8508 +24288 +115 +59 +16437 +1013 +58 +5022 +3546 +790 +32 +24289 +43 +1091 +9 +59 +24290 +1047 +232 +590 +14363 +667 +2830 +249 +19763 +815 +17062 +24291 +32 +24292 +7256 +11762 +23196 +345 +24293 +333 +1992 +15824 +24294 +24295 +20 +32 +17151 +19 +24296 +11822 +707 +2302 +24297 +24298 +3 +23464 +2772 +1580 +24299 +24300 +24301 +590 +1051 +21126 +5499 +24302 +15718 +2 +249 +19618 +178 +9 +915 +538 +3553 +24303 +24304 +24305 +4547 +24306 +32 +24307 +24308 +19 +24309 +43 +24310 +24311 +23842 +15720 +10356 +11601 +13566 +7522 +22 +43 +3743 +11647 +4422 +24312 +24313 +24314 +24315 +19 +24316 +4790 +3553 +24317 +1559 +24318 +24319 +14 +155 +1612 +4609 +21947 +24320 +14 +24321 +1655 +22986 +13283 +57 +24322 +2550 +24323 +43 +541 +18703 +24324 +19618 +237 +15718 +24325 +7034 +57 +24326 +590 +14477 +590 +2305 +24327 +15107 +24328 +24329 +24330 +24331 +2260 +439 +345 +16139 +9160 +22643 +299 +23647 +14363 +21947 +272 +24332 +13721 +14 +24333 +1157 +4 +11428 +842 +24334 +43 +1566 +9 +43 +142 +24335 +122 +1680 +3708 +1668 +1124 +745 +24336 +7835 +16152 +24337 +1013 +24338 +16079 +6950 +21947 +349 +24339 +1716 +24340 +286 +24341 +1712 +15718 +8668 +24005 +201 +24342 +1688 +12 +155 +21681 +196 +2828 +24343 +14 +16437 +18707 +24344 +24345 +24346 +24347 +6395 +24348 +647 +1513 +13721 +24349 +24350 +24351 +24352 +819 +20 +24353 +3546 +9 +13615 +228 +24354 +24355 +24356 +16656 +2410 +7183 +24357 +11102 +2042 +11321 +1817 +15824 +43 +1481 +24358 +24359 +2790 +2577 +19618 +24360 +21947 +590 +736 +23842 +10147 +345 +14 +24361 +24362 +14079 +1169 +24363 +11421 +24364 +1765 +14621 +14000 +24365 +24366 +24367 +43 +4409 +1870 +15718 +12005 +15718 +23842 +24368 +24369 +12987 +1817 +24370 +2502 +18364 +370 +24371 +5253 +24372 +845 +21947 +24373 +24374 +19618 +16437 +17151 +2446 +590 +345 +13721 +1382 +24375 +10727 +647 +17151 +349 +590 +24376 +5075 +35 +3 +10 +24377 +24378 +32 +7835 +43 +8566 +15 +24379 +345 +43 +19 +2609 +2550 +24380 +12987 +17602 +23842 +11420 +13721 +24381 +24382 +5248 +21947 +24383 +590 +478 +249 +24384 +265 +24385 +24386 +209 +14102 +13570 +14477 +24387 +12506 +104 +1517 +24388 +24389 +24390 +24391 +20280 +24392 +24393 +196 +43 +3353 +286 +24394 +24395 +19618 +57 +554 +24396 +24397 +4463 +19 +43 +491 +23103 +21947 +24398 +24399 +24400 +22963 +57 +21947 +24401 +24402 +24403 +10111 +24404 +8208 +14 +24405 +4414 +24406 +24407 +2129 +24408 +32 +9 +24409 +57 +24410 +21947 +24303 +24411 +24412 +2 +19 +24413 +23166 +19 +24414 +21689 +32 +4745 +24415 +286 +24416 +590 +19618 +1920 +21947 +2197 +8134 +15718 +2764 +2550 +720 +16089 +2 +24144 +3270 +24417 +13405 +583 +21947 +24418 +7810 +7835 +24419 +286 +13652 +745 +3050 +15718 +13721 +647 +24420 +519 +24303 +9 +24421 +24422 +14363 +24423 +24424 +24144 +24425 +170 +3546 +24426 +827 +24427 +24428 +23190 +24429 +24430 +590 +15 +345 +21947 +19655 +7855 +7053 +10 +19 +24144 +16931 +13993 +1244 +13721 +24431 +13375 +66 +24432 +11273 +823 +18695 +17151 +24433 +1817 +24434 +24435 +2356 +5780 +24436 +24437 +24438 +2 +15 +2733 +1517 +20142 +19 +24439 +4502 +4124 +24440 +5318 +1677 +21947 +24441 +590 +590 +14 +60 +24442 +1698 +24443 +24444 +564 +2550 +1655 +24445 +22371 +43 +24446 +3034 +89 +2577 +24447 +16437 +24303 +4536 +15718 +9 +24448 +2314 +24449 +24450 +2446 +8976 +237 +7183 +286 +24451 +18784 +11413 +23103 +24452 +4961 +16102 +24453 +19655 +9 +827 +24454 +651 +4985 +4388 +24455 +3546 +15476 +24456 +20792 +24457 +24458 +590 +19 +15 +3601 +15 +43 +24459 +17151 +24460 +10470 +24461 +286 +24462 +24463 +24464 +24465 +15 +24466 +24467 +809 +19 +1230 +24468 +185 +14 +21947 +13173 +9 +155 +24469 +3546 +24470 +10123 +24471 +2254 +19 +2 +17865 +77 +24472 +764 +2804 +89 +24473 +3062 +14363 +24474 +373 +13721 +1021 +9649 +78 +24475 +24476 +249 +14216 +286 +24477 +2410 +736 +17151 +24478 +24479 +70 +8701 +19 +43 +4116 +24480 +1011 +358 +24481 +10117 +24482 +259 +24483 +24484 +24485 +24486 +9 +9 +21776 +3546 +17151 +590 +5659 +24487 +24488 +2459 +24489 +24490 +16079 +8669 +24491 +12260 +24492 +1160 +24493 +1696 +24494 +23842 +24495 +18896 +274 +17151 +11394 +24496 +1300 +3546 +14 +24497 +286 +89 +17151 +5085 +24498 +683 +24499 +25 +24500 +590 +24501 +590 +14 +647 +20 +24502 +16437 +19 +349 +24503 +24504 +24505 +2 +7717 +24506 +165 +5780 +19918 +2694 +24507 +24508 +24509 +24510 +24511 +4088 +915 +24512 +24513 +17144 +21031 +554 +11471 +19618 +155 +14185 +112 +168 +24514 +24515 +990 +3484 +24516 +24517 +13343 +345 +9 +1316 +1286 +24518 +14597 +111 +5257 +18283 +196 +24519 +18982 +137 +24520 +464 +16437 +22962 +16437 +274 +24521 +6171 +1056 +43 +36 +24522 +16571 +14 +15489 +686 +24523 +19868 +24524 +19618 +436 +24525 +24526 +18589 +24527 +1013 +720 +424 +22986 +24528 +7137 +13364 +345 +24303 +541 +16437 +24335 +4293 +24529 +4050 +24303 +1291 +24530 +24531 +13662 +24532 +24533 +24534 +24535 +736 +24536 +14 +24537 +5780 +24538 +14001 +2 +13988 +24539 +24540 +554 +17136 +24541 +23619 +24542 +24543 +24544 +32 +24545 +17920 +19839 +14240 +24546 +3546 +1013 +24547 +9 +7835 +24548 +20700 +24144 +1542 +35 +861 +7835 +4398 +342 +554 +24549 +7601 +19323 +24550 +3236 +17136 +3 +24551 +583 +21889 +48 +24552 +24553 +22802 +57 +17151 +24554 +23103 +18423 +24555 +24556 +2330 +36 +17670 +6430 +66 +24557 +13721 +24558 +24559 +19655 +15 +590 +20 +10967 +24560 +24561 +9 +24562 +24563 +188 +10 +24564 +89 +19797 +12404 +12005 +24565 +286 +24566 +43 +66 +57 +21947 +5197 +24567 +24568 +24569 +647 +24570 +14532 +1382 +19618 +322 +24571 +24572 +19931 +3007 +16437 +24573 +19386 +24574 +1021 +43 +7053 +24575 +14604 +12768 +23600 +9060 +24576 +17151 +1013 +15914 +13375 +43 +9578 +14477 +1612 +24577 +43 +24578 +24579 +22307 +23110 +3055 +24580 +24581 +23842 +17603 +10 +1013 +24582 +23196 +1961 +24583 +9 +20141 +24584 +21947 +24585 +24586 +24587 +24588 +24589 +11087 +1716 +9 +17698 +12005 +12402 +6782 +21947 +16640 +19618 +17151 +17754 +1901 +12987 +3278 +2042 +155 +14 +20228 +24590 +24591 +57 +2577 +24592 +519 +24593 +583 +155 +21776 +24594 +24595 +21947 +24596 +24597 +24598 +24599 +24600 +5085 +4824 +24601 +24602 +9 +20 +873 +566 +18695 +2132 +736 +2790 +24603 +24604 +345 +2537 +24605 +24606 +24607 +43 +519 +24608 +24609 +1566 +286 +14 +1423 +379 +590 +8351 +19618 +22787 +10 +24610 +3546 +24335 +24611 +24612 +24613 +492 +155 +8962 +21947 +14 +6430 +24614 +92 +349 +23579 +1680 +19618 +24615 +24616 +1198 +15718 +1481 +21947 +24617 +2117 +9 +24339 +1914 +22 +24618 +10 +138 +21947 +155 +24619 +43 +2117 +213 +19 +19852 +4055 +43 +24620 +43 +14586 +23196 +24621 +24622 +19618 +284 +1524 +20115 +1578 +21689 +284 +249 +43 +24623 +7600 +248 +14529 +24624 +149 +17633 +283 +57 +24625 +10230 +303 +13848 +24626 +24627 +411 +17151 +24628 +1109 +1155 +24629 +354 +399 +24630 +80 +2146 +13897 +5780 +24631 +24632 +541 +23842 +2008 +345 +24633 +3743 +24634 +3421 +24635 +24636 +590 +24637 +8256 +24638 +24639 +19618 +1578 +14 +19091 +14 +24640 +647 +24641 +1524 +4293 +1710 +24642 +22260 +24643 +12987 +24644 +13529 +24645 +24646 +43 +24647 +17151 +13721 +3842 +18616 +20 +24648 +24649 +3345 +8883 +9 +24650 +24651 +24652 +10 +24653 +573 +6531 +21730 +209 +3755 +23226 +1295 +16445 +736 +114 +16437 +17136 +24654 +8458 +303 +21796 +590 +6179 +4827 +24655 +24656 +5757 +323 +24657 +1765 +188 +24658 +590 +533 +24659 +24660 +24661 +24662 +2243 +213 +155 +24663 +303 +832 +736 +19337 +1559 +24664 +286 +2314 +14 +8779 +2 +19 +2410 +286 +4028 +155 +24665 +16437 +9 +3546 +3546 +1357 +19218 +14477 +8814 +24666 +24667 +21999 +19883 +286 +3316 +590 +24668 +24669 +20952 +24670 +24671 +5085 +19581 +24672 +15437 +8668 +24673 +21947 +24674 +377 +24675 +3543 +24676 +1870 +4808 +14 +24677 +24678 +24679 +24680 +24681 +12584 +46 +14 +24682 +14914 +24683 +9 +861 +16629 +872 +8186 +21947 +24684 +971 +24685 +354 +22091 +15085 +24686 +19 +6341 +13361 +20 +155 +24687 +2035 +349 +1764 +3904 +89 +345 +19 +24688 +24689 +19 +80 +8297 +89 +4317 +24690 +3546 +2264 +43 +15718 +24691 +345 +284 +24692 +24485 +21947 +24693 +16681 +8994 +3546 +3959 +43 +3353 +24694 +4550 +24695 +15718 +43 +20339 +1637 +7276 +3 +32 +4028 +14 +24696 +7014 +24697 +448 +24698 +590 +164 +201 +24699 +11224 +5169 +24700 +24701 +821 +5627 +24702 +24703 +24704 +24705 +24706 +9 +515 +24707 +590 +22818 +646 +24708 +24709 +349 +43 +827 +24710 +24711 +24712 +590 +24713 +5908 +12117 +14668 +24714 +21776 +1230 +24715 +1920 +24716 +23842 +137 +19404 +887 +24717 +24718 +14 +9705 +24719 +6341 +1100 +19618 +930 +9475 +24720 +14 +24721 +24722 +24723 +21776 +24303 +14546 +14363 +19404 +17136 +21947 +22 +1316 +14147 +80 +1559 +769 +1181 +536 +17670 +18978 +14 +2721 +232 +43 +23603 +24724 +12684 +209 +7855 +590 +24725 +23842 +89 +14 +936 +1090 +3546 +43 +19404 +19618 +7980 +76 +3258 +46 +24725 +24726 +24727 +43 +24728 +24729 +345 +1817 +20156 +24730 +3546 +24731 +24732 +22029 +286 +24733 +176 +24734 +15592 +24735 +14079 +24736 +6364 +2694 +213 +24737 +4502 +24738 +57 +8188 +24739 +1559 +21947 +24740 +3421 +14477 +13405 +19918 +989 +861 +303 +1749 +8351 +590 +861 +1364 +21947 +21627 +24741 +2238 +19 +14 +24742 +24743 +19618 +24744 +699 +24745 +248 +24746 +15589 +14 +9 +21947 +5085 +590 +23842 +24747 +345 +24748 +24749 +15 +24750 +464 +323 +58 +2 +554 +24751 +12987 +24752 +3034 +3546 +22556 +24753 +590 +13502 +2 +6086 +2314 +590 +24754 +16645 +24755 +43 +12987 +13721 +24756 +412 +24757 +24758 +23842 +379 +24759 +8392 +1688 +736 +19618 +24760 +24761 +2117 +19618 +24762 +24763 +590 +8566 +19618 +24764 +24765 +1051 +24766 +24767 +24768 +725 +21893 +24769 +9 +24770 +24771 +60 +24772 +1244 +77 +1051 +24773 +24774 +5319 +43 +1442 +24775 +7208 +43 +14477 +24776 +14 +24777 +24778 +12618 +5267 +24779 +188 +32 +24780 +24781 +140 +13721 +25 +24782 +24783 +1465 +1615 +24784 +683 +21947 +9801 +3553 +24785 +24786 +9 +213 +9 +1244 +24144 +24787 +24788 +6877 +24789 +21261 +24790 +20623 +24791 +24792 +1425 +345 +9 +345 +3546 +14017 +98 +15539 +2348 +14945 +18695 +21947 +24793 +24794 +24795 +1949 +123 +349 +24796 +12722 +24797 +303 +24798 +57 +21947 +5963 +24799 +345 +23867 +2577 +349 +32 +1870 +2410 +19 +19 +24800 +248 +872 +43 +19 +989 +24303 +18631 +13721 +99 +24801 +590 +554 +24802 +25 +24803 +2476 +1992 +24804 +35 +24805 +303 +14981 +14 +554 +57 +24806 +14477 +19 +24807 +1867 +24808 +24809 +2919 +3546 +24810 +24811 +155 +259 +24812 +349 +24813 +24814 +14 +24815 +2694 +3601 +24816 +24817 +21681 +19 +201 +24818 +24819 +24820 +491 +213 +43 +24821 +9 +23103 +12077 +24822 +12005 +24823 +22196 +24425 +284 +24824 +9 +24144 +1812 +18760 +14616 +32 +19618 +9 +1765 +1364 +11762 +15718 +24825 +9 +14363 +24826 +1604 +24827 +554 +9402 +104 +24828 +43 +43 +713 +21776 +1083 +19618 +17151 +13150 +24829 +24830 +9 +213 +15718 +19618 +24831 +24832 +24833 +16437 +24834 +19618 +11754 +21947 +32 +2865 +24303 +21947 +24835 +24836 +24837 +24838 +16437 +23226 +24839 +43 +2 +24840 +24841 +24842 +24843 +12912 +24844 +14660 +541 +8392 +18045 +24845 +24846 +24847 +196 +24848 +14 +24849 +1222 +590 +24850 +13721 +24851 +14 +155 +24852 +823 +3546 +24853 +24854 +43 +24855 +19655 +24856 +9 +21947 +15 +24857 +15718 +24858 +17151 +509 +18612 +19618 +665 +24859 +77 +24860 +24861 +358 +24862 +104 +32 +15718 +222 +24863 +24864 +13721 +22 +1745 +138 +14 +5418 +17472 +1529 +24865 +15718 +2694 +2 +11966 +4226 +24866 +9 +24867 +345 +24868 +24869 +13721 +323 +24870 +6877 +19 +19 +2 +24871 +24872 +19 +155 +24873 +249 +10 +21947 +411 +13566 +23842 +357 +24471 +373 +379 +24144 +24874 +24875 +24876 +19797 +1382 +24877 +14477 +24878 +358 +20125 +155 +24879 +4293 +14102 +24880 +11483 +24881 +9630 +19618 +9 +24882 +19 +24883 +43 +6400 +24884 +14001 +14340 +57 +24885 +671 +24886 +13721 +12351 +19 +24887 +736 +21947 +24888 +6095 +66 +15 +155 +24332 +15 +14563 +647 +24889 +303 +415 +21947 +105 +22 +16437 +16443 +24890 +14 +19 +24891 +13179 +9 +19 +24892 +24893 +590 +22717 +24894 +19618 +24895 +1316 +23231 +43 +24896 +24897 +201 +24898 +12387 +179 +19783 +14 +17151 +24899 +14660 +17484 +2764 +7855 +9 +24900 +24901 +2 +1442 +24902 +24903 +24904 +3171 +7835 +19 +2042 +345 +57 +24905 +764 +1226 +11754 +2499 +250 +24906 +15 +590 +24907 +24908 +24909 +590 +24910 +24144 +14001 +24911 +13566 +24912 +13497 +2818 +24913 +24914 +24915 +14216 +24916 +24917 +57 +365 +24918 +15720 +17151 +9 +9 +554 +21627 +2427 +24919 +24920 +2260 +590 +24921 +2314 +32 +14 +24303 +24922 +12366 +24923 +6950 +22888 +24924 +24925 +24926 +8291 +24927 +536 +4141 +3976 +24896 +24928 +8151 +14 +590 +24929 +24930 +66 +115 +24931 +14 +43 +1090 +176 +15 +590 +872 +910 +349 +18047 +1181 +10642 +15406 +14001 +16437 +32 +14369 +24932 +24933 +24934 +19209 +24935 +19 +20 +14 +104 +24936 +24937 +369 +665 +21947 +24303 +24938 +43 +24939 +5627 +286 +1048 +21947 +24940 +24941 +6147 +15718 +11995 +5920 +24942 +9 +15718 +21947 +24943 +24944 +24945 +19 +9 +14 +20 +1517 +286 +9 +21947 +24946 +15 +342 +14477 +495 +24947 +4702 +11423 +2459 +43 +24948 +38 +665 +24949 +14477 +9 +9 +24950 +24207 +24896 +4128 +24951 +24952 +14 +18734 +590 +14 +14477 +9 +19655 +24953 +272 +24954 +24955 +2804 +24956 +155 +2386 +286 +24957 +24958 +19 +24959 +415 +8685 +24960 +3546 +21947 +24961 +323 +86 +19 +5665 +24962 +24963 +24964 +7835 +568 +24965 +24966 +9560 +21540 +24967 +14 +137 +24968 +24969 +13623 +17670 +24970 +14185 +10793 +13721 +7053 +22308 +3546 +7183 +201 +2694 +24971 +24972 +720 +23842 +22230 +17716 +21269 +43 +24973 +19 +21947 +24974 +7137 +24975 +24976 +24977 +20187 +12 +13721 +12250 +4278 +3353 +14454 +8392 +8809 +665 +5316 +19 +24978 +345 +24979 +936 +24980 +24981 +14001 +11762 +832 +179 +24982 +24983 +323 +24984 +24985 +18896 +24986 +89 +43 +19478 +24987 +765 +7273 +345 +1425 +57 +915 +14 +24988 +19 +415 +24989 +22 +2 +24990 +21947 +23653 +9 +24991 +24992 +201 +16899 +24993 +15718 +3353 +5781 +12479 +188 +272 +17911 +12987 +24994 +57 +9 +24995 +17412 +24996 +24997 +43 +140 +24998 +349 +8994 +3546 +286 +24999 +25000 +25001 +25002 +9497 +741 +345 +17698 +14369 +25003 +6595 +7053 +3476 +3649 +7729 +228 +196 +25004 +15517 +5650 +14 +10482 +669 +25005 +707 +8787 +25006 +14369 +590 +9 +213 +5791 +21947 +43 +25007 +6058 +24303 +9 +14369 +373 +25008 +595 +736 +5299 +597 +19 +25009 +25010 +1991 +14369 +8188 +25011 +19458 +24303 +25012 +3546 +3330 +25013 +25014 +25015 +48 +14 +8967 +25016 +1542 +9275 +278 +25017 +25018 +25019 +14 +4388 +19091 +3417 +1051 +590 +25020 +1513 +25021 +19918 +25022 +665 +25023 +25024 +2234 +25025 +14 +25026 +25027 +21947 +9 +12402 +5085 +25028 +3546 +10 +9 +21849 +25029 +25030 +43 +14 +13365 +25031 +284 +5629 +25032 +1991 +25033 +3353 +19965 +7276 +17136 +25034 +10846 +2197 +25035 +14 +13721 +25036 +590 +19618 +1425 +9 +24045 +286 +15589 +745 +2537 +14477 +11762 +1920 +10 +25037 +25038 +185 +15730 +9396 +590 +25039 +5614 +3976 +25040 +590 +3546 +303 +590 +590 +590 +43 +19252 +25041 +16126 +25 +25042 +25043 +3 +25044 +14 +25045 +57 +25046 +20 +8624 +18798 +19 +720 +176 +14363 +9622 +590 +19218 +9 +25047 +25048 +25049 +13721 +9 +24144 +10642 +764 +25050 +15718 +590 +25051 +464 +57 +19618 +21689 +201 +1245 +25052 +25053 +936 +248 +25054 +19655 +25055 +25056 +1637 +25057 +25058 +2764 +14477 +6877 +1330 +25059 +2367 +303 +25060 +4414 +25061 +25062 +13566 +1765 +25063 +4387 +4411 +17136 +13721 +590 +286 +1051 +21947 +18896 +590 +14369 +25064 +971 +15718 +7835 +19003 +337 +25065 +16637 +3546 +849 +590 +35 +3251 +25066 +25067 +694 +14603 +19404 +25068 +3034 +209 +57 +213 +3 +19618 +3546 +14 +17033 +25069 +337 +12777 +736 +13721 +43 +7014 +303 +1066 +25070 +10094 +8171 +6518 +2694 +694 +1090 +25071 +648 +411 +25072 +25073 +25074 +14385 +478 +4585 +25075 +14381 +25076 +20852 +25077 +25078 +15989 +43 +25079 +15 +14079 +272 +25080 +3844 +19404 +1287 +15471 +849 +971 +25081 +736 +19 +365 +18423 +25082 +590 +11423 +19109 +25083 +25084 +43 +25085 +1082 +43 +25086 +14 +89 +25087 +1465 +155 +43 +25088 +8668 +25089 +1013 +8787 +15496 +18695 +1021 +25090 +2770 +25091 +25092 +1300 +9 +3417 +25 +3546 +17698 +5438 +13721 +25093 +25094 +24978 +17635 +25095 +7855 +25096 +15718 +19618 +19 +25097 +25098 +303 +19618 +25099 +25100 +3546 +3546 +21834 +4764 +25101 +25102 +25103 +2836 +25104 +25105 +1021 +25106 +25107 +15949 +4116 +13150 +1842 +25108 +25109 +14369 +2577 +43 +25110 +25111 +11757 +303 +647 +7053 +16437 +25112 +25113 +1112 +25114 +554 +25110 +3546 +43 +25115 +21947 +16648 +19 +24045 +2577 +24335 +590 +25116 +25117 +25118 +3095 +24144 +1316 +25119 +25120 +14477 +25121 +25122 +25123 +14 +397 +19 +25124 +25125 +24978 +25126 +25127 +25128 +21947 +43 +20666 +25129 +25130 +14693 +1529 +6741 +19618 +24862 +730 +19 +21729 +2971 +1604 +5601 +20 +25131 +15718 +5780 +1236 +25132 +25133 +8103 +16687 +345 +349 +19655 +590 +12987 +24303 +15824 +15285 +25134 +590 +4 +14 +25135 +8297 +25136 +25137 +25138 +12544 +4313 +19241 +4650 +17151 +25139 +13813 +14127 +25140 +25141 +1090 +25142 +13956 +25143 +14 +9 +24802 +20 +21947 +25144 +25145 +15797 +10672 +25146 +19618 +284 +25147 +345 +25148 +25149 +284 +25097 +590 +11370 +13721 +25150 +711 +154 +4055 +213 +1160 +2764 +25151 +2537 +2561 +17606 +1224 +16205 +25152 +25153 +365 +2314 +3657 +25154 +6950 +11341 +25155 +43 +9 +1051 +449 +43 +9688 +32 +21947 +1423 +590 +2635 +586 +25156 +25157 +3407 +12772 +2764 +887 +25158 +25159 +3330 +6354 +25160 +20 +22 +25161 +25162 +6300 +25163 +707 +8208 +9 +25164 +337 +21947 +8248 +21947 +349 +25165 +25166 +19 +736 +3484 +25167 +138 +22 +349 +25168 +2865 +25169 +284 +23364 +12315 +3546 +3546 +1987 +4364 +25170 +19 +6518 +358 +14477 +43 +323 +5780 +25171 +7812 +43 +590 +15718 +14 +25172 +8392 +5628 +25173 +25174 +25175 +303 +25176 +2040 +25177 +25178 +25179 +357 +1091 +9355 +20218 +736 +19618 +15220 +16437 +25180 +25181 +201 +17920 +14369 +25182 +14 +14477 +345 +7215 +9 +5085 +7283 +13721 +1508 +24896 +597 +25183 +14869 +3484 +25184 +20773 +3872 +590 +25185 +21947 +13230 +345 +1716 +14369 +25186 +16437 +25187 +284 +25188 +3546 +4550 +2260 +770 +19618 +14 +25189 +25190 +25191 +140 +13137 +337 +25192 +845 +25193 +25194 +25195 +21947 +12893 +19 +1181 +9 +24978 +284 +495 +25196 +25197 +25139 +43 +2733 +2113 +19 +15809 +25198 +541 +25199 +213 +25200 +5310 +21698 +25201 +379 +25202 +25203 +25204 +17698 +23103 +25205 +2197 +3251 +25206 +25207 +1316 +213 +3546 +161 +58 +25208 +822 +16 +25209 +155 +25210 +98 +2502 +21947 +514 +338 +8994 +25211 +23495 +13988 +20952 +284 +24532 +1090 +286 +337 +713 +25212 +1090 +590 +25213 +25214 +11762 +25215 +24617 +25216 +349 +25217 +14660 +14001 +1224 +43 +249 +25218 +18037 +25219 +509 +222 +43 +14827 +21947 +237 +43 +15718 +24144 +12287 +10 +17151 +3546 +25220 +284 +2577 +25221 +25222 +25223 +89 +25224 +25225 +15718 +7053 +25226 +14619 +25227 +43 +25228 +21276 +586 +11966 +25229 +590 +915 +7835 +17151 +25230 +25231 +425 +25232 +411 +349 +590 +25233 +35 +25234 +3546 +13648 +16121 +25235 +323 +25236 +4411 +4547 +24144 +25237 +155 +1224 +303 +25238 +57 +17151 +24036 +12987 +25239 +5780 +25240 +43 +24045 +25241 +9 +18896 +53 +21698 +1203 +21569 +32 +24896 +25242 +20199 +25243 +25244 +586 +25245 +25246 +25247 +821 +57 +1885 +19597 +25248 +770 +25249 +12479 +25250 +25251 +25252 +1018 +57 +25253 +24725 +1021 +2260 +4490 +2978 +25254 +25255 +12934 +25256 +25257 +24045 +1090 +25258 +25259 +14887 +5085 +25260 +2287 +19655 +720 +9 +25261 +9939 +25262 +20803 +25263 +35 +138 +15718 +19618 +14143 +14000 +2971 +25264 +1310 +25265 +14477 +25266 +25267 +248 +4550 +213 +299 +25268 +25269 +57 +22963 +4760 +19618 +23103 +23741 +25270 +1415 +2318 +43 +303 +1700 +25271 +19439 +20 +9705 +349 +25272 +25273 +25274 +487 +19618 +13713 +22963 +25275 +5650 +24978 +2042 +20212 +43 +590 +1655 +25276 +6766 +25277 +1700 +3546 +12812 +14 +1956 +536 +15824 +14 +19 +1384 +10094 +25278 +24896 +18044 +25279 +19334 +25280 +2756 +1688 +21947 +15238 +1048 +25281 +155 +19 +9688 +25282 +7048 +1047 +590 +2577 +4166 +8895 +345 +14 +25283 +1295 +155 +25284 +11966 +25285 +25286 +24303 +25287 +25288 +25289 +4502 +25290 +25291 +57 +25292 +25293 +7835 +25294 +24896 +966 +15311 +25295 +3128 +25296 +21947 +19797 +13721 +21947 +5376 +379 +6341 +5415 +57 +25297 +9 +43 +13721 +554 +893 +25298 +25299 +20 +5085 +20 +32 +7110 +25300 +25301 +8297 +24144 +17228 +10002 +590 +3601 +8188 +20450 +9 +25302 +5780 +14369 +25303 +43 +25304 +20530 +24646 +1316 +1812 +25305 +18548 +25306 +176 +590 +98 +8188 +25307 +21031 +43 +683 +21999 +24303 +25308 +12987 +25309 +25310 +24303 +2909 +379 +24303 +3034 +98 +7053 +24061 +21947 +25311 +25312 +4463 +25313 +14 +57 +9 +43 +25314 +43 +25315 +1823 +25316 +651 +1425 +25317 +25318 +24978 +21947 +25319 +1049 +25320 +817 +2314 +25321 +17670 +25322 +14477 +9 +14 +269 +19 +25323 +25324 +25325 +25326 +2476 +5119 +14477 +25327 +519 +15544 +21947 +13721 +16024 +19 +24896 +25328 +59 +25329 +1617 +25330 +4237 +1680 +25331 +345 +736 +8244 +43 +43 +13721 +43 +25332 +286 +2 +8295 +14000 +25333 +379 +3553 +25334 +9 +2040 +22 +282 +303 +25335 +14369 +21947 +19 +25336 +970 +25337 +5074 +21889 +3546 +25338 +25339 +448 +25340 +1013 +25341 +23103 +209 +14369 +9 +17872 +25342 +14527 +15406 +349 +16211 +14363 +24896 +25343 +13721 +15718 +25344 +14 +198 +24896 +21834 +3999 +7991 +15 +1514 +43 +25345 +16437 +17635 +19646 +23406 +25346 +3034 +25347 +25348 +25349 +15718 +25350 +19618 +25351 +1615 +25352 +20 +3546 +38 +15 +1612 +765 +2 +25353 +25354 +25355 +590 +18317 +25356 +1090 +25357 +1513 +5085 +60 +25358 +2260 +2 +25359 +43 +11249 +19797 +21947 +89 +14215 +25360 +25361 +560 +25362 +25363 +2556 +25364 +25365 +20019 +201 +25366 +411 +1605 +16437 +17236 +25367 +43 +155 +357 +590 +9402 +25368 +25369 +2577 +25370 +25371 +25372 +25373 +25374 +25375 +12987 +25376 +13375 +3484 +24303 +10 +1013 +25377 +25378 +25379 +5085 +590 +8668 +25172 +25380 +22308 +10117 +1425 +21031 +2728 +25381 +25382 +1991 +155 +19 +4458 +25383 +2577 +25384 +9 +736 +573 +14 +10298 +20161 +25385 +21947 +9 +14515 +77 +24045 +13721 +9560 +25386 +155 +25387 +178 +8351 +24303 +25388 +345 +286 +1425 +9 +25389 +590 +13760 +15511 +25390 +25391 +22587 +25392 +2308 +25393 +25394 +25395 +25237 +4315 +6928 +809 +25396 +25397 +5085 +2061 +25398 +323 +25399 +22 +590 +14369 +9 +25400 +21947 +2776 +25401 +25402 +16103 +22923 +11321 +286 +25403 +16437 +1300 +17151 +7208 +25404 +77 +17144 +25405 +3546 +21947 +22652 +1090 +23368 +25406 +25407 +25408 +2 +25237 +25409 +24896 +2 +25410 +21998 +25411 +25412 +9 +15718 +9 +25413 +14 +16 +25414 +155 +208 +9 +25415 +52 +3026 +25416 +3546 +25417 +20700 +25418 +17670 +1384 +597 +4 +189 +19618 +25419 +250 +25420 +25421 +713 +43 +25422 +3842 +25423 +25424 +9 +3 +764 +24303 +4536 +43 +2406 +707 +25425 +25426 +1384 +16003 +554 +14962 +25427 +25428 +25429 +25430 +10028 +25431 +155 +23103 +209 +13116 +4747 +19 +25432 +25433 +1295 +2324 +25434 +1870 +24302 +25435 +25436 +439 +25437 +13905 +25438 +14369 +25439 +1710 +1021 +3546 +22 +412 +4855 +25440 +2 +24303 +25441 +7053 +25442 +3645 +57 +25443 +1542 +23103 +590 +15572 +25444 +915 +15 +25445 +25446 +25447 +21947 +6701 +25448 +25449 +21947 +23103 +18998 +13905 +25450 +3981 +43 +3655 +201 +35 +554 +915 +17151 +286 +15718 +13375 +14477 +25334 +13721 +25451 +19 +736 +43 +2804 +18798 +248 +32 +4536 +337 +25452 +25453 +25454 +228 +25455 +76 +188 +25456 +25457 +3863 +25458 +14369 +345 +9 +25227 +25459 +9 +6275 +2609 +6764 +25460 +25461 +3546 +442 +13855 +25462 +25463 +3546 +25464 +201 +12937 +25465 +19576 +21627 +3241 +1559 +12671 +25466 +248 +44 +736 +25467 +25468 +25469 +13139 +345 +25470 +9 +25471 +24864 +52 +19655 +6950 +8218 +43 +43 +5438 +25472 +25473 +20803 +337 +9396 +248 +25474 +25475 +590 +32 +2542 +25476 +345 +2769 +57 +1364 +25477 +16671 +25478 +14581 +25479 +5755 +25480 +13988 +337 +1559 +15718 +25481 +14776 +24303 +25482 +2029 +25483 +25484 +25485 +248 +25486 +3610 +25487 +21947 +12832 +5085 +25488 +5963 +25489 +21947 +25490 +15718 +25491 +25492 +8668 +2 +21947 +2009 +12053 +286 +25493 +21908 +25494 +194 +25495 +43 +1364 +25496 +25497 +25498 +32 +43 +3 +43 +15718 +590 +24256 +745 +18685 +25499 +43 +25500 +1364 +25501 +25502 +14 +1961 +8798 +15718 +4550 +1444 +272 +25503 +3310 +2 +1566 +4425 +941 +9 +10 +25504 +21947 +25505 +19528 +18503 +23323 +25506 +25507 +16466 +13131 +25508 +25509 +25510 +5085 +15699 +2 +25364 +25511 +647 +24864 +720 +15718 +25512 +14 +9 +25513 +25514 +25515 +495 +6095 +595 +25516 +43 +11822 +4403 +4808 +25517 +25518 +10 +590 +248 +13721 +1991 +16118 +21689 +686 +25519 +19618 +25520 +379 +25521 +25522 +5627 +14363 +3546 +21947 +25523 +25524 +21689 +9561 +24864 +10 +25525 +13721 +155 +284 +24725 +25526 +25527 +25528 +2769 +14240 +16 +14 +7891 +303 +1559 +286 +357 +43 +25529 +248 +25530 +1765 +15038 +653 +25531 +25532 +25533 +17920 +1812 +751 +3546 +21672 +9 +25534 +831 +21627 +9705 +9 +1247 +533 +188 +3 +14131 +25535 +278 +21563 +8967 +3964 +21689 +10946 +25536 +25537 +24303 +25538 +13721 +20682 +25539 +1212 +213 +6096 +19 +23103 +25540 +12255 +89 +6621 +2790 +1423 +303 +3939 +3978 +1716 +8566 +14369 +25541 +25542 +25543 +19 +237 +24045 +3543 +25544 +18064 +25545 +18045 +14369 +18798 +4463 +25546 +272 +2253 +339 +20228 +9 +2086 +25547 +25548 +25549 +25550 +17920 +43 +15 +24896 +2135 +10325 +21947 +24144 +7053 +1989 +43 +25551 +25552 +25553 +16437 +22977 +590 +25554 +25555 +25556 +22075 +292 +25557 +20952 +484 +25558 +2 +3976 +14 +14 +18048 +2998 +2325 +25559 +42 +15978 +13375 +5780 +25560 +16437 +10 +15556 +14369 +1208 +24896 +1286 +1715 +7923 +2694 +25237 +25561 +22268 +13748 +24303 +15308 +25562 +19618 +25563 +25564 +694 +25565 +23832 +1578 +10356 +13307 +155 +188 +19 +19 +8098 +25566 +25567 +19 +25568 +192 +11736 +25569 +19304 +345 +1048 +25570 +3171 +25571 +25572 +21947 +14 +222 +25573 +15718 +12 +3491 +5542 +647 +25574 +16437 +7379 +339 +25575 +25576 +19618 +1442 +1208 +9842 +14001 +713 +25577 +25578 +25579 +25580 +57 +23608 +11483 +25581 +25582 +24303 +11995 +25583 +21947 +595 +25584 +25585 +25586 +21947 +17134 +185 +25587 +3480 +25588 +25589 +43 +15783 +1559 +19618 +3546 +1154 +2356 +3601 +25590 +349 +25584 +25591 +616 +25592 +25593 +25594 +25595 +25596 +155 +25597 +7836 +222 +19618 +12479 +14477 +24144 +14477 +43 +11762 +19 +25598 +2694 +25599 +3601 +25600 +14369 +21869 +5340 +286 +10642 +209 +25601 +19618 +20339 +1425 +18612 +25602 +345 +25603 +21689 +345 +13754 +10356 +14369 +10265 +6655 +3543 +13317 +2415 +19404 +14477 +25334 +1229 +14 +98 +21947 +1612 +57 +8566 +43 +1765 +25604 +25605 +19618 +1220 +25606 +590 +358 +25607 +25608 +25609 +18384 +286 +25610 +25611 +189 +25237 +25612 +25613 +25614 +25615 +25616 +365 +3546 +25617 +25618 +892 +2260 +1013 +25619 +25620 +887 +9 +677 +12722 +15718 +2157 +43 +683 +25621 +25622 +4851 +8367 +24864 +25623 +20616 +43 +25624 +25625 +286 +14477 +25626 +11762 +25627 +57 +21947 +25628 +137 +20442 +6883 +25629 +3546 +14 +13721 +19655 +25630 +14660 +590 +17698 +1295 +10094 +25631 +16437 +25632 +25633 +4550 +25634 +15762 +3395 +788 +25635 +25636 +109 +915 +25637 +536 +24725 +4806 +16190 +2694 +22666 +590 +25638 +3546 +25639 +17920 +16121 +720 +19 +24303 +25640 +24877 +4550 +14017 +20 +24864 +15718 +21689 +25641 +25642 +21529 +25643 +13721 +57 +25644 +43 +554 +25645 +25646 +25647 +25334 +25648 +25649 +21947 +345 +25650 +377 +13721 +17151 +1566 +286 +25651 +2029 +15718 +25652 +3787 +25653 +3546 +43 +1562 +10030 +2593 +6616 +179 +3239 +15216 +1605 +3548 +201 +2697 +25654 +15054 +196 +2243 +25655 +25656 +25657 +25658 +19 +25237 +25659 +18695 +57 +2175 +25660 +19 +13721 +590 +3546 +14369 +4414 +8668 +25661 +10338 +25159 +5031 +3908 +24919 +23697 +23103 +2 +272 +509 +25662 +11702 +19655 +25663 +24864 +19 +4961 +14 +24896 +4 +15718 +19286 +25664 +7855 +25503 +12741 +1295 +9 +554 +14 +25665 +19 +13721 +9993 +25666 +25667 +590 +25668 +24045 +286 +2476 +590 +17284 +2609 +2318 +2540 +14369 +14477 +9 +25669 +20 +46 +1241 +3546 +14363 +193 +19618 +13127 +2260 +248 +2287 +9 +11211 +25670 +25671 +3050 +14343 +1011 +25672 +25673 +25674 +20 +613 +19404 +1300 +1208 +57 +114 +379 +495 +2550 +1384 +25675 +25676 +25677 +25678 +10 +25679 +24207 +1972 +18896 +25237 +23406 +590 +590 +1051 +25680 +4463 +25681 +25682 +19 +7855 +4951 +2 +2029 +1172 +155 +25683 +25684 +303 +25685 +25686 +14 +25687 +25688 +23603 +213 +416 +25689 +2 +19 +25690 +43 +18874 +845 +20 +745 +745 +18749 +25691 +554 +25692 +25237 +17670 +25693 +5780 +8869 +720 +19 +25694 +10406 +25695 +613 +590 +14369 +590 +25696 +14369 +25697 +15 +25698 +7855 +213 +16118 +17151 +3353 +20 +18956 +25699 +4518 +14369 +4315 +248 +25700 +303 +25701 +15004 +23608 +14363 +8668 +373 +286 +9784 +1364 +5415 +15 +379 +22787 +13721 +32 +15018 +25702 +1212 +2622 +16437 +22273 +16480 +25703 +25704 +2958 +1090 +1085 +3 +25705 +25706 +21332 +25707 +19 +3119 +19618 +25237 +14369 +19404 +25708 +14 +25709 +25710 +4263 +590 +25711 +15718 +7154 +25712 +14 +25713 +337 +7531 +21947 +25714 +19 +7532 +9539 +15 +18792 +10236 +337 +14369 +24896 +8297 +303 +25715 +38 +345 +303 +303 +25716 +15000 +411 +2 +25717 +2733 +5204 +20768 +3546 +25718 +25719 +25720 +2009 +25721 +25722 +25723 +21947 +25724 +20572 +13523 +20 +14 +25725 +590 +25726 +590 +4116 +764 +286 +25727 +13529 +25728 +4550 +19618 +25729 +25730 +34 +25 +43 +24978 +5558 +25731 +185 +25237 +590 +1316 +25732 +1488 +25733 +379 +16790 +21988 +25734 +5877 +24896 +14583 +14477 +1578 +43 +7053 +736 +1082 +25735 +17151 +115 +1562 +286 +25736 +1212 +14 +25737 +284 +25738 +15511 +2131 +25683 +21947 +13721 +43 +19618 +25739 +9144 +1018 +827 +22317 +25740 +586 +19404 +25741 +25742 +25743 +7419 +25744 +1013 +665 +21947 +3599 +14124 +12005 +5188 +720 +9 +25745 +25746 +25747 +15 +590 +43 +25748 +11995 +15 +1465 +25749 +24497 +286 +9 +440 +22 +25750 +19655 +25751 +23103 +4793 +21885 +720 +5780 +57 +14604 +1169 +25752 +25753 +2697 +15094 +14477 +3034 +8668 +25754 +25755 +137 +345 +3 +25756 +2195 +14369 +25757 +2197 +22967 +16780 +2197 +25237 +4550 +25758 +25759 +25760 +3660 +25761 +18942 +25762 +25763 +745 +1446 +25764 +1100 +248 +25765 +25766 +14604 +9 +25767 +9 +597 +24896 +13361 +19404 +25768 +25769 +19618 +249 +25770 +25771 +21689 +12729 +23103 +13566 +24715 +19 +72 +2 +13721 +17151 +7457 +15 +22 +43 +248 +1013 +24896 +15844 +25772 +25773 +25683 +590 +9 +43 +25162 +21947 +14 +25774 +21947 +5085 +25775 +16028 +25776 +25777 +6517 +57 +14604 +345 +19618 +25778 +57 +19618 +720 +25779 +12987 +17083 +43 +25780 +1090 +15854 +201 +25781 +155 +209 +24725 +22308 +25782 +25783 +25784 +10230 +25785 +43 +11762 +23103 +9617 +25786 +648 +2197 +43 +9 +18406 +25787 +25788 +89 +337 +13959 +25789 +14 +25790 +12808 +3553 +2577 +25791 +14 +22468 +590 +2499 +25792 +736 +24785 +32 +14 +25793 +43 +14369 +3279 +286 +14 +18778 +17151 +3 +25794 +43 +25795 +1976 +25796 +25797 +25798 +25799 +21486 +272 +8465 +315 +13721 +16466 +13721 +19655 +15718 +15 +16118 +9 +11162 +25800 +32 +1829 +25801 +25802 +8668 +25803 +25804 +25805 +25806 +554 +8668 +25807 +43 +25808 +25809 +19091 +337 +24303 +14369 +43 +25810 +25811 +286 +10477 +590 +23103 +25812 +736 +14 +18372 +14363 +3546 +2694 +25813 +13721 +25814 +849 +25815 +21947 +18670 +573 +20941 +24864 +14435 +25816 +1091 +11754 +14 +11176 +25817 +5833 +6341 +432 +14 +25818 +14 +3291 +25819 +3335 +10946 +24978 +5780 +19 +25820 +25821 +20161 +25822 +25823 +248 +25382 +25824 +8297 +3546 +24864 +345 +32 +2056 +25825 +25826 +25827 +4581 +25828 +18421 +1889 +25829 +25830 +3 +13578 +25334 +15 +345 +9234 +25831 +2035 +25832 +14369 +6457 +25833 +25834 +16866 +286 +25835 +2029 +2389 +1234 +20339 +2197 +1637 +21947 +25836 +209 +25837 +19 +1382 +32 +25838 +25839 +25840 +25841 +1542 +25842 +665 +25237 +9 +286 +25843 +3484 +7604 +19618 +25844 +25845 +9566 +25846 +677 +4020 +201 +25847 +25848 +3601 +248 +21947 +4518 +8218 +25659 +21947 +14658 +7291 +1316 +24864 +284 +43 +2052 +5582 +10993 +707 +25334 +25849 +25850 +25851 +25852 +7053 +22308 +23103 +23603 +213 +25853 +21371 +2577 +1147 +19 +14 +25854 +17480 +25855 +25856 +19091 +25857 +25858 +98 +25859 +14604 +3546 +57 +9449 +590 +1542 +7137 +17349 +15 +25860 +25202 +2724 +25861 +14 +13372 +32 +213 +1051 +25862 +19618 +13721 +25863 +25864 +21698 +25865 +14369 +2 +1765 +21835 +12397 +665 +3546 +1100 +22717 +2882 +4441 +25866 +19618 +337 +8668 +25867 +694 +25868 +284 +18695 +2121 +25869 +20 +25870 +24303 +989 +3978 +9 +32 +3119 +25871 +6110 +25872 +25873 +20 +25874 +8427 +24907 +25875 +1715 +4616 +25876 +213 +25877 +155 +57 +1244 +25878 +491 +25879 +1563 +303 +8029 +10290 +9 +21126 +6372 +25880 +337 +358 +303 +16121 +25881 +25882 +25883 +1742 +248 +25884 +25885 +25584 +1090 +25886 +19 +1018 +15705 +213 +25887 +25888 +23666 +15 +25889 +18798 +272 +32 +25890 +19 +720 +25891 +25892 +24951 +24896 +24896 +3484 +442 +25893 +4 +25894 +4684 +25895 +18045 +6741 +14 +24862 +5649 +3546 +24864 +25896 +25897 +25898 +3546 +1812 +3543 +25899 +25900 +21698 +6212 +25901 +3546 +14 +25902 +11593 +43 +24303 +1134 +345 +25903 +3546 +1817 +25904 +25905 +1357 +25906 +272 +2314 +590 +9 +5780 +590 +514 +25907 +2 +25908 +25909 +590 +25910 +19618 +14079 +25911 +566 +43 +13721 +21947 +7917 +96 +4285 +2809 +1991 +13721 +25912 +1049 +286 +1542 +25913 +2 +590 +17082 +25914 +2476 +8255 +19618 +514 +10011 +43 +25915 +98 +25916 +25917 +43 +2314 +1517 +25918 +303 +14369 +24862 +25919 +19931 +590 +373 +4550 +15718 +25920 +25921 +25636 +21031 +201 +303 +25922 +25923 +25924 +25925 +25926 +25927 +1961 +8280 +25928 +19362 +25929 +25930 +23547 +2830 +24978 +25931 +25932 +14 +25933 +14477 +14369 +5614 +15718 +13721 +1423 +25934 +19 +23727 +3543 +3546 +25935 +2197 +25936 +25937 +25938 +9578 +25939 +155 +25940 +14 +18300 +72 +7743 +25941 +3546 +25942 +11754 +590 +155 +6785 +7053 +286 +5088 +10946 +25943 +809 +373 +25944 +22963 +24303 +14 +9410 +25945 +25946 +25947 +25948 +25949 +25584 +25950 +12 +25951 +4280 +24725 +25952 +2764 +20339 +13111 +16140 +25953 +25954 +2201 +10030 +137 +4050 +21947 +25955 +5204 +464 +12067 +16885 +25237 +170 +3546 +14 +13721 +22 +6459 +25956 +18178 +1577 +25957 +14604 +25958 +25959 +1300 +1160 +20 +373 +25683 +345 +13721 +20645 +13721 +19618 +201 +25960 +19618 +3030 +13721 +1364 +19 +554 +25871 +3709 +21045 +3338 +373 +22940 +43 +349 +9123 +18982 +3546 +3546 +36 +19 +25961 +25962 +19931 +6261 +533 +3546 +6794 +25963 +6928 +25964 +13721 +25965 +14 +159 +24144 +25584 +25146 +25966 +19218 +8188 +43 +590 +43 +19618 +3353 +25967 +228 +25659 +7053 +2707 +23103 +25968 +6095 +1082 +25969 +25970 +25971 +22986 +2009 +43 +25972 +286 +25973 +25974 +10108 +25975 +9410 +23103 +17654 +23071 +2136 +23196 +25976 +1817 +1765 +3546 +4990 +25977 +48 +14369 +15 +25978 +19 +25979 +25980 +538 +17151 +188 +25981 +25237 +15038 +25982 +16437 +25983 +15718 +286 +25984 +21689 +25985 +6518 +9 +25986 +270 +16618 +25987 +286 +11762 +24896 +6004 +20329 +25988 +5085 +25989 +18695 +25990 +16798 +25991 +22787 +495 +20063 +590 +19 +21689 +25992 +4463 +25993 +16 +53 +25994 +25995 +32 +32 +25996 +14369 +1743 +24303 +1804 +25997 +43 +14369 +25998 +14369 +25999 +26000 +26001 +14069 +26002 +1961 +26003 +554 +26004 +21947 +26005 +19478 +519 +89 +26006 +15824 +5803 +272 +26007 +2000 +19618 +188 +26008 +958 +26009 +15998 +26010 +26011 +554 +26012 +26013 +1013 +22065 +1961 +554 +26014 +26015 +1021 +26016 +9 +142 +1524 +26017 +12506 +14 +19404 +26018 +9 +7886 +19655 +15592 +9937 +26019 +590 +5780 +3394 +1529 +17609 +13721 +3077 +9 +536 +11762 +9 +21947 +26020 +26021 +13721 +14 +19 +21031 +43 +26022 +586 +26023 +1991 +26024 +2316 +11762 +1013 +26025 +26026 +613 +19 +377 +345 +26027 +24864 +26028 +18045 +26029 +26030 +24303 +26031 +26032 +26033 +26034 +26035 +14369 +349 +1642 +3067 +19091 +12987 +179 +24725 +213 +19 +43 +26036 +26037 +736 +7053 +19 +21734 +1300 +26038 +19 +17084 +26039 +5627 +155 +26040 +1012 +21689 +8015 +19618 +57 +2410 +10 +8351 +32 +12067 +26041 +7357 +3546 +23490 +26042 +26043 +14477 +554 +9 +26044 +26045 +6950 +26046 +26047 +26048 +98 +14369 +2537 +32 +26049 +20195 +8248 +21947 +101 +8053 +26050 +11804 +3546 +1912 +9 +19 +15718 +17151 +26051 +12826 +5117 +26052 +1384 +26053 +1784 +26054 +915 +26055 +26056 +17112 +89 +21947 +26057 +9 +26058 +26059 +15541 +11282 +26060 +225 +26061 +278 +665 +14 +14278 +21947 +19218 +13566 +26062 +26063 +590 +26064 +89 +590 +22302 +57 +26065 +43 +52 +3546 +2577 +26066 +21947 +1364 +16102 +13396 +26067 +12005 +26068 +26069 +14369 +7912 +1382 +1011 +17982 +3546 +17400 +155 +12404 +208 +8721 +20068 +16941 +4411 +32 +24896 +26070 +26071 +24864 +26072 +345 +13721 +1742 +26073 +24725 +14363 +647 +6571 +14477 +17911 +26074 +573 +2978 +43 +8367 +26075 +26076 +590 +19 +26077 +20497 +872 +720 +26078 +12005 +861 +13721 +349 +1100 +3546 +21689 +24732 +519 +26079 +26080 +155 +26081 +14369 +590 +26082 +11647 +9617 +18045 +26083 +26084 +3546 +10385 +43 +3546 +17151 +677 +26085 +647 +22918 +736 +14369 +4221 +1300 +1561 +26086 +272 +26087 +4388 +26088 +43 +26089 +13539 +17136 +26090 +19404 +26091 +13721 +1739 +24339 +16437 +24978 +1768 +207 +2 +26092 +26093 +26094 +14 +9 +26095 +317 +26096 +26097 +26098 +19 +7137 +26099 +21947 +3546 +590 +26100 +26101 +8668 +8967 +1107 +18045 +22963 +43 +862 +38 +26102 +26103 +26104 +19 +2 +2040 +26105 +26106 +345 +1917 +16102 +971 +3601 +26107 +590 +26108 +14 +43 +19823 +26109 +26110 +9 +3978 +21947 +26111 +528 +1172 +14 +24864 +26112 +345 +15104 +26113 +13375 +14369 +32 +17698 +24303 +282 +26114 +29 +14 +865 +14 +677 +26115 +24864 +26116 +26117 +17151 +4463 +1234 +26118 +26119 +26120 +14 +26121 +26122 +1612 +26123 +2694 +9 +566 +16437 +26124 +7987 +26125 +26126 +4230 +4550 +4764 +26127 +26128 +2 +26129 +13330 +1018 +14001 +24565 +24864 +19618 +26130 +7291 +26131 +53 +21689 +4 +14369 +590 +43 +14369 +17151 +26132 +26133 +4088 +12768 +21947 +26134 +5085 +7014 +13721 +26135 +12152 +26136 +15 +5780 +26137 +1090 +26138 +26139 +26140 +26141 +14363 +1112 +26142 +26143 +26144 +790 +234 +26145 +590 +3242 +398 +14 +26146 +8392 +13701 +140 +1382 +26147 +26148 +2009 +26149 +26150 +26151 +14369 +14 +26152 +21947 +14 +26153 +43 +349 +14369 +26154 +26155 +19797 +5446 +22 +26156 +1520 +720 +17136 +23122 +26157 +16014 +1090 +26158 +379 +43 +26159 +24725 +26160 +4463 +358 +26161 +14693 +7053 +26162 +590 +26163 +7048 +14814 +26164 +26165 +57 +399 +57 +26166 +26167 +25237 +26168 +14369 +26169 +14369 +19 +19618 +14185 +26170 +590 +21947 +24144 +845 +26171 +32 +43 +519 +3546 +25237 +26172 +345 +1021 +26173 +16118 +25833 +9 +1465 +14369 +21947 +26174 +6776 +17846 +345 +26175 +1100 +26176 +590 +9 +21947 +26177 +26178 +43 +2733 +26179 +26180 +19618 +137 +1738 +4918 +26181 +57 +13856 +8798 +4526 +20645 +26182 +21947 +333 +21689 +7137 +1013 +26183 +14909 +26184 +26185 +554 +26186 +15694 +22 +26187 +13721 +286 +26188 +14 +2919 +26189 +26190 +19 +43 +345 +14 +24790 +24303 +26191 +14 +29 +4088 +26192 +17151 +14 +26001 +1870 +26193 +14 +26194 +1010 +379 +26195 +26196 +968 +597 +26197 +26198 +23541 +4550 +377 +590 +43 +26199 +13484 +887 +26200 +21947 +26201 +286 +26202 +9 +26203 +26204 +23290 +286 +18591 +1224 +26205 +24864 +18019 +21947 +345 +1823 +26206 +43 +6620 +9431 +26207 +26208 +26209 +25683 +26210 +3546 +590 +24303 +26211 +1091 +19 +14604 +26212 +358 +3546 +3559 +26213 +26214 +21689 +36 +24303 +26215 +9400 +25659 +26216 +7137 +26217 +323 +3546 +25683 +7032 +1612 +8037 +26218 +5117 +501 +345 +720 +590 +13721 +26219 +7982 +24303 +19538 +26220 +26221 +590 +26222 +2770 +3330 +26223 +14 +3519 +827 +26224 +26225 +15 +3338 +484 +18383 +26226 +11822 +1208 +26227 +14604 +26228 +21947 +8668 +15906 +19 +4855 +20942 +26229 +25237 +3546 +25659 +15240 +736 +14477 +26230 +26231 +2034 +104 +8967 +16102 +924 +5326 +7588 +26232 +26233 +3978 +26234 +7053 +4518 +8110 +558 +14 +19109 +457 +590 +26235 +26236 +26237 +1502 +13361 +19 +26238 +19618 +2832 +21947 +26239 +14 +809 +590 +14 +3553 +26240 +19618 +26241 +19030 +23192 +14 +26242 +7855 +26243 +14477 +26244 +10 +4070 +564 +26245 +3119 +647 +21947 +26246 +519 +26247 +590 +14992 +14935 +26248 +26249 +12479 +59 +22269 +7357 +32 +26250 +26251 +1924 +26252 +1870 +18655 +16925 +9543 +3546 +590 +26253 +13405 +26254 +26255 +16437 +26256 +140 +26257 +26258 +17151 +26259 +43 +25927 +2260 +11274 +89 +26260 +11321 +9 +98 +22468 +112 +9779 +624 +3330 +2019 +495 +10 +22552 +5305 +14477 +286 +1316 +8177 +19 +26261 +20265 +26262 +10706 +26263 +26264 +26265 +23727 +26266 +14 +10364 +26267 +19 +7835 +43 +26268 +15 +26269 +6261 +1316 +474 +14342 +26270 +26271 +26272 +14 +26273 +533 +26274 +26275 +22500 +17136 +26276 +4550 +26277 +26278 +13131 +736 +14000 +21885 +22 +25334 +11762 +6479 +26279 +26280 +7477 +26281 +26282 +26283 +20340 +21947 +26284 +5085 +13361 +43 +2804 +15718 +32 +713 +1989 +19 +8188 +115 +209 +827 +345 +6627 +57 +26285 +26286 +1100 +185 +26287 +14369 +26288 +13484 +14 +26289 +26290 +21947 +1817 +14604 +15914 +645 +26291 +26292 +208 +1013 +16437 +8994 +26293 +24862 +26294 +23406 +3546 +9 +13619 +21947 +26295 +26296 +14 +26297 +26298 +25140 +745 +26299 +43 +14363 +9 +21947 +209 +3764 +43 +17151 +33 +17151 +26300 +14962 +24864 +16949 +26301 +9849 +8316 +1425 +3546 +1066 +26302 +1514 +26303 +24896 +26304 +5614 +26305 +17228 +26306 +26307 +155 +915 +2561 +590 +9 +13721 +1512 +590 +5085 +26308 +26309 +10 +286 +43 +14369 +26310 +19 +9 +26311 +26312 +3546 +6499 +5780 +43 +20946 +43 +26313 +590 +26314 +1124 +26315 +26316 +26317 +26318 +14 +19 +26319 +26320 +26321 +26322 +14 +887 +43 +19209 +16118 +5085 +272 +2325 +713 +26323 +57 +26324 +590 +57 +12722 +196 +2577 +1817 +373 +817 +26325 +5085 +26326 +26327 +2410 +349 +26328 +3950 +10846 +1655 +26329 +2121 +20676 +671 +2577 +590 +861 +22236 +24269 +26330 +3343 +188 +19931 +16819 +26331 +11762 +3546 +16695 +3924 +26332 +26333 +26334 +26335 +21947 +32 +26336 +26337 +590 +26338 +155 +22075 +24227 +26339 +3546 +2064 +6251 +18045 +26340 +13721 +25237 +26341 +487 +2427 +26342 +3460 +21947 +25928 +25758 +26343 +19 +1021 +19209 +1823 +26344 +26345 +2029 +790 +53 +4550 +77 +18136 +26346 +2197 +16125 +23103 +16369 +26347 +14369 +26348 +21947 +26349 +286 +12936 +14369 +26350 +6560 +26351 +349 +26352 +25564 +188 +26353 +26354 +590 +26355 +24207 +10621 +2694 +26356 +14369 +26357 +21947 +26358 +3978 +22 +26359 +26360 +26361 +424 +26362 +14 +26363 +26364 +22308 +4502 +26365 +13149 +26366 +4550 +26367 +536 +6010 +1338 +26368 +10642 +26369 +286 +14369 +26370 +26371 +352 +3376 +23547 +3978 +9 +26372 +155 +26373 +21947 +26374 +26375 +24864 +26376 +2310 +26377 +6950 +26378 +21947 +15216 +9 +24423 +19618 +26379 +586 +1222 +155 +14477 +3243 +26380 +14 +3546 +43 +1961 +18579 +14 +14477 +590 +26381 +3484 +26382 +26383 +16941 +8651 +26384 +936 +26385 +14369 +251 +26386 +43 +43 +26387 +26388 +20 +9 +26389 +26390 +26391 +26392 +26393 +26394 +3171 +5627 +19618 +14 +43 +2260 +14604 +26395 +26396 +1369 +1882 +26397 +13307 +26398 +10 +26399 +13897 +21947 +24303 +26400 +3649 +26401 +26402 +554 +17653 +13457 +26403 +14 +26404 +13149 +26405 +2694 +26406 +568 +590 +26407 +43 +26408 +26409 +26410 +155 +23037 +2260 +26411 +26412 +26413 +25683 +26414 +26415 +23103 +25683 +24144 +1710 +14 +26416 +554 +26417 +26418 +3553 +26419 +9 +26420 +26421 +19618 +9 +24864 +11762 +14 +43 +26422 +26423 +26424 +89 +5085 +14369 +26425 +26426 +22963 +3 +21947 +43 +19 +21947 +26427 +17151 +3546 +43 +17607 +21947 +19404 +26428 +9837 +19 +1870 +26429 +1051 +26430 +9 +43 +25584 +8188 +26431 +5803 +4 +26432 +764 +26433 +3546 +26434 +15718 +22 +26435 +26436 +70 +26403 +26437 +5584 +26438 +1224 +26439 +26440 +14843 +26441 +827 +26442 +155 +10428 +26443 +18951 +26444 +590 +5085 +26445 +26446 +13129 +12987 +43 +250 +43 +26447 +26448 +60 +26449 +26450 +671 +12304 +272 +1364 +26451 +26452 +43 +14369 +14152 +2769 +16118 +26453 +26454 +3252 +15647 +26455 +2040 +8465 +14343 +26456 +8188 +2733 +3 +25683 +26457 +26458 +7835 +323 +57 +26459 +19618 +2065 +25683 +26460 +26461 +12 +24896 +26462 +26463 +26464 +22042 +9 +26465 +16121 +822 +15809 +17346 +683 +26466 +15718 +8668 +15 +22798 +26467 +2029 +15 +8670 +1090 +14 +514 +6341 +3553 +43 +357 +25140 +20161 +1875 +8351 +8103 +43 +2 +26468 +26469 +6877 +14 +446 +286 +19618 +14211 +26470 +26471 +10 +13150 +10486 +26472 +19 +5085 +1961 +26473 +21947 +21947 +7183 +4855 +15810 +26474 +19 +24896 +558 +3946 +26475 +21947 +14369 +26476 +8953 +415 +3546 +1559 +14 +2728 +26477 +26478 +3470 +9 +22 +12155 +26479 +26480 +9 +13721 +2 +26481 +9819 +791 +26482 +21947 +26483 +26484 +19 +12067 +17790 +14477 +26485 +26486 +26487 +26488 +590 +3546 +14369 +10774 +26489 +26490 +15466 +26491 +26492 +11374 +823 +26493 +590 +14 +26494 +26495 +9 +22485 +96 +43 +3063 +17151 +26496 +26497 +915 +26498 +11964 +26499 +2 +646 +536 +26500 +24725 +1834 +272 +26501 +26502 +3801 +26503 +6499 +19 +20941 +7053 +25683 +26504 +26505 +590 +647 +26506 +6072 +26507 +26508 +7907 +26509 +25237 +4387 +26510 +26511 +1200 +345 +974 +222 +26512 +26513 +2795 +3105 +26514 +26515 +338 +21947 +26516 +7810 +26517 +14603 +26518 +26519 +32 +19618 +11229 +21947 +2449 +26520 +286 +1542 +8496 +26521 +11754 +26522 +9 +26403 +26523 +1817 +715 +26524 +26525 +3317 +21947 +3546 +936 +590 +26526 +827 +26527 +26528 +26529 +19 +2 +26530 +15948 +26531 +19928 +872 +26532 +19 +1011 +736 +26533 +590 +26534 +24017 +4650 +832 +11845 +26535 +26536 +26537 +249 +26538 +18695 +26539 +18695 +348 +23343 +249 +17039 +26540 +21947 +26541 +26542 +26543 +806 +25140 +26544 +26545 +21947 +26546 +9074 +32 +4550 +26547 +590 +26548 +26549 +26550 +10642 +19 +286 +6877 +26551 +58 +43 +26552 +19 +9410 +43 +26553 +201 +14369 +25584 +16876 +21689 +24039 +25683 +3546 +25584 +15 +1066 +17151 +26554 +14 +26555 +3546 +26556 +196 +554 +14369 +19 +25334 +286 +9 +17033 +22 +9074 +26557 +43 +554 +26558 +415 +17411 +26559 +24896 +19618 +26560 +3546 +43 +26561 +26562 +10 +399 +26563 +16017 +14000 +26564 +43 +5451 +26565 +26566 +14369 +15718 +19 +272 +2260 +26567 +15 +1605 +26568 +286 +286 +26569 +26570 +590 +349 +26571 +19 +26572 +19 +533 +8297 +4463 +20442 +19 +333 +26573 +26574 +5780 +1559 +21947 +26575 +12005 +8668 +19 +26576 +3353 +536 +26577 +16653 +26578 +11428 +286 +26579 +14 +70 +590 +16826 +21947 +586 +43 +26580 +24896 +3417 +15 +26581 +26582 +26583 +20643 +23530 +2324 +57 +8127 +17635 +17151 +1154 +2012 +26584 +25584 +9 +17345 +22666 +4388 +20470 +26585 +286 +15683 +26586 +14369 +14604 +26587 +1529 +1542 +3030 +26588 +26589 +213 +26590 +1090 +25140 +26591 +3452 +14 +26592 +26593 +21947 +26594 +26595 +26596 +26597 +303 +26598 +26599 +379 +21947 +11215 +26600 +14 +26601 +7208 +19618 +25140 +209 +25735 +26602 +26603 +26604 +26476 +26605 +26339 +3908 +17294 +14369 +26606 +15 +23103 +248 +2561 +284 +26607 +1578 +26608 +349 +284 +26609 +4028 +9900 +26610 +26611 +19 +3446 +4899 +358 +3976 +303 +14 +22573 +26612 +213 +15584 +26613 +5654 +26614 +26615 +23885 +17653 +26616 +337 +284 +8668 +11995 +15 +26617 +10 +26618 +26619 +26620 +26621 +1356 +19 +14369 +9384 +26622 +248 +4367 +8743 +15718 +26623 +10 +16727 +26624 +26625 +24864 +26626 +2342 +26627 +272 +1513 +26628 +15 +26629 +586 +19918 +20 +7855 +26630 +590 +26631 +57 +19220 +3546 +26632 +337 +26633 +7364 +7256 +66 +26634 +20563 +18325 +25584 +337 +176 +21947 +26635 +26636 +26637 +1774 +5780 +17691 +9 +26638 +24896 +21947 +26639 +43 +43 +7458 +1011 +26640 +15193 +26641 +17405 +16684 +337 +15939 +13566 +272 +590 +303 +8100 +19 +19618 +13213 +15907 +43 +26642 +491 +26643 +554 +284 +9 +26644 +19 +2770 +13349 +13343 +554 +671 +26645 +43 +26646 +9 +20 +2006 +43 +26647 +24864 +26648 +26649 +26650 +20866 +14 +915 +19 +25904 +26651 +26652 +26653 +2804 +24207 +20315 +26654 +26655 +26656 +24238 +26657 +9 +66 +26658 +19 +337 +26659 +26660 +26661 +736 +26662 +26663 +201 +26664 +349 +345 +26665 +26666 +8668 +26667 +26668 +286 +25009 +5904 +26669 +26670 +26671 +43 +1382 +12438 +22103 +26672 +2117 +26673 +274 +720 +349 +14 +8798 +26674 +2040 +25683 +18386 +26675 +26676 +26677 +142 +26678 +5780 +7048 +827 +26679 +2410 +14604 +13566 +14020 +14 +26680 +357 +26681 +26682 +26683 +26493 +115 +26684 +272 +3287 +590 +26685 +3601 +21947 +26686 +3559 +17151 +26687 +8256 +24449 +26688 +26689 +22633 +20328 +14369 +21947 +590 +26690 +23464 +1425 +286 +26691 +26692 +26493 +21947 +14 +17871 +26693 +2415 +337 +842 +3480 +26694 +4278 +1696 +20 +26695 +15820 +2496 +20 +213 +26696 +1013 +26697 +26698 +18718 +26699 +21689 +705 +4367 +9245 +26700 +24303 +19 +19618 +53 +248 +26701 +26702 +16826 +26703 +43 +5085 +736 +26704 +26705 +26706 +26707 +14770 +26708 +26709 +26710 +29 +178 +19 +590 +26711 +17151 +5393 +13721 +1991 +26712 +26713 +26714 +590 +80 +26715 +21947 +8953 +24 +8566 +825 +14369 +26716 +701 +26717 +8668 +274 +14 +14 +14 +26718 +13296 +284 +1082 +19404 +26719 +26720 +736 +15107 +26721 +26722 +3546 +3546 +358 +26723 +18824 +9210 +26724 +13721 +8668 +112 +647 +17320 +25129 +23579 +9 +1482 +3034 +26725 +26726 +823 +26631 +286 +1612 +32 +13411 +23226 +16387 +29 +3546 +9497 +26727 +345 +26728 +17698 +26729 +43 +26730 +4634 +736 +114 +26731 +26732 +3484 +14 +1224 +24303 +14 +1745 +12987 +14001 +26733 +17151 +26734 +26735 +3435 +915 +26736 +15560 +1090 +140 +411 +736 +12832 +1882 +26493 +272 +12 +196 +1961 +26737 +590 +15718 +16440 +5085 +26738 +20 +284 +736 +43 +26739 +26740 +1529 +19 +1787 +43 +16826 +20442 +26741 +26742 +43 +26743 +26744 +3546 +26745 +26746 +13721 +2957 +18695 +26239 +43 +24725 +26747 +3546 +14369 +10616 +26748 +26749 +26493 +19 +57 +26750 +26751 +67 +9 +15 +337 +14369 +3546 +43 +26752 +26753 +26754 +9 +26755 +14 +12987 +19489 +15 +26756 +26757 +19 +16944 +2 +11308 +4551 +3119 +2764 +11321 +137 +9 +4805 +736 +26758 +140 +25140 +2577 +3 +301 +26759 +717 +26760 +26761 +26762 +17749 +26763 +19 +823 +25683 +26764 +554 +369 +26765 +43 +5085 +26766 +19852 +2 +19 +3546 +24174 +26767 +828 +849 +1090 +26403 +7835 +26768 +590 +3546 +1812 +26769 +26770 +26771 +213 +43 +1090 +14186 +26772 +17151 +16024 +26493 +26773 +26774 +1051 +554 +11321 +26775 +13435 +26776 +1172 +590 +9 +26777 +38 +286 +16102 +26778 +26779 +1605 +15683 +665 +16028 +26780 +590 +3546 +137 +248 +21947 +19 +284 +284 +3252 +14477 +26781 +26782 +7009 +1562 +4221 +26783 +14515 +15718 +26784 +3251 +665 +3119 +19817 +15718 +2998 +3394 +564 +303 +10389 +248 +26785 +26786 +26787 +9 +3546 +590 +484 +26788 +248 +159 +26789 +26790 +24505 +20442 +8392 +26791 +26792 +155 +286 +32 +349 +24541 +25140 +188 +1513 +24908 +60 +26793 +26794 +8210 +751 +26795 +26796 +213 +303 +590 +1160 +284 +26797 +26798 +25778 +1768 +26676 +26799 +23207 +9 +26800 +4179 +32 +4735 +26801 +4550 +16437 +9343 +26802 +26803 +26804 +16118 +284 +5438 +26805 +26806 +26807 +14477 +248 +26808 +24896 +26809 +14603 +4684 +26810 +14369 +26811 +19404 +26812 +10654 +24303 +15657 +43 +1018 +26813 +286 +23226 +24864 +14363 +26814 +26815 +26816 +26817 +21947 +26818 +11762 +26819 +21689 +26820 +26821 +26822 +26403 +14871 +26823 +20339 +43 +25237 +26676 +202 +26824 +213 +26825 +736 +26826 +26827 +26828 +26829 +8330 +26830 +795 +26831 +19404 +26549 +3544 +2733 +1561 +18081 +14 +2281 +11822 +20470 +26832 +3353 +3546 +303 +2577 +24998 +57 +26833 +12 +24144 +720 +2 +26834 +12480 +14369 +2577 +3994 +213 +16024 +248 +26835 +26836 +58 +18860 +26837 +736 +16788 +26838 +26839 +6991 +26840 +26841 +26842 +26843 +26844 +4581 +26845 +1812 +25140 +1100 +26846 +14909 +26847 +19 +647 +2 +4463 +349 +46 +536 +26848 +484 +26849 +32 +26545 +26850 +4406 +26851 +26852 +26853 +14369 +6939 +26854 +43 +11762 +26855 +26856 +26857 +26858 +26859 +24423 +25683 +16240 +26792 +663 +3753 +26860 +26861 +8392 +4550 +26862 +14660 +8188 +14363 +1090 +26863 +345 +7585 +14363 +26864 +26865 +26866 +43 +26867 +5780 +26868 +20 +213 +26869 +26870 +11471 +14369 +590 +14 +26871 +21689 +26872 +284 +14369 +19618 +1543 +26873 +1829 +26874 +18382 +43 +2318 +24324 +9 +25683 +26496 +3546 +19655 +26875 +647 +26876 +2832 +19969 +21947 +20617 +9 +21947 +25237 +345 +26877 +26878 +2040 +26879 +24207 +11548 +2463 +1961 +323 +26880 +337 +337 +1244 +20646 +213 +1790 +248 +5022 +10 +26881 +270 +14369 +5314 +213 +1038 +2902 +26882 +26883 +8460 +26884 +6840 +736 +1696 +26885 +26886 +26887 +26888 +3484 +26889 +21149 +14 +26890 +43 +15 +137 +26891 +26892 +21947 +26893 +21947 +1384 +9 +26894 +26029 +26895 +26896 +2561 +11808 +43 +3546 +20340 +20897 +345 +213 +4028 +26897 +26898 +6364 +7516 +22684 +26899 +17151 +26900 +248 +9 +26901 +284 +303 +10702 +57 +213 +26902 +12152 +43 +23196 +3994 +720 +26903 +18503 +26904 +3 +26905 +590 +26906 +590 +8465 +43 +3546 +26907 +4441 +26908 +26909 +26910 +32 +25237 +3764 +25281 +26911 +13721 +1817 +3 +26184 +26912 +14369 +720 +15718 +26913 +379 +11754 +411 +20470 +15 +19618 +26914 +6915 +17670 +26915 +26916 +26917 +26918 +26919 +26920 +26921 +1021 +13150 +3790 +26922 +514 +26923 +14 +3546 +14649 +14 +26924 +26925 +26926 +26403 +573 +13721 +26927 +12180 +26928 +14 +1787 +26929 +9 +43 +248 +3417 +26724 +9 +519 +4241 +3828 +26930 +26931 +1513 +26932 +26933 +19 +13974 +4502 +213 +1369 +26934 +26935 +26936 +26937 +1091 +48 +16413 +7045 +2009 +5704 +694 +590 +26938 +26939 +19618 +15 +26940 +4650 +23425 +26941 +11889 +57 +11762 +26942 +5629 +22 +26943 +26944 +188 +26945 +57 +26946 +411 +19 +14369 +872 +14604 +26947 +26948 +26949 +1021 +20600 +17749 +26950 +491 +11428 +590 +26951 +26952 +26953 +12987 +286 +26954 +26955 +17972 +3601 +5561 +590 +17490 +1961 +138 +26956 +2733 +590 +26957 +26958 +26959 +764 +26960 +286 +57 +442 +26961 +26962 +43 +26963 +4209 +26964 +24864 +16437 +14 +415 +26965 +501 +26966 +11762 +9524 +26967 +26968 +26969 +26970 +19618 +188 +46 +345 +3546 +9 +20339 +26971 +2619 +26972 +17338 +12468 +3546 +26973 +21681 +43 +1011 +1082 +590 +26974 +26975 +590 +24864 +936 +1870 +519 +2514 +26976 +645 +590 +286 +43 +5780 +3187 +26977 +26978 +26979 +26980 +32 +14079 +26981 +5627 +872 +26982 +10 +16389 +26983 +26984 +26985 +568 +14604 +647 +43 +5780 +1817 +22 +24207 +12684 +20871 +2540 +26986 +284 +185 +26987 +26988 +6286 +16437 +2459 +2514 +26989 +590 +26990 +284 +14369 +4803 +15939 +3546 +9 +26991 +182 +736 +3546 +19618 +26992 +26403 +19 +345 +26993 +26994 +15728 +342 +213 +26995 +345 +446 +345 +14369 +5773 +15718 +19573 +26996 +26997 +5271 +26998 +26999 +317 +43 +27000 +24640 +345 +27001 +286 +5188 +665 +1529 +27002 +790 +3546 +27003 +27004 +57 +57 +27005 +27006 +27007 +7944 +4217 +19 +13721 +66 +27008 +1502 +27009 +25584 +27010 +519 +18364 +27011 +24716 +27012 +349 +24896 +1907 +10 +27013 +27014 +27015 +24207 +178 +14369 +286 +3994 +99 +827 +18695 +25442 +27016 +1295 +19009 +18205 +3546 +2902 +3406 +3546 +9 +16607 +646 +379 +590 +209 +303 +21245 +3601 +27017 +8994 +155 +21439 +27018 +9796 +213 +2415 +27019 +464 +337 +2601 +14369 +326 +27020 +648 +27021 +590 +478 +1287 +21889 +27022 +77 +15045 +1749 +647 +910 +27023 +27024 +19618 +27025 +27026 +25683 +43 +13721 +646 +27027 +27028 +43 +25140 +21947 +349 +27029 +27030 +89 +15 +27031 +27032 +21522 +21947 +8668 +43 +21947 +66 +2537 +590 +303 +22963 +2019 +1743 +43 +27033 +27034 +27035 +1181 +27036 +19 +3994 +24873 +250 +89 +20770 +57 +5169 +27037 +265 +25237 +26484 +27038 +19 +27039 +27040 +27041 +1889 +27042 +27043 +27044 +27045 +25097 +25683 +27046 +104 +19 +27047 +19404 +27048 +13848 +10781 +23103 +14 +34 +27049 +27050 +178 +14 +8967 +720 +14369 +882 +27051 +14532 +2882 +32 +27052 +12916 +18833 +15797 +1415 +27053 +27054 +27055 +27056 +27057 +1066 +27058 +27059 +8188 +17151 +27060 +27061 +27062 +27063 +2329 +25584 +27064 +27065 +27066 +24896 +27067 +5561 +5780 +1160 +25683 +2577 +2287 +4979 +3421 +3546 +27068 +27069 +27070 +24303 +27071 +590 +1157 +27072 +865 +27073 +3317 +10 +19 +27074 +14477 +3484 +27075 +27076 +27077 +2 +27078 +27079 +27080 +15050 +317 +27081 +27082 +15718 +2029 +27083 +25144 +27084 +694 +10727 +590 +4502 +14276 +249 +14369 +412 +209 +27085 +27086 +27087 +27088 +14 +27089 +5041 +27090 +1542 +27091 +7379 +249 +7981 +27092 +5780 +27093 +20470 +27094 +1961 +27095 +92 +22 +317 +27096 +19 +27097 +6095 +411 +27098 +2668 +27099 +20 +27100 +27101 +10028 +1817 +4982 +1870 +3862 +790 +11282 +27102 +27103 +3601 +15320 +27104 +26706 +89 +12987 +27105 +137 +19 +19618 +27106 +27107 +27108 +1955 +27109 +14 +26975 +10038 +14 +14645 +16121 +27110 +27111 +1870 +411 +19404 +13721 +4020 +3546 +27112 +27113 +17 +27114 +14 +27115 +27116 +2733 +3978 +15718 +23550 +26744 +24896 +24303 +20161 +43 +25584 +2043 +27117 +27118 +9 +24896 +14 +27119 +6499 +27120 +822 +24725 +21041 +27121 +590 +1765 +417 +27122 +27123 +27124 +27125 +27126 +1139 +27127 +27128 +27129 +17119 +425 +14 +27130 +8004 +27131 +14 +104 +6122 +5908 +27132 +11762 +11341 +201 +3546 +27133 +27134 +27135 +1219 +8762 +27136 +25140 +27137 +9 +27138 +4126 +4765 +936 +27139 +21947 +22420 +10604 +3034 +3067 +6188 +27140 +11321 +7053 +3 +27141 +4028 +32 +27142 +27143 +27144 +27145 +27146 +21187 +27147 +18896 +2560 +179 +13721 +745 +14369 +21027 +3034 +27148 +9796 +14 +345 +27149 +27150 +3546 +27151 +1524 +24038 +303 +142 +15718 +27152 +7053 +14369 +446 +8098 +1523 +66 +27153 +27154 +27155 +27156 +27157 +27158 +24 +27159 +15 +27160 +2140 +19618 +19618 +8019 +4388 +27161 +705 +43 +23103 +15728 +52 +14369 +21689 +9 +27162 +989 +20541 +22666 +27163 +27164 +27165 +1924 +27166 +23881 +43 +27167 +2015 +27168 +22555 +2260 +1559 +1169 +21947 +14 +349 +27169 +27170 +590 +3 +20315 +19994 +284 +245 +27171 +23418 +299 +24896 +27172 +491 +104 +27173 +27174 +13721 +590 +3553 +7053 +27175 +27176 +27177 +15556 +665 +38 +9 +8392 +27178 +13721 +554 +27179 +25683 +1812 +27180 +3546 +18364 +27181 +11211 +43 +27182 +27183 +345 +11321 +27184 +7991 +17206 +27185 +1604 +16024 +1502 +43 +21031 +6812 +27186 +9 +27187 +18503 +21947 +3546 +27188 +27189 +9 +27190 +365 +11283 +21947 +27191 +4414 +27192 +27193 +24340 +27194 +27195 +9460 +18695 +2449 +27196 +196 +27197 +27198 +21947 +4550 +27199 +24050 +27200 +15589 +17151 +25683 +9 +712 +27201 +43 +23770 +1605 +27202 +21947 +27203 +26403 +27204 +8280 +43 +10848 +27205 +21947 +27206 +1765 +21947 +1470 +14 +27207 +27208 +27209 +21689 +25584 +24864 +20161 +23890 +27210 +694 +27211 +21947 +27212 +27213 +24864 +3732 +2769 +14 +19655 +25140 +27214 +27215 +27216 +1384 +57 +43 +14 +14477 +164 +27217 +5780 +27218 +27219 +13841 +11822 +1021 +27220 +11792 +27221 +764 +26922 +5780 +3239 +12203 +399 +1013 +27222 +446 +1615 +692 +9 +26493 +27223 +27224 +1513 +27225 +5577 +2489 +15 +2260 +27088 +1310 +19618 +27226 +9617 +27227 +2459 +27228 +3601 +15 +1465 +27229 +616 +2791 +2919 +15 +26744 +7288 +22 +1047 +27230 +2882 +27231 +3546 +27232 +20 +27233 +8721 +27234 +20764 +27235 +27236 +7717 +14477 +286 +27237 +286 +35 +24045 +430 +18503 +14 +43 +17136 +17972 +27238 +27239 +27240 +25636 +590 +9194 +590 +1013 +25239 +27241 +14 +2694 +9 +27242 +590 +27243 +27244 +14079 +27245 +377 +11802 +24864 +5297 +26493 +14477 +1320 +27246 +27247 +491 +222 +286 +677 +12 +590 +541 +1291 +2308 +18539 +720 +286 +4075 +4550 +142 +14795 +2287 +345 +14 +22666 +225 +22 +27248 +27249 +9688 +27250 +237 +27251 +27252 +323 +21947 +27253 +25237 +27254 +17151 +21563 +201 +323 +137 +495 +27255 +27256 +5559 +60 +27257 +14369 +19 +910 +27258 +27259 +14369 +3394 +24896 +25237 +43 +15 +5438 +27260 +27261 +27262 +2919 +201 +13721 +770 +14369 +20470 +27263 +27264 +27265 +1222 +15718 +19618 +2941 +27266 +14363 +24303 +66 +27267 +14 +2260 +1107 +27268 +3790 +21947 +25683 +27269 +15718 +27270 +2790 +8566 +14562 +8724 +27271 +1716 +14240 +27272 +720 +16437 +8297 +89 +15824 +21947 +19 +286 +27150 +286 +24303 +27273 +22986 +176 +495 +9688 +27274 +14369 +2577 +27275 +303 +27276 +22 +1090 +1444 +27277 +16206 +27278 +1514 +27279 +13680 +43 +8280 +272 +27280 +201 +915 +10111 +27281 +27282 +201 +27283 +19 +26493 +27284 +25237 +27285 +616 +11 +27286 +14 +19 +14000 +24303 +27287 +27288 +27178 +27289 +43 +27290 +12807 +464 +16305 +27291 +27292 +19797 +19618 +14369 +590 +27293 +27294 +12772 +27295 +27296 +14 +27297 +32 +17872 +6354 +18695 +990 +43 +19 +19852 +25996 +14 +21689 +27298 +27299 +8226 +21947 +27300 +3546 +10621 +590 +14175 +3978 +43 +17663 +27301 +32 +27302 +25683 +228 +23727 +3546 +26493 +27303 +24725 +4550 +27304 +27305 +43 +301 +27306 +4550 +590 +14989 +20 +1021 +736 +43 +1295 +27307 +27308 +9688 +373 +25584 +23406 +27309 +25237 +27310 +3310 +2356 +27311 +14369 +4547 +27312 +27313 +5085 +2412 +43 +24725 +15718 +13721 +1316 +27314 +1710 +222 +7991 +15 +1356 +27315 +345 +13721 +8297 +21669 +21371 +27316 +27317 +27318 +27319 +424 +25140 +27320 +3480 +5075 +648 +533 +1730 +26496 +27321 +43 +27322 +1157 +692 +27323 +27324 +27325 +27326 +11483 +18429 +27327 +92 +27328 +27329 +25683 +17151 +27330 +26647 +27331 +307 +27332 +197 +971 +14131 +27333 +616 +27334 +27335 +2694 +14369 +27336 +27337 +27338 +27339 +27340 +27341 +8098 +24303 +27342 +317 +27343 +2074 +10787 +14 +89 +27344 +19 +586 +25 +27345 +17151 +345 +27346 +15 +26744 +23741 +2124 +57 +849 +10 +27347 +13127 +27348 +6132 +24303 +1382 +251 +21947 +862 +8351 +27349 +27350 +27351 +27352 +1688 +23216 +21947 +18895 +27353 +10 +1965 +13178 +43 +21947 +27354 +27355 +27356 +14477 +27357 +27358 +1352 +27359 +27360 +369 +27361 +7855 +43 +14604 +19618 +27362 +683 +25683 +533 +272 +27363 +25683 +27364 +14369 +27365 +1779 +3828 +27366 +27367 +27368 +27369 +27370 +24303 +3 +89 +27371 +736 +27372 +14369 +27373 +3546 +27374 +14477 +27178 +25237 +17151 +27375 +98 +5085 +323 +27376 +2356 +16818 +668 +27377 +11762 +7053 +5798 +10156 +14 +286 +27378 +27120 +17 +9994 +19386 +495 +6439 +6468 +27379 +24303 +27380 +27381 +1160 +27382 +5085 +519 +1169 +27383 +27384 +7795 +1517 +27385 +5085 +27386 +16437 +27387 +43 +27388 +18914 +4055 +27389 +14363 +12426 +27390 +14 +27391 +27392 +14369 +27393 +1615 +12346 +12307 +24303 +32 +12916 +14369 +21947 +27394 +27395 +15718 +18928 +27396 +7053 +27397 +27398 +43 +2694 +27399 +24725 +19618 +27400 +14 +21337 +14 +27401 +1364 +27402 +57 +27403 +25871 +3752 +10356 +27404 +27405 +27406 +27407 +27408 +22 +442 +26744 +25683 +8188 +26493 +25683 +27409 +27410 +272 +27411 +3546 +27412 +736 +27413 +27414 +590 +27415 +27416 +27417 +1047 +21689 +27418 +13905 +1674 +20 +2121 +27419 +20 +27420 +27263 +43 +25237 +27421 +27422 +3732 +27423 +24896 +14369 +27424 +27425 +349 +25382 +21689 +19618 +1046 +21947 +27426 +15718 +27427 +7835 +25237 +23103 +590 +27428 +21947 +27429 +4518 +12005 +24303 +21947 +27430 +20616 +25140 +27431 +43 +27432 +155 +27433 +27434 +27435 +9837 +8073 +13721 +1012 +27436 +590 +27437 +25237 +27438 +27439 +14 +27440 +21947 +36 +23103 +15308 +27441 +19618 +27442 +27443 +14603 +38 +27444 +27445 +590 +7053 +27446 +27447 +19838 +27448 +27449 +27450 +14369 +412 +5780 +43 +27451 +6130 +27452 +27453 +27454 +15718 +9 +23103 +43 +19404 +14477 +27455 +7053 +44 +27456 +18357 +27457 +5390 +27458 +27459 +13307 +14477 +43 +27460 +27461 +2325 +27462 +27463 +27464 +27465 +19 +27466 +721 +27467 +27468 +4426 +14000 +12351 +27469 +3826 +18988 +14 +1316 +25140 +286 +27470 +14604 +26496 +27471 +13285 +17608 +4896 +27472 +7836 +9 +1529 +27473 +13713 +43 +6950 +27474 +23406 +14 +19450 +27475 +17338 +2865 +27476 +27477 +21947 +23559 +27478 +27479 +27480 +1047 +15824 +24034 +22986 +43 +15971 +14369 +27481 +27482 +2040 +27483 +27484 +7253 +27485 +11822 +27486 +27487 +29 +26157 +19 +27488 +27489 +27490 +19 +15338 +27491 +1991 +8188 +27492 +27493 +27494 +24725 +27495 +27496 +27497 +17136 +9 +27498 +27499 +13905 +26680 +27500 +1493 +27501 +27502 +872 +6110 +14659 +13721 +27503 +286 +43 +27206 +27504 +77 +21947 +14369 +27505 +27506 +27507 +349 +27508 +554 +192 +21045 +20 +1168 +27509 +2 +27510 +2700 +8244 +140 +14477 +27511 +27512 +4516 +590 +27513 +7053 +27514 +21947 +25382 +21030 +27515 +3484 +3310 +98 +2 +43 +24303 +27516 +1013 +519 +14 +1021 +27517 +4388 +2040 +43 +665 +3546 +19618 +16437 +1385 +14 +27518 +1966 +27519 +27520 +201 +24864 +6518 +27521 +16687 +26030 +14 +27522 +14 +590 +12359 +590 +14 +27523 +27524 +13390 +27525 +379 +12055 +27526 +13111 +27527 +25871 +11928 +27528 +3978 +27529 +2694 +178 +21576 +668 +43 +27530 +2998 +15 +27531 +22684 +5085 +345 +24896 +1870 +43 +27532 +27533 +21947 +272 +27534 +27535 +22420 +1011 +13411 +9 +19618 +27536 +699 +27287 +19618 +24303 +5614 +10 +27537 +27538 +27539 +293 +27420 +14947 +80 +2694 +12307 +27540 +25237 +27541 +27542 +274 +12987 +27543 +14477 +5904 +14369 +27544 +27545 +27546 +14369 +22963 +27547 +1051 +26683 +27548 +43 +3546 +1021 +566 +24864 +11404 +707 +19582 +9 +43 +22442 +874 +428 +27287 +3543 +590 +27549 +27550 +104 +339 +590 +27551 +24733 +43 +349 +24896 +736 +27552 +519 +27553 +13307 +27554 +27555 +5085 +57 +27556 +25237 +27557 +2581 +8249 +27558 +13278 +8218 +27559 +43 +650 +6950 +27560 +19 +27561 +6395 +9 +27562 +27563 +590 +3330 +27564 +23727 +27565 +2027 +17749 +25584 +1172 +1012 +24036 +24303 +96 +8994 +13721 +27566 +13721 +25140 +32 +27567 +5297 +27568 +27569 +21947 +27570 +27571 +27572 +27573 +5725 +10003 +6225 +57 +286 +27574 +43 +18048 +21947 +2 +566 +26680 +5780 +590 +4900 +2694 +27575 +27576 +10748 +27577 +57 +25943 +349 +27578 +19618 +14693 +18250 +201 +412 +14909 +27579 +23504 +21669 +27580 +27581 +27582 +19050 +1090 +22 +11593 +27583 +25794 +23754 +46 +11944 +6874 +27584 +25237 +16925 +59 +13374 +1692 +21689 +20 +27585 +27586 +5085 +19217 +2338 +27587 +590 +14 +14369 +1605 +14000 +338 +1860 +14369 +7137 +15718 +398 +5908 +27588 +27589 +15824 +24725 +43 +345 +3105 +27590 +26493 +15 +27591 +286 +27592 +14 +20 +349 +9 +27593 +1559 +984 +345 +27594 +27595 +249 +19618 +411 +1864 +13721 +27596 +270 +27597 +6950 +29 +25382 +89 +26808 +27598 +27599 +24303 +6505 +440 +27600 +24864 +26065 +19 +141 +27601 +14369 +27602 +10706 +27603 +15718 +32 +19618 +25140 +22461 +43 +27604 +15268 +590 +27605 +27606 +18874 +19792 +14079 +590 +21698 +1481 +15 +3768 +179 +3470 +736 +3601 +27607 +237 +27608 +27609 +8367 +25683 +736 +13807 +27610 +14 +1912 +27611 +9 +1300 +2841 +188 +6360 +27612 +8188 +43 +27613 +27614 +27615 +27616 +11593 +27617 +4387 +27618 +27619 +27620 +27621 +20897 +27622 +48 +43 +22963 +43 +26496 +27623 +27624 +228 +27625 +27626 +15718 +7053 +25659 +478 +3 +19 +19 +5049 +10 +19 +683 +1051 +21947 +27495 +27627 +22391 +27628 +10 +18982 +15824 +317 +27629 +27630 +27631 +27632 +1066 +22 +22492 +27633 +27634 +27635 +27636 +27637 +12987 +2694 +43 +9 +27287 +1157 +23530 +284 +6950 +11995 +22963 +27638 +354 +25710 +19618 +24896 +736 +27639 +11321 +27640 +616 +27641 +736 +590 +4521 +4169 +27642 +349 +24896 +27643 +936 +27599 +19618 +14363 +19655 +12778 +201 +14 +1465 +27644 +6595 +3978 +27645 +13721 +7799 +27646 +26724 +32 +646 +27647 +27648 +27649 +27650 +27651 +12987 +25683 +12987 +43 +3003 +628 +416 +9 +27652 +2721 +736 +19 +2939 +14001 +27653 +27654 +590 +14 +20280 +27655 +27656 +57 +14477 +12987 +27657 +1100 +27658 +27659 +694 +568 +15718 +27660 +7152 +213 +27661 +176 +27662 +3003 +23103 +770 +27663 +19618 +27664 +27665 +13703 +27666 +24864 +27667 +27668 +6335 +27669 +2561 +2537 +23834 +15298 +155 +27670 +17 +1332 +25871 +27671 +27672 +14 +43 +25683 +27673 +6285 +43 +736 +43 +24920 +27674 +27675 +32 +27676 +14477 +27677 +10415 +43 +27678 +12588 +27679 +14477 +14878 +9784 +590 +2 +490 +27680 +10961 +14369 +60 +6086 +57 +27681 +2164 +6557 +27682 +76 +43 +27683 +27684 +6171 +590 +27685 +27686 +6765 +8188 +24864 +27687 +21947 +27688 +24303 +27689 +14369 +27690 +14130 +13843 +27691 +27692 +1100 +1153 +3546 +137 +27693 +20 +27694 +358 +27695 +1577 +5080 +624 +15718 +6505 +27696 +188 +27697 +736 +24862 +915 +19618 +590 +21896 +10591 +3546 +27698 +665 +27699 +27700 +27701 +27702 +14 +12987 +6054 +745 +4550 +43 +18946 +817 +34 +27703 +286 +27704 +3546 +19 +27705 +27706 +27707 +15853 +14 +27708 +15718 +2 +89 +27709 +9 +8297 +14102 +9 +27710 +19 +27711 +16290 +27712 +27072 +27713 +736 +18577 +27714 +686 +5477 +27715 +5119 +27716 +25237 +26744 +27717 +345 +317 +5204 +27718 +2197 +6214 +27287 +17151 +1559 +27719 +25140 +25280 +2944 +1688 +15662 +43 +269 +15718 +27720 +26389 +27721 +27722 +5088 +5764 +740 +27723 +282 +24864 +20 +14477 +25237 +16437 +3 +613 +725 +24753 +27724 +27725 +10 +27726 +27727 +27728 +554 +27729 +21947 +1234 +27730 +27731 +27732 +3546 +27733 +4086 +27734 +27735 +27069 +665 +27736 +20 +5438 +43 +27737 +27738 +464 +179 +27739 +27740 +1976 +27741 +225 +20655 +10218 +12987 +23506 +2 +15308 +1012 +15928 +27742 +27743 +27744 +10642 +27745 +317 +4598 +437 +27746 +590 +3053 +27747 +720 +14 +17872 +27748 +27749 +27750 +1885 +14 +22 +43 +14363 +27751 +27752 +18982 +14 +14521 +8668 +25683 +21947 +20329 +3 +13557 +27753 +27754 +14477 +196 +27755 +32 +21776 +27756 +27757 +24303 +533 +11647 +27758 +6263 +25683 +27759 +26361 +648 +27760 +3994 +27761 +15647 +352 +14000 +15718 +18334 +17670 +23741 +27762 +27763 +590 +18742 +24303 +25200 +2197 +590 +12600 +19618 +27764 +9 +14 +27765 +231 +19 +27766 +370 +19 +3119 +8249 +18795 +9 +27767 +286 +6275 +1529 +27768 +27769 +27770 +27771 +4463 +27772 +27773 +27774 +1860 +27775 +2043 +2577 +138 +24327 +27776 +27777 +27778 +1160 +9 +9402 +24864 +27779 +597 +20572 +19405 +15718 +99 +27780 +27781 +14369 +43 +14 +27782 +1563 +9 +972 +19655 +27783 +27784 +590 +27785 +22797 +27786 +27787 +25237 +14 +720 +27788 +14000 +27789 +27790 +43 +17048 +15406 +1021 +14604 +15797 +2072 +2301 +27791 +5383 +27792 +3638 +22895 +15824 +27793 +27794 +272 +15 +8160 +14369 +27260 +12214 +21947 +6877 +590 +27795 +11479 +354 +27796 +27797 +27798 +554 +10 +14 +27799 +57 +15989 +27800 +14175 +14369 +14369 +705 +209 +17635 +14604 +15718 +27801 +27802 +209 +27803 +25140 +26496 +1517 +27804 +27805 +15 +9 +27806 +36 +22552 +598 +8351 +26066 +8392 +547 +19 +77 +27807 +27808 +249 +27809 +832 +286 +27810 +4144 +9979 +25140 +27811 +2058 +27812 +176 +27813 +27814 +27815 +27816 +27817 +14804 +19 +4684 +27818 +4028 +3317 +27819 +1523 +286 +27820 +27821 +2260 +27822 +25683 +27823 +464 +3192 +13361 +17135 +22 +16014 +27824 +27825 +27548 +19 +27826 +7137 +27827 +573 +9 +301 +17151 +9 +1169 +27828 +1870 +27829 +2764 +16024 +2694 +27830 +165 +27831 +27832 +21947 +590 +25683 +26984 +43 +14477 +25140 +27833 +815 +27834 +590 +301 +822 +14369 +14369 +2260 +17136 +3546 +27835 +14369 +27836 +590 +27837 +14369 +24896 +8027 +27838 +1349 +27839 +213 +27840 +1444 +27841 +11 +5665 +27842 +14 +276 +43 +27843 +27844 +13411 +27845 +861 +27846 +345 +1406 +817 +2790 +910 +24303 +27847 +6341 +27848 +27849 +21947 +345 +590 +16763 +213 +303 +27850 +9 +27851 +13721 +27852 +185 +1458 +24303 +27853 +27854 +27855 +27856 +248 +21947 +26496 +284 +1604 +345 +1674 +213 +17151 +24896 +213 +286 +213 +27857 +25871 +7876 +27858 +27859 +5837 +137 +27860 +194 +27861 +27862 +24864 +297 +548 +27863 +14369 +27864 +27865 +19792 +3553 +27866 +27867 +26724 +683 +14363 +27868 +26744 +27869 +27870 +12479 +936 +14 +14 +27871 +9 +11394 +27872 +4550 +284 +27873 +27874 +27875 +683 +19618 +14604 +27876 +27877 +27878 +43 +9 +2769 +57 +27234 +18548 +2 +27879 +16 +27880 +27881 +27882 +17151 +3279 +27883 +27884 +27885 +14604 +554 +13905 +16645 +27886 +1021 +43 +43 +7855 +213 +213 +27887 +14369 +14 +14 +57 +15718 +317 +249 +27888 +27889 +27890 +43 +27891 +24303 +3546 +15 +6285 +936 +27892 +5085 +665 +27893 +27894 +248 +23231 +21187 +25683 +27895 +27896 +337 +337 +27897 +21947 +22 +18522 +27898 +27899 +1765 +27900 +11841 +222 +27901 +17072 +14477 +23103 +12260 +27902 +16014 +21186 +213 +43 +27903 +19 +317 +5780 +1749 +27904 +20803 +3470 +590 +27905 +27906 +23842 +57 +213 +27907 +3994 +43 +27908 +18650 +337 +27909 +4388 +21689 +14473 +27910 +27911 +15356 +337 +248 +43 +1524 +284 +27912 +1551 +27913 +29 +24296 +720 +3546 +464 +14 +3081 +13307 +20161 +5872 +27914 +27915 +27916 +6518 +15989 +16437 +14 +349 +19618 +1116 +2 +1012 +27917 +24896 +27918 +22896 +764 +590 +43 +590 +3546 +659 +70 +442 +27919 +7610 +27920 +3067 +19618 +590 +9 +12814 +27921 +1382 +9692 +14102 +10017 +2476 +14241 +27922 +18695 +27923 +2832 +590 +272 +27924 +19 +2 +27925 +27926 +861 +20260 +736 +1352 +345 +19 +27927 +412 +14 +22 +43 +2550 +14 +27928 +27929 +4701 +27930 +9629 +19160 +13905 +26744 +17151 +13905 +7588 +27931 +222 +27932 +14 +16205 +27933 +22237 +11827 +9266 +27934 +19 +590 +27935 +25584 +5755 +845 +27936 +27937 +27938 +21776 +741 +5467 +22 +365 +12893 +27939 +27940 +590 +10642 +303 +27941 +27942 +27943 +63 +27944 +22901 +21947 +19484 +14369 +27945 +14363 +1655 +464 +165 +19 +4896 +27946 +27069 +25683 +27947 +16437 +17144 +11634 +27948 +14019 +21947 +24614 +25683 +573 +27719 +2406 +1912 +2567 +19 +27949 +27950 +27951 +27952 +27953 +337 +27954 +16413 +7855 +27955 +14 +4856 +27956 +15953 +1508 +27957 +248 +27958 +27959 +862 +24896 +29 +337 +27960 +652 +12621 +21947 +3546 +27961 +21186 +25237 +14369 +1082 +27962 +25159 +7137 +123 +26786 +27963 +1834 +19 +2260 +29 +1384 +27964 +3350 +21689 +27965 +14 +286 +248 +7600 +7117 +15027 +12987 +9 +799 +2865 +14477 +8297 +14 +14 +2877 +14000 +3978 +6850 +89 +24507 +27966 +613 +284 +27967 +27968 +19852 +27969 +57 +345 +370 +349 +17093 +25871 +27970 +15 +32 +21947 +27971 +27972 +16102 +2561 +27973 +15718 +232 +27974 +5188 +27975 +43 +27281 +1112 +27976 +590 +43 +27069 +27977 +5188 +14369 +43 +342 +590 +27978 +27979 +27980 +27981 +19091 +6441 +24862 +6708 +3711 +27982 +27983 +25868 +1382 +590 +16 +3553 +27984 +345 +14 +57 +2334 +21627 +548 +20300 +43 +24303 +27985 +27986 +27987 +519 +27988 +16156 +27989 +24896 +27990 +1249 +16048 +21947 +6628 +9037 +4055 +4550 +32 +5085 +2550 +27991 +27992 +27993 +5188 +345 +887 +27994 +27096 +2561 +2619 +1157 +10470 +16437 +27995 +9 +43 +27996 +27997 +337 +9 +27998 +9 +25584 +22 +1561 +4684 +446 +25140 +23103 +590 +27999 +4550 +342 +15718 +5085 +25683 +1100 +14 +28000 +28001 +1382 +26158 +28002 +9 +20442 +19428 +28003 +12308 +19 +28004 +28005 +19 +28006 +14 +14 +590 +2029 +3994 +19618 +14422 +1066 +213 +28007 +28008 +14369 +8593 +815 +9 +20 +2 +28009 +28010 +26361 +28011 +303 +25237 +20764 +10230 +28012 +21947 +10946 +8668 +372 +28013 +28014 +822 +43 +19618 +23578 +14 +26724 +4824 +15833 +28015 +11483 +14 +28016 +28017 +28018 +28019 +22308 +349 +720 +248 +24896 +22963 +15 +248 +28020 +28021 +28022 +17151 +915 +28023 +9 +1502 +18054 +14369 +568 +284 +28024 +15718 +28025 +14369 +1517 +284 +28026 +28027 +28028 +25237 +14369 +28029 +24951 +647 +28030 +28031 +14 +28032 +284 +337 +28033 +19655 +28034 +345 +3546 +89 +28035 +301 +28036 +20700 +213 +3767 +28037 +3143 +22346 +11925 +28038 +14369 +19618 +14 +7797 +3546 +25140 +790 +14660 +1913 +2537 +6722 +284 +28039 +28040 +28041 +2197 +28042 +28043 +17872 +28044 +14 +19 +115 +28045 +43 +26169 +337 +337 +28046 +28047 +12055 +6885 +17119 +339 +9 +28048 +9 +28049 +337 +720 +23103 +15718 +7137 +28050 +17151 +349 +32 +345 +17668 +354 +248 +28051 +23406 +18045 +67 +24303 +28052 +9 +14 +337 +28053 +554 +26361 +4791 +2694 +23051 +12827 +590 +28054 +1543 +1364 +248 +590 +590 +3457 +19618 +28055 +1927 +39 +6018 +18435 +4387 +6877 +28056 +155 +1956 +9 +28057 +10 +28058 +15718 +303 +17801 +25749 +28059 +25140 +21947 +13905 +323 +43 +28060 +736 +26361 +10727 +28061 +27798 +19091 +28062 +43 +9 +17498 +3546 +11102 +1224 +28063 +28064 +28065 +720 +32 +17761 +28066 +42 +28067 +14 +1920 +28068 +28069 +14 +6533 +28070 +28071 +9 +28072 +21947 +21749 +20 +43 +7071 +23253 +3546 +28073 +3050 +21947 +1249 +15718 +671 +1356 +28074 +28075 +28076 +573 +9 +323 +28077 +28078 +12462 +11321 +2876 +25237 +24019 +590 +3428 +303 +28079 +28080 +590 +21776 +1508 +1655 +28081 +28082 +1655 +201 +14 +43 +17151 +2356 +19965 +21947 +14477 +248 +20 +77 +28083 +19797 +209 +25140 +2707 +28084 +28085 +28086 +745 +213 +28087 +28088 +28089 +32 +590 +14603 +1615 +14369 +1817 +286 +15793 +887 +28090 +28091 +28092 +3546 +14 +28093 +28094 +28095 +3484 +43 +28096 +6341 +4808 +27146 +765 +28097 +28098 +790 +21947 +764 +28099 +1352 +286 +352 +554 +25683 +28100 +28101 +5314 +25683 +19 +28102 +2410 +19 +7208 +352 +10607 +9 +28103 +272 +15718 +9 +14369 +28104 +28105 +137 +28106 +28107 +17151 +14369 +26496 +28108 +28109 +22308 +57 +9 +9 +28110 +4116 +27069 +28111 +28112 +28113 +14477 +915 +28114 +540 +28115 +28116 +213 +28117 +25 +942 +16012 +24896 +28118 +28119 +28120 +5188 +28121 +28122 +8668 +201 +1870 +28123 +25237 +1384 +17687 +28124 +28125 +18064 +28126 +28127 +28128 +28129 +28130 +28131 +14 +19 +14406 +7706 +28132 +7991 +89 +19618 +28133 +6571 +28134 +21458 +28135 +2042 +28136 +28137 +345 +28138 +590 +28139 +272 +28140 +32 +2260 +566 +28141 +25140 +15167 +19 +3546 +43 +28142 +3546 +17151 +43 +28143 +28144 +8208 +142 +28145 +28146 +17151 +1234 +5662 +21947 +2619 +14650 +28147 +28148 +28149 +28150 +28151 +28152 +19 +586 +286 +25584 +379 +58 +28153 +28154 +12005 +3546 +25 +4055 +28155 +1764 +28156 +17267 +25625 +19 +28157 +28158 +10179 +28159 +28160 +66 +14 +32 +28161 +20923 +28162 +28163 +3 +8188 +2762 +10 +2310 +14 +43 +19618 +317 +3994 +28164 +28165 +25943 +7053 +2430 +2841 +5188 +27178 +43 +1612 +21947 +2153 +28166 +1889 +140 +26040 +1991 +2316 +3484 +28167 +27719 +28168 +3546 +9234 +19 +21947 +1743 +25140 +28169 +9 +14660 +28170 +14 +28171 +23674 +5119 +18707 +13347 +28172 +2254 +24896 +568 +28173 +7071 +24698 +9012 +28174 +1514 +4055 +28175 +28176 +2728 +14577 +25172 +28177 +43 +13578 +1442 +4411 +8668 +28178 +1610 +25237 +28179 +18683 +16254 +24896 +28180 +28181 +28182 +28183 +18804 +2537 +590 +1745 +2463 +590 +15 +24303 +18693 +28184 +11217 +554 +24063 +28185 +28186 +43 +1401 +250 +2733 +19 +694 +2197 +43 +4452 +28187 +43 +1021 +28188 +24864 +14369 +13576 +12748 +14 +21833 +590 +4180 +28189 +301 +28190 +3546 +14 +9 +25584 +28191 +315 +573 +20383 +28192 +8188 +373 +28193 +28194 +20038 +14 +28195 +25140 +32 +3546 +28196 +13748 +28197 +3546 +15718 +43 +13721 +28198 +201 +28199 +27514 +43 +28200 +28201 +12768 +28202 +28203 +25683 +43 +28204 +23447 +28205 +5579 +3548 +11335 +4441 +28206 +827 +28207 +14369 +32 +8205 +720 +27069 +8566 +1870 +28208 +28209 +3484 +28210 +19 +28211 +89 +3323 +28212 +1689 +21947 +1765 +9 +28213 +28214 +25196 +19618 +24144 +1203 +3553 +28215 +28216 +13131 +28217 +179 +5297 +24862 +286 +43 +25237 +28218 +28219 +28220 +25943 +1615 +28221 +13721 +57 +17927 +6096 +3828 +18695 +10 +28222 +9123 +248 +28223 +3484 +21947 +28224 +914 +28225 +4897 +17451 +3790 +1345 +22 +14 +28226 +19 +590 +5085 +2058 +19 +22963 +1716 +12936 +28227 +9 +14 +28228 +28229 +6001 +28230 +28231 +11593 +43 +8160 +14175 +4594 +28232 +28233 +80 +25140 +286 +28234 +14369 +137 +205 +43 +19883 +43 +7048 +1131 +28235 +28236 +28237 +28238 +10 +28239 +28240 +213 +28241 +28242 +28243 +43 +286 +28244 +28245 +872 +2694 +4900 +417 +28246 +3353 +15 +28247 +24303 +28248 +25581 +286 +19206 +28249 +28250 +24896 +8297 +411 +19 +28251 +28252 +28253 +28254 +14808 +28255 +9095 +16205 +21689 +21947 +3546 +11535 +23103 +28256 +3546 +20367 +842 +28257 +16437 +28258 +13721 +19974 +28259 +19618 +4028 +28260 +28261 +28262 +315 +213 +446 +32 +21947 +28263 +19618 +554 +57 +32 +6459 +28264 +29 +1817 +28265 +28266 +25615 +28267 +28268 +28269 +28270 +28271 +28272 +3457 +28273 +1889 +3239 +13721 +1912 +67 +1961 +14369 +24303 +28274 +1765 +28275 +13721 +28276 +14 +14947 +28277 +57 +1190 +28278 +28279 +28280 +2061 +9 +28281 +28282 +28283 +15718 +9 +161 +4634 +22963 +28284 +26496 +28285 +26872 +20 +5282 +28286 +28287 +11971 +14369 +3978 +28288 +13375 +213 +26361 +16413 +28289 +21947 +19 +12987 +10745 +10094 +741 +28290 +349 +26744 +28291 +764 +9440 +25237 +28292 +337 +13569 +28293 +1021 +24303 +24207 +286 +3546 +28294 +28295 +29 +25140 +28296 +337 +28297 +5326 +3553 +28298 +24951 +345 +14604 +28299 +1900 +590 +14477 +28300 +28301 +28302 +28303 +28304 +28305 +829 +43 +28306 +12376 +25237 +14369 +284 +9 +1090 +5085 +446 +2 +28307 +28308 +5780 +26484 +14369 +15 +379 +28309 +28310 +9739 +28311 +554 +28312 +24015 +28313 +194 +14369 +284 +43 +28314 +24303 +1169 +32 +14363 +28315 +590 +6364 +590 +1090 +3601 +337 +28316 +28317 +28318 +28319 +7014 +21947 +345 +28320 +28321 +25382 +213 +16826 +590 +14363 +19705 +27146 +14369 +7492 +43 +9 +2570 +533 +274 +28322 +32 +345 +21947 +590 +21689 +28323 +248 +15718 +19618 +28324 +10510 +57 +28325 +16 +8994 +32 +27656 +14 +28326 +2064 +15654 +57 +442 +34 +22308 +2550 +28327 +286 +28328 +20773 +28329 +24303 +3655 +28330 +28331 +28332 +2331 +4918 +5780 +19 +43 +28333 +21947 +26001 +28334 +1502 +2865 +738 +28335 +28336 +3959 +22512 +23103 +28337 +28338 +28339 +28340 +6156 +14369 +28341 +6006 +2762 +28342 +28343 +28344 +43 +28345 +248 +25140 +28346 +5634 +323 +1172 +28347 +22 +22420 +13721 +24896 +28348 +24303 +28349 +28350 +24303 +43 +25683 +19 +8392 +1562 +4806 +736 +155 +16698 +9 +28351 +32 +1011 +590 +13323 +23418 +28352 +1234 +184 +3172 +1291 +8256 +2029 +20 +28353 +20108 +32 +18670 +23770 +21689 +114 +28354 +153 +303 +339 +26361 +28355 +8501 +21947 +1956 +303 +140 +28356 +28357 +179 +28358 +28359 +28360 +14477 +21947 +249 +292 +112 +6156 +960 +5438 +2314 +25481 +18951 +23951 +21947 +28361 +43 +15718 +28362 +19 +28363 +24896 +25140 +28364 +28365 +12864 +28366 +12722 +28367 +20340 +28368 +8297 +13721 +28369 +28370 +22815 +613 +28371 +12120 +28372 +28373 +13343 +28374 +13150 +10961 +28375 +28376 +13479 +28377 +28378 +14369 +28379 +272 +14369 +22 +349 +19 +25237 +1578 +7855 +28380 +43 +2040 +2 +28381 +736 +26962 +16 +28382 +28383 +28384 +28385 +28386 +2 +399 +28387 +28388 +28389 +213 +28390 +28391 +8594 +250 +2744 +70 +28392 +936 +25584 +2356 +28393 +15718 +18045 +829 +21947 +28394 +26912 +337 +468 +5271 +28395 +22075 +28396 +20265 +345 +28397 +446 +28398 +13721 +28399 +28400 +2960 +2764 +2260 +15473 +3814 +28401 +28402 +22587 +4682 +28403 +14369 +28404 +28405 +28406 +21947 +28407 +28408 +27087 +43 +43 +28409 +28410 +13721 +26496 +28411 +28412 +98 +28413 +379 +1385 +28414 +358 +751 +1559 +590 +14 +28415 +5188 +15718 +21947 +16121 +28416 +28417 +19 +28418 +72 +3546 +6741 +28419 +25683 +2 +792 +8668 +17730 +25683 +28420 +28421 +138 +25683 +1425 +28422 +28423 +28424 +28425 +28426 +28427 +1907 +14 +28428 +3075 +541 +28429 +2694 +28430 +7154 +28431 +683 +28432 +14 +14604 +2019 +201 +28433 +248 +21947 +28237 +28434 +554 +4403 +345 +590 +590 +28435 +19618 +28436 +8297 +11483 +27069 +14658 +28437 +5780 +14 +28438 +720 +43 +28439 +590 +28440 +354 +42 +13150 +28441 +25140 +18928 +4411 +20 +28442 +23103 +14369 +28443 +648 +16 +188 +14 +28444 +22030 +28445 +28446 +249 +4141 +2688 +586 +6877 +14 +28447 +237 +28448 +18982 +22236 +3316 +14 +28449 +14 +28450 +19 +349 +24303 +9490 +5648 +1605 +25584 +16338 +28451 +14369 +28452 +155 +27170 +28453 +28454 +1559 +28455 +28456 +103 +27748 +14330 +28457 +14330 +28458 +28459 +28460 +1481 +17151 +15824 +43 +12987 +23226 +28461 +28462 +713 +14 +28463 +28464 +28465 +164 +827 +28466 +21947 +28467 +3546 +3546 +28468 +13706 +27726 +1502 +509 +707 +14369 +18364 +8297 +28469 +5085 +28470 +28471 +28472 +4278 +5820 +80 +32 +165 +14 +28473 +28474 +16707 +14 +29 +10145 +28475 +28476 +4550 +27043 +28477 +57 +43 +28478 +28479 +28480 +14 +286 +28481 +14330 +28482 +3546 +19852 +474 +28483 +10505 +28484 +19927 +28485 +28486 +28487 +554 +20 +590 +21947 +28488 +28489 +349 +26744 +28490 +6907 +43 +28491 +28492 +28493 +509 +849 +28494 +28495 +3601 +28496 +5188 +28497 +548 +28498 +590 +28499 +28500 +28501 +20276 +27069 +915 +1157 +14369 +28502 +791 +28503 +14 +1021 +28504 +1578 +12067 +43 +19618 +345 +379 +27069 +28505 +14 +28506 +28507 +24303 +141 +3546 +373 +28508 +4002 +5649 +28509 +28510 +27146 +28511 +25237 +9 +28512 +17635 +736 +3297 +16126 +28513 +14369 +14369 +197 +8668 +28514 +60 +28515 +14330 +707 +11702 +484 +2197 +26119 +286 +13721 +28516 +28517 +9118 +1082 +2117 +28518 +28519 +14001 +14001 +28520 +14604 +20679 +28521 +19618 +21947 +28522 +141 +28523 +28524 +209 +28525 +21947 +15461 +28526 +20125 +43 +5659 +28527 +13721 +5773 +28528 +14 +22 +8351 +25943 +28529 +28530 +225 +28531 +1021 +28532 +43 +29 +14 +14369 +1765 +28533 +28534 +7543 +28535 +22121 +19655 +14 +28536 +3546 +482 +28537 +28538 +28317 +3546 +26666 +32 +1320 +23322 +28539 +21689 +12404 +28540 +38 +28541 +28542 +27719 +19 +10849 +21947 +16206 +19618 +28543 +13848 +28441 +2577 +15623 +28544 +25237 +2009 +1364 +4411 +28545 +28546 +282 +15 +10583 +331 +28547 +28548 +1502 +28549 +28550 +14477 +43 +1524 +28551 +28552 +26705 +28553 +495 +28554 +28555 +32 +590 +98 +28556 +28557 +18503 +590 +28558 +26786 +19 +18061 +28559 +2 +28560 +19 +28561 +28562 +57 +28563 +28564 +28565 +2540 +28566 +43 +28567 +248 +25683 +28568 +892 +1066 +1048 +28569 +7053 +25683 +533 +209 +1013 +28570 +1710 +16466 +14 +12344 +201 +8188 +28571 +43 +28572 +9060 +19 +77 +9 +345 +1524 +28573 +14 +20514 +4028 +28574 +8392 +19 +590 +3030 +28575 +21947 +11754 +10 +28576 +11514 +28577 +1765 +17151 +9 +536 +21947 +24896 +137 +96 +28578 +4285 +9 +242 +14 +5188 +1082 +60 +19965 +14 +28579 +18951 +8392 +28580 +28581 +28582 +14330 +28583 +28584 +27153 +28585 +1011 +28586 +28587 +28588 +5088 +5363 +1765 +6625 +5039 +3375 +28589 +28590 +28591 +28592 +104 +28593 +3546 +16437 +25584 +1234 +28594 +590 +16437 +28595 +28596 +3959 +28597 +5426 +17151 +1018 +27954 +28598 +19948 +28599 +28600 +1710 +590 +6518 +28601 +14369 +23438 +43 +10245 +5967 +5853 +28602 +21947 +28603 +138 +28604 +28605 +3598 +28606 +2338 +28607 +1947 +28608 +24207 +43 +28609 +5653 +12376 +9 +26452 +3872 +28610 +28611 +286 +57 +936 +24864 +989 +14369 +5204 +9705 +2314 +13150 +28612 +25943 +915 +28613 +10 +20175 +10 +43 +19618 +28614 +19 +28615 +28616 +43 +832 +28617 +345 +4144 +9 +28618 +590 +28428 +14 +28619 +28620 +28621 +57 +24896 +28622 +28623 +28624 +15718 +28625 +28626 +249 +2314 +167 +43 +14369 +2707 +28627 +28628 +28629 +15718 +1992 +15718 +14477 +28630 +19 +12902 +20 +446 +28631 +28632 +28633 +28634 +28635 +15476 +38 +590 +28636 +21698 +28637 +14369 +28638 +28639 +28640 +12479 +18683 +1234 +21031 +9 +92 +2314 +28641 +165 +43 +3422 +24303 +590 +28642 +736 +28643 +14369 +590 +14369 +28644 +201 +28645 +9095 +699 +28646 +397 +8566 +28647 +15446 +14214 +28648 +6364 +21947 +9 +28649 +17151 +21947 +28650 +28651 +28652 +28653 +28317 +9 +28654 +21947 +707 +2739 +18640 +57 +2117 +5204 +5188 +19713 +791 +48 +345 +2260 +28655 +3317 +2733 +25683 +2 +21947 +514 +8367 +24303 +169 +4518 +12936 +28656 +19618 +28657 +9922 +3353 +17264 +28658 +16866 +3546 +19 +11754 +1612 +28659 +28660 +1905 +5188 +114 +28661 +28662 +345 +398 +28663 +24725 +28664 +24896 +11966 +274 +28665 +28666 +28667 +21947 +28668 +9617 +28669 +1912 +28670 +2136 +19 +228 +28671 +19 +28672 +399 +238 +259 +10 +28673 +28674 +17151 +345 +28675 +25343 +590 +24227 +24864 +21268 +2029 +3179 +28676 +170 +43 +11192 +24864 +6122 +16178 +25683 +19624 +415 +5431 +28677 +26158 +28678 +28679 +2944 +28680 +28681 +28682 +13721 +27178 +5780 +28683 +28684 +28685 +13179 +28686 +28687 +25237 +28688 +25584 +1090 +5297 +23103 +28689 +28690 +19 +16375 +28691 +20 +19655 +28692 +590 +14477 +1021 +533 +24303 +201 +28693 +28694 +2314 +3546 +3546 +1961 +28695 +21698 +2446 +28696 +4230 +11185 +647 +21689 +7240 +14477 +586 +764 +28697 +28698 +18695 +28699 +14947 +140 +677 +28700 +14363 +446 +5976 +28317 +28701 +15261 +14 +345 +25237 +2577 +16102 +28702 +1765 +25140 +26506 +3546 +28703 +4088 +28704 +28705 +2135 +3543 +28706 +7753 +23343 +15914 +28707 +349 +28708 +155 +28709 +14477 +28710 +590 +24303 +24864 +28711 +13119 +19 +24896 +16205 +1234 +1425 +1051 +14330 +28712 +590 +21745 +28713 +17098 +28714 +3553 +28715 +28517 +24725 +5188 +10003 +28339 +249 +28549 +25140 +671 +28716 +28717 +28718 +28719 +16915 +28720 +28721 +19918 +3528 +13721 +509 +15186 +3546 +5820 +28722 +28723 +28724 +5085 +28725 +28726 +19 +6766 +28727 +1529 +286 +28728 +2764 +67 +24896 +14 +28729 +3317 +402 +560 +25683 +2316 +14 +3994 +28730 +14868 +1112 +349 +28731 +43 +28732 +28733 +43 +28734 +24725 +28735 +10963 +28736 +12987 +25237 +25921 +28737 +28738 +533 +28739 +19287 +1013 +9 +18982 +138 +15 +28740 +28741 +8465 +28742 +303 +28743 +16707 +5071 +647 +1927 +19 +25237 +4364 +14369 +21889 +15 +831 +43 +14369 +155 +28317 +21939 +10640 +13570 +16 +28744 +32 +28745 +20 +28746 +11552 +28747 +5438 +28748 +14 +3421 +28749 +28750 +19491 +28751 +26361 +28752 +1559 +10875 +5431 +11754 +17670 +28753 +28754 +10895 +21947 +19124 +25584 +9 +28755 +14 +590 +24725 +2 +12285 +28756 +1154 +27069 +349 +573 +43 +28757 +28758 +28759 +597 +28760 +357 +5691 +28761 +590 +20 +2733 +28762 +491 +77 +915 +491 +16826 +28763 +28764 +28765 +17466 +26496 +9 +43 +21947 +28766 +28767 +16883 +1443 +3601 +14369 +13150 +28768 +25 +552 +28769 +21947 +26496 +15718 +44 +14363 +28770 +1637 +28771 +25140 +28772 +28773 +24896 +5080 +28774 +590 +14369 +2330 +28549 +20 +19 +16067 +1425 +25683 +43 +28775 +28776 +28777 +533 +28778 +2668 +1047 +249 +2657 +28779 +10638 +28780 +14369 +9784 +1991 +80 +28781 +28782 +5803 +14816 +14846 +22986 +28783 +26744 +28784 +28785 +16437 +24303 +23603 +28786 +20694 +14965 +28787 +28788 +19 +22963 +28789 +18094 +28790 +28791 +1991 +19 +28792 +9497 +7379 +495 +24896 +28793 +590 +28794 +155 +8566 +24896 +28795 +19618 +317 +2762 +13721 +25140 +822 +14061 +2550 +28796 +3365 +12936 +14 +28797 +14604 +23103 +28798 +9 +28799 +354 +397 +28800 +9 +13307 +28801 +345 +28802 +15718 +19618 +590 +16437 +694 +8746 +872 +28803 +5547 +397 +28804 +4056 +4634 +1425 +7107 +28805 +21689 +9 +20952 +28806 +27069 +568 +14369 +845 +24864 +9 +28807 +3546 +28808 +683 +590 +7855 +104 +4364 +28809 +19618 +3546 +28810 +11907 +4001 +28811 +2243 +24725 +28812 +1314 +28813 +28814 +24864 +25683 +28815 +338 +28816 +26496 +28817 +25683 +3601 +28818 +28819 +8668 +28820 +28821 +14000 +28822 +28823 +28824 +14 +28825 +713 +4088 +24725 +15 +378 +22461 +13086 +14 +14 +14330 +3213 +3764 +2609 +155 +43 +2567 +28826 +738 +28078 +28827 +28828 +28829 +25237 +25140 +590 +57 +28830 +14477 +16437 +1481 +1066 +28317 +22236 +28831 +28832 +17385 +13111 +13848 +14369 +9688 +28833 +25140 +28834 +14 +28835 +19797 +112 +14 +1082 +12402 +378 +28549 +28317 +5481 +23806 +13150 +28836 +3476 +7154 +28837 +9410 +28838 +1605 +14868 +201 +7741 +26724 +379 +28839 +8210 +28840 +15183 +14369 +3408 +14369 +14369 +28841 +28842 +28843 +27669 +13566 +19 +28844 +1300 +28845 +28317 +16102 +28846 +28847 +10232 +2865 +28848 +24896 +1122 +14 +28849 +349 +57 +28850 +4 +28851 +25871 +14369 +28852 +21947 +28853 +14369 +15647 +23578 +16240 +3546 +24725 +28854 +20339 +19618 +28855 +720 +22850 +24862 +28856 +28857 +28858 +14 +4634 +28859 +1203 +815 +14 +19 +28860 +19618 +904 +28861 +2 +28862 +3067 +28863 +8418 +15683 +28864 +1465 +28865 +12746 +28866 +14369 +28867 +14345 +19 +19618 +28868 +245 +2065 +178 +3353 +13721 +28869 +28870 +28871 +1870 +14369 +28872 +1444 +28873 +43 +28874 +28875 +272 +24864 +14343 +990 +28876 +28877 +28878 +28879 +3598 +28880 +7176 +2 +194 +647 +827 +28881 +11308 +17326 +196 +5175 +28882 +3601 +15718 +9287 +28883 +11762 +22420 +32 +28884 +24862 +1300 +23139 +1228 +24864 +28885 +345 +590 +28886 +27726 +26069 +2286 +28887 +28888 +484 +4032 +1232 +28889 +28890 +89 +28317 +9343 +20952 +1100 +14 +24864 +16437 +28891 +28892 +28588 +57 +18695 +683 +28893 +28894 +24896 +245 +16826 +590 +28895 +28896 +9 +28897 +2744 +16883 +590 +25871 +17 +28898 +28899 +28900 +28901 +1112 +28902 +590 +16437 +22308 +9 +15442 +27669 +11733 +19618 +6156 +2476 +249 +26361 +19655 +28903 +590 +28904 +28905 +28906 +2 +18651 +14330 +28907 +25144 +27669 +28908 +13361 +28909 +9 +286 +28910 +28911 +15718 +1021 +1870 +17151 +15663 +28912 +14 +28913 +9 +28317 +28914 +20390 +278 +28915 +21947 +23853 +28916 +2550 +28917 +28918 +28919 +28920 +590 +21947 +28921 +28922 +4820 +24303 +349 +971 +28923 +28924 +28925 +28926 +89 +28927 +15718 +5188 +43 +28928 +28929 +9 +28930 +19304 +28931 +345 +24928 +28317 +28932 +28933 +1612 +28934 +19655 +4050 +4463 +28935 +28936 +26357 +46 +26724 +43 +28937 +15511 +2734 +43 +28938 +28939 +1559 +259 +9 +28940 +197 +14 +536 +25904 +14 +28941 +197 +28942 +28943 +19900 +28944 +32 +28945 +355 +43 +377 +19618 +14 +2 +32 +28946 +14369 +21947 +19091 +5780 +28947 +43 +28948 +9 +14 +28949 +28950 +1090 +28951 +1112 +28952 +28953 +28954 +28955 +827 +27167 +17920 +25237 +28956 +14 +1648 +28957 +5579 +28958 +28959 +286 +2577 +28960 +19618 +14330 +18443 +20952 +9738 +3601 +28961 +5144 +28962 +28963 +19618 +27172 +11803 +3546 +28964 +28965 +28966 +28967 +24864 +14363 +1082 +5085 +27279 +28968 +4463 +21689 +2415 +43 +15718 +28549 +22986 +345 +28969 +28951 +12344 +936 +28970 +28971 +345 +28972 +13179 +28973 +19 +1514 +3252 +28974 +1542 +28975 +4168 +9136 +21031 +1310 +28976 +24864 +28977 +24751 +28978 +22963 +14871 +9367 +19 +23103 +26431 +9039 +28979 +5099 +14369 +19618 +286 +28460 +14909 +11754 +2042 +18334 +28980 +24725 +28317 +15045 +7137 +28981 +14301 +2976 +2999 +28982 +15 +22099 +28317 +5629 +18951 +14330 +28451 +4441 +379 +28983 +1961 +28984 +19 +4963 +720 +21947 +28985 +25584 +558 +590 +590 +3546 +1425 +28986 +15718 +14186 +28987 +284 +28988 +28989 +19618 +28990 +18473 +1300 +24864 +28991 +18376 +28992 +28993 +19502 +7328 +28441 +25449 +284 +10 +213 +4264 +5757 +14369 +17136 +25140 +28994 +8427 +18951 +2029 +28995 +13721 +19797 +8653 +7440 +28996 +15718 +28997 +590 +25237 +28998 +27719 +8549 +213 +345 +12299 +28999 +14604 +29000 +29001 +11899 +286 +29002 +21689 +29003 +2415 +29004 +20 +720 +29005 +29006 +25749 +2762 +29007 +7537 +4651 +29008 +24640 +66 +337 +29009 +29010 +24725 +29011 +303 +27798 +15718 +14330 +29012 +29013 +29014 +10748 +29015 +43 +209 +29016 +29017 +209 +1154 +19618 +6095 +2316 +6407 +29018 +14363 +29019 +24864 +29020 +15 +213 +29021 +24303 +3546 +14369 +29022 +809 +213 +14604 +9 +8297 +3095 +248 +29023 +1442 +284 +29024 +29025 +23559 +1100 +29026 +2650 +1966 +19 +27798 +817 +12560 +20700 +29027 +7053 +29028 +20 +17151 +23226 +590 +7260 +43 +29029 +2197 +29030 +29031 +29032 +29033 +411 +337 +1517 +349 +43 +15810 +29034 +11966 +15539 +29035 +14330 +29036 +4518 +345 +18479 +43 +11429 +29037 +24725 +14 +303 +590 +648 +2793 +11966 +576 +24864 +2577 +14 +303 +1470 +29038 +43 +25683 +21947 +29039 +29040 +25661 +21371 +6305 +29041 +43 +16437 +15718 +29042 +24896 +29043 +29044 +43 +284 +14 +137 +19655 +1012 +17033 +4907 +29045 +66 +13721 +2415 +29046 +21947 +15486 +10117 +533 +22 +303 +29047 +590 +29048 +29049 +398 +29050 +25683 +24207 +6087 +345 +213 +29051 +861 +6364 +19 +18798 +495 +29052 +15718 +29053 +3546 +24751 +29054 +18346 +590 +67 +29055 +29056 +3553 +29057 +152 +14369 +29058 +301 +2117 +22 +29059 +590 +29060 +25683 +28299 +29061 +29062 +24896 +3353 +10720 +248 +1817 +2459 +2 +9410 +28295 +28441 +27669 +9 +24144 +248 +66 +590 +29063 +20265 +29064 +284 +17443 +29065 +15718 +29066 +1955 +2694 +13976 +29067 +14369 +590 +861 +6335 +17454 +4677 +29068 +29069 +2550 +29070 +8280 +590 +43 +286 +29071 +24303 +15718 +179 +590 +29072 +3546 +5188 +354 +3546 +29073 +14369 +29074 +29075 +15718 +29076 +137 +17670 +5641 +7053 +29077 +29078 +13721 +29079 +29080 +2902 +590 +1961 +3119 +29081 +16437 +29082 +15718 +29083 +1291 +28441 +357 +21947 +18493 +4422 +5820 +4414 +29084 +19852 +1716 +213 +9617 +29085 +25942 +11754 +2681 +16148 +29086 +29087 +43 +989 +242 +213 +29088 +21689 +2672 +2764 +5582 +29089 +1765 +29090 +22 +3553 +29091 +248 +29092 +22986 +23817 +446 +2971 +43 +28549 +43 +3546 +5561 +26484 +20681 +29093 +11312 +28991 +29094 +7053 +43 +345 +1987 +29095 +13721 +29096 +29097 +7137 +43 +29098 +10 +1896 +3417 +29099 +29100 +29101 +248 +29102 +345 +22292 +10049 +27719 +29103 +29104 +29105 +29106 +29107 +43 +29108 +15718 +29109 +29110 +29111 +1790 +19 +440 +1169 +3330 +17230 +3908 +14369 +29112 +29113 +809 +29114 +19852 +22142 +29115 +29116 +43 +20 +538 +17151 +590 +14 +29117 +736 +5904 +399 +29118 +3555 +21947 +19 +9 +1508 +590 +8686 +123 +16334 +29119 +671 +14 +9 +16437 +29120 +597 +29121 +5649 +21947 +14477 +29122 +29123 +25683 +6950 +5007 +18120 +29124 +29125 +29126 +29127 +209 +32 +14477 +14660 +29128 +98 +16116 +29129 +5780 +270 +24303 +249 +2314 +19 +597 +24725 +21947 +29130 +736 +29131 +29132 +29133 +27798 +14 +1013 +29134 +7912 +29135 +24 +10470 +29136 +155 +5780 +19618 +2032 +248 +29137 +1605 +19 +590 +24896 +6364 +24458 +22829 +29138 +6197 +29139 +822 +590 +19618 +663 +23770 +590 +29140 +1612 +29141 +21947 +29142 +1139 +43 +345 +14 +43 +14369 +583 +29143 +736 +28549 +15835 +19197 +29144 +21563 +24774 +29145 +18695 +5188 +29146 +29147 +15483 +3719 +29148 +29149 +13397 +1920 +29150 +25395 +29151 +29152 +29153 +27096 +29154 +10 +25683 +15 +29155 +29156 +29157 +5188 +11498 +3999 +29158 +284 +14363 +25943 +21947 +22823 +29159 +14369 +19797 +29160 +1626 +20700 +274 +29161 +29162 +1249 +29163 +5659 +27514 +10222 +21947 +736 +29164 +19618 +29165 +590 +8747 +43 +209 +4547 +29166 +29167 +29168 +29169 +29170 +201 +248 +852 +16079 +89 +29171 +27669 +29172 +590 +24303 +29173 +4518 +29174 +12307 +1013 +24811 +27836 +29175 +57 +9688 +27669 +16437 +29176 +720 +590 +590 +29177 +29178 +29179 +27719 +29180 +29181 +3187 +9 +178 +29182 +29183 +8744 +7053 +29184 +213 +24303 +865 +29185 +1234 +28877 +845 +3546 +509 +3745 +29186 +21947 +24303 +29187 +43 +14 +13721 +29188 +23226 +5780 +29189 +21947 +15398 +29190 +29191 +1382 +29192 +6068 +12987 +5773 +1605 +29193 +29194 +29195 +28317 +29196 +16798 +284 +3745 +15718 +337 +19868 +28317 +29197 +29198 +3546 +25140 +29199 +4055 +28317 +345 +19404 +7208 +19 +21730 +1763 +770 +29200 +1082 +29201 +21947 +1688 +29202 +14477 +5204 +730 +29203 +2260 +21003 +25293 +24045 +19404 +286 +583 +20 +536 +573 +29204 +29205 +19404 +29206 +15718 +14369 +28199 +13905 +694 +24207 +29207 +541 +29208 +3003 +284 +2 +29209 +29210 +29211 +29212 +6505 +29213 +590 +24303 +213 +57 +15 +4364 +14 +17 +29214 +29215 +19330 +14 +12497 +19951 +3553 +3601 +209 +43 +19 +18120 +29216 +29217 +284 +2577 +23103 +1169 +21394 +519 +18916 +2560 +5083 +2537 +337 +250 +29218 +29219 +29220 +29221 +1562 +7167 +29222 +29223 +8460 +23103 +29224 +6011 +5650 +29225 +21947 +24207 +29226 +989 +17151 +15517 +15718 +29227 +18995 +958 +39 +104 +29228 +13721 +2314 +137 +14957 +29229 +4055 +29230 +720 +29231 +13721 +248 +21947 +1247 +29232 +29233 +10364 +19 +16826 +15718 +349 +29234 +29235 +647 +11321 +8668 +28951 +29236 +8156 +590 +303 +225 +15718 +28951 +303 +26724 +272 +18684 +28317 +358 +29237 +29238 +15718 +29239 +24725 +14369 +2324 +21310 +2802 +29240 +213 +5188 +1011 +19655 +29241 +29242 +89 +29243 +2476 +14 +26361 +590 +286 +14 +1090 +8864 +29244 +1775 +2006 +19 +19618 +29245 +29246 +15718 +2287 +29247 +29248 +4269 +29249 +3317 +6263 +14369 +29250 +27153 +14477 +29251 +29252 +29253 +16967 +2000 +43 +5075 +15292 +213 +29254 +213 +29255 +14 +29256 +1765 +9 +18798 +3470 +17136 +29257 +19618 +14369 +317 +29258 +1604 +284 +19122 +6203 +14 +249 +29259 +345 +13279 +29260 +5629 +29261 +29262 +2314 +25237 +272 +4547 +14477 +29263 +554 +21947 +338 +590 +337 +29264 +29265 +29266 +538 +12402 +25683 +29267 +736 +1021 +43 +29268 +23990 +3007 +590 +29269 +861 +24896 +28549 +7537 +16154 +7379 +13848 +29270 +345 +14 +248 +27669 +29271 +12202 +26496 +29272 +14330 +29200 +29273 +21399 +29274 +29275 +29276 +3839 +4907 +8392 +8297 +14810 +29277 +29278 +29279 +29280 +14 +694 +29281 +24207 +28549 +4 +20 +3546 +29282 +142 +27669 +29283 +29284 +21947 +16180 +114 +2 +29285 +19 +554 +791 +936 +24864 +29286 +14369 +29287 +17151 +11762 +29288 +4196 +29289 +14369 +590 +12987 +590 +29290 +29291 +29292 +20199 +8392 +32 +337 +35 +14330 +13721 +1765 +18064 +14 +29293 +29294 +349 +29295 +29296 +15718 +14 +29297 +19 +736 +29298 +29299 +18951 +1779 +29300 +29301 +29302 +21947 +284 +29303 +730 +3353 +21947 +29304 +19 +28317 +29305 +15586 +25382 +12886 +29306 +3546 +26508 +4821 +29307 +29308 +29309 +15360 +29310 +15 +1529 +29311 +29312 +29313 +29314 +1606 +27669 +29315 +1720 +13721 +7381 +29316 +14 +7815 +29317 +3095 +25683 +349 +29318 +29319 +21947 +29320 +6766 +29321 +29322 +29323 +7996 +1245 +29324 +265 +29325 +29326 +27669 +29327 +29328 +590 +583 +190 +648 +720 +43 +43 +27798 +14604 +1749 +13265 +57 +5080 +59 +32 +26361 +28317 +29329 +19 +14 +43 +43 +1444 +671 +19 +29330 +936 +20 +29331 +3 +24896 +29332 +43 +25683 +15 +18914 +29333 +790 +2694 +18045 +29334 +590 +590 +29335 +1961 +29336 +29337 +14330 +29338 +1091 +970 +9 +57 +2832 +29339 +19 +29340 +590 +29341 +29342 +32 +14001 +9 +26496 +815 +12987 +22403 +29343 +2677 +29344 +25584 +19618 +19 +720 +14363 +345 +27669 +14330 +1090 +286 +29345 +9 +14604 +3353 +8668 +29346 +29347 +29348 +3994 +19 +3546 +10108 +165 +21947 +14604 +8566 +29349 +6087 +29350 +5085 +29351 +21947 +23363 +21947 +29352 +19965 +29353 +29354 +29355 +2540 +29356 +24303 +3540 +5929 +29204 +9 +15 +32 +377 +16375 +10 +18568 +16437 +26027 +14604 +15 +29357 +29358 +19618 +29359 +14330 +29360 +19 +817 +29361 +29362 +29363 +20442 +2512 +9102 +5188 +10777 +1434 +29364 +15718 +12005 +20984 +29365 +1051 +495 +29366 +29367 +590 +29368 +209 +29369 +29370 +14001 +3546 +10004 +15616 +2540 +14947 +19797 +1812 +25154 +1038 +2550 +21765 +29371 +21947 +9024 +5188 +29372 +29373 +29374 +43 +29375 +872 +29376 +21261 +564 +29377 +1356 +29378 +25237 +3428 +4230 +27069 +1870 +6950 +29379 +29380 +27024 +12989 +29381 +3546 +29382 +14369 +23313 +357 +225 +19404 +29383 +43 +16695 +29384 +11945 +29385 +20215 +22337 +29386 +29387 +1153 +736 +27415 +9364 +446 +15718 +29388 +28951 +24864 +14477 +4684 +24864 +29389 +279 +457 +29390 +25260 +11413 +15718 +23212 +29391 +29392 +1316 +345 +29393 +323 +22065 +448 +29394 +29395 +29396 +446 +89 +29397 +648 +19 +17048 +12404 +16258 +5623 +15824 +1634 +736 +25683 +29398 +99 +13765 +29399 +29400 +29401 +29402 +43 +29403 +3480 +29404 +16826 +2253 +18306 +29405 +21947 +29406 +24303 +1224 +1021 +29407 +28472 +4293 +29007 +9 +29408 +2206 +14947 +590 +495 +29409 +448 +29410 +20785 +9 +29411 +29412 +29413 +248 +2694 +15718 +58 +29414 +27669 +32 +19122 +24303 +9 +1765 +29415 +11 +10028 +29416 +345 +20 +665 +25140 +27669 +3655 +29417 +25140 +19237 +29418 +32 +13576 +16557 +13721 +29419 +24864 +29420 +7053 +2211 +5119 +12987 +29421 +28317 +28056 +12254 +28317 +43 +25172 +29422 +29423 +29424 +14 +29425 +15194 +8787 +29426 +13688 +29427 +28317 +22308 +397 +317 +19655 +29428 +29429 +345 +29241 +14369 +13140 +15 +28961 +514 +15718 +29430 +484 +29431 +7053 +29432 +21947 +29433 +29434 +9343 +14369 +29435 +99 +24725 +9560 +29436 +2804 +19 +14 +29437 +345 +138 +10 +2 +1051 +9 +7053 +29438 +29439 +29440 +554 +6363 +338 +16840 +18695 +27604 +29441 +25 +14369 +25829 +29442 +272 +286 +1222 +29443 +14 +365 +15479 +28606 +29444 +272 +19 +42 +29445 +2577 +2316 +24896 +29446 +29447 +495 +29448 +29200 +1198 +142 +14477 +29449 +28317 +14603 +29382 +29450 +28463 +19798 +349 +464 +17670 +29439 +29451 +17151 +29452 +25140 +25 +1425 +29453 +29454 +446 +23103 +19852 +190 +38 +29455 +43 +29456 +115 +29457 +29458 +29459 +29460 +29461 +6617 +11176 +29462 +29463 +671 +112 +736 +32 +22463 +29464 +19597 +416 +1100 +29465 +19 +20 +554 +2349 +349 +4803 +379 +29466 +13149 +270 +18310 +155 +29467 +29468 +3 +29469 +25237 +19794 +29470 +27669 +25237 +29471 +24896 +29472 +29381 +8249 +3546 +736 +29381 +5780 +29473 +29474 +29475 +2347 +25943 +29476 +29477 +29478 +29479 +18951 +554 +14 +29480 +29481 +29482 +29483 +17920 +9 +590 +7799 +53 +29484 +29485 +28951 +29486 +3349 +14947 +18869 +29487 +1356 +6011 +29488 +971 +29489 +29490 +29491 +25140 +1090 +15483 +15718 +9 +57 +29492 +29493 +590 +2733 +29494 +1244 +29495 +29496 +5780 +3546 +29497 +19 +8566 +15718 +590 +14477 +1798 +29498 +5588 +43 +25683 +29499 +29500 +13279 +379 +28317 +412 +29501 +3 +188 +29502 +349 +3994 +19 +29503 +1743 +6612 +446 +29504 +29505 +29506 +29507 +20992 +15718 +29508 +29509 +28317 +29510 +29511 +14369 +15 +7835 +345 +29512 +9 +29513 +29514 +21947 +29515 +5817 +590 +29516 +12696 +2577 +4028 +1799 +931 +89 +29517 +29204 +23208 +345 +29518 +29519 +29520 +495 +12893 +5773 +14 +15718 +19618 +15718 +29521 +28441 +22 +9 +29522 +29523 +1021 +590 +8668 +9 +43 +29524 +29525 +29526 +1273 +29527 +29528 +6068 +29529 +29530 +9 +29531 +3546 +21698 +29532 +21947 +29533 +9 +29534 +1852 +34 +12120 +28317 +43 +29535 +12158 +29536 +19404 +21947 +26127 +29537 +9 +29538 +29539 +29540 +32 +2649 +29541 +29542 +24896 +29543 +29544 +1300 +6251 +155 +29545 +14 +18064 +29275 +29546 +1812 +29547 +29548 +21689 +28951 +29549 +1018 +21947 +29550 +18199 +21689 +317 +536 +9 +29551 +29552 +43 +25943 +29553 +19 +2694 +43 +29554 +29555 +29556 +22 +29557 +104 +23226 +533 +24207 +19618 +20 +7385 +315 +29558 +2009 +29559 +12987 +27669 +25237 +21947 +29560 +484 +29561 +18503 +1907 +29562 +1559 +29563 +24161 +590 +1208 +29564 +249 +29565 +29566 +25 +3546 +27619 +15718 +29567 +8208 +6275 +29568 +29569 +29570 +590 +29571 +29572 +29573 +12988 +24896 +29574 +29575 +29576 +22963 +29577 +25683 +17813 +24896 +29578 +13721 +1401 +27420 +29579 +10 +29580 +9 +25624 +29581 +29582 +286 +25140 +29583 +12647 +29584 +29585 +10511 +16571 +29586 +29587 +155 +29588 +2260 +29589 +29590 +29591 +29592 +29593 +29594 +29595 +29381 +29596 +28549 +29597 +29598 +6505 +29599 +6468 +25683 +349 +29600 +8814 +19618 +28036 +4496 +29601 +1580 +14947 +29602 +29603 +43 +345 +27669 +29604 +29605 +707 +27087 +29606 +29607 +6766 +29608 +29609 +16254 +2694 +80 +29610 +22963 +15 +1517 +1384 +22919 +26501 +437 +29611 +9 +1768 +29612 +29613 +3575 +104 +15453 +2251 +112 +13566 +29614 +29381 +25659 +29615 +26040 +4055 +24725 +29616 +24303 +60 +15718 +21889 +115 +446 +7053 +1295 +5842 +43 +29617 +29618 +29619 +29620 +791 +29621 +29622 +2833 +24232 +1100 +2764 +6504 +9 +18736 +7253 +2744 +29623 +3743 +14415 +29624 +20694 +29625 +29626 +10094 +3553 +29627 +323 +20838 +21947 +358 +29628 +5923 +29629 +2029 +2117 +29630 +29631 +29632 +1524 +22963 +272 +29633 +6480 +29634 +1045 +29635 +29636 +29637 +11321 +23764 +89 +5188 +29638 +5188 +29639 +29640 +1212 +5188 +713 +29641 +29642 +43 +29643 +5780 +21373 +29644 +29645 +24303 +2988 +29646 +720 +20238 +29647 +12120 +29648 +1531 +14330 +29649 +29650 +2694 +21947 +29381 +29651 +29652 +29653 +138 +29654 +29655 +19 +29656 +104 +29657 +29658 +18695 +566 +19 +29659 +514 +1742 +29660 +29661 +14 +27117 +43 +24219 +936 +15853 +29662 +29663 +29664 +29204 +27739 +1870 +29665 +21947 +29666 +3790 +13961 +104 +15718 +29667 +7053 +27669 +323 +13721 +16437 +32 +19618 +20514 +21947 +6950 +115 +1011 +14560 +16979 +491 +5629 +29668 +29669 +564 +15718 +22 +29670 +13570 +4422 +3976 +29671 +24896 +29672 +29673 +43 +11787 +29674 +23103 +15540 +29675 +29200 +29676 +9 +29677 +1013 +29678 +29679 +29680 +29681 +29381 +29682 +9 +915 +16437 +17151 +29683 +861 +24178 +29684 +29685 +24896 +12893 +29686 +26031 +19091 +3551 +29687 +29688 +16826 +1961 +7053 +2042 +21689 +15718 +9749 +24896 +29689 +1870 +29690 +677 +10406 +24864 +29691 +29692 +14 +29693 +1680 +349 +29694 +24303 +25683 +29695 +2121 +27231 +12067 +12983 +29696 +29697 +43 +19091 +21947 +29381 +14369 +15718 +29698 +29381 +14947 +22 +29699 +29700 +29701 +29702 +5467 +2680 +439 +28317 +29483 +6364 +6950 +29703 +25237 +5806 +29704 +2686 +13943 +21031 +29705 +25625 +20518 +29706 +29707 +590 +1154 +29708 +29709 +29710 +29711 +43 +1168 +1090 +590 +28317 +8668 +11176 +20859 +245 +8218 +4934 +3345 +19928 +22461 +29712 +29713 +18668 +10910 +29714 +29715 +20 +197 +27669 +3119 +29716 +7835 +14 +29717 +2734 +14369 +9 +24864 +791 +22 +14481 +26710 +590 +29718 +29719 +27096 +1154 +13807 +29720 +43 +2117 +9 +29721 +590 +29722 +3055 +1425 +1514 +25659 +13823 +11436 +3626 +14477 +29723 +29724 +14369 +29725 +4357 +590 +2733 +259 +4461 +29726 +15914 +14 +28549 +29727 +1018 +39 +22 +14330 +15 +14369 +43 +25318 +5188 +29728 +29729 +29730 +2356 +3598 +4380 +650 +3601 +4502 +14477 +23828 +22236 +27669 +345 +29731 +4144 +5188 +21947 +29732 +57 +112 +18695 +29733 +43 +29734 +590 +29735 +21947 +5629 +29736 +14477 +5204 +24896 +109 +29737 +597 +15442 +3239 +19618 +29738 +29739 +24725 +278 +29740 +29741 +29742 +29743 +2117 +29744 +29745 +29746 +12582 +29747 +29748 +29749 +29750 +27669 +19404 +32 +14369 +17281 +26361 +29381 +12987 +9 +286 +29751 +17903 +14369 +29381 +13904 +3077 +16826 +201 +29752 +590 +10028 +29010 +29753 +29754 +29755 +590 +1637 +3994 +3719 +29381 +21563 +248 +4153 +201 +10117 +536 +303 +15 +936 +483 +248 +25683 +590 +15718 +29381 +185 +29756 +43 +25991 +5188 +24195 +29757 +272 +29758 +26496 +16121 +3655 +4677 +29759 +29760 +3546 +26286 +27096 +29761 +29762 +28317 +317 +18919 +29763 +10 +1011 +22986 +21947 +865 +209 +590 +29764 +28441 +29765 +436 +3376 +284 +13279 +43 +29766 +29767 +29768 +29769 +11471 +19 +5780 +373 +29770 +590 +29771 +791 +21947 +29772 +3546 +15718 +29773 +14477 +303 +14 +248 +29774 +14477 +436 +29775 +14604 +1425 +29776 +29777 +19618 +303 +826 +29778 +3 +29779 +20595 +4760 +279 +11995 +19928 +29780 +140 +5904 +29781 +29782 +29783 +14369 +2356 +15718 +1051 +554 +22986 +29784 +29785 +337 +13721 +590 +2302 +9 +14 +736 +29786 +43 +337 +12351 +43 +38 +28312 +1808 +29787 +24896 +21947 +29788 +1300 +2476 +29789 +14369 +26178 +1224 +15 +29790 +4452 +25943 +14 +29791 +20 +590 +29483 +15 +29792 +9 +9 +29793 +29381 +29794 +29795 +29796 +24144 +29797 +1090 +15718 +286 +345 +3559 +27669 +2588 +13721 +19318 +19618 +5085 +8683 +1442 +29798 +28317 +707 +3999 +19618 +1810 +590 +28441 +3904 +29381 +9617 +337 +20443 +29799 +3546 +28317 +29800 +860 +20952 +25237 +29801 +29802 +2787 +209 +19618 +29803 +286 +13566 +345 +1942 +29804 +29805 +21031 +29806 +1442 +248 +29807 +14 +248 +21947 +14 +7795 +2 +3546 +5438 +29808 +29381 +21698 +16180 +21869 +815 +29809 +29810 +1716 +109 +24864 +249 +21947 +29811 +303 +6071 +1168 +2769 +13307 +43 +3746 +14086 +14 +23323 +29812 +17871 +590 +29813 +29814 +3239 +29815 +590 +14161 +1047 +2026 +43 +21947 +373 +57 +196 +29816 +284 +590 +29817 +29818 +14 +43 +29819 +19 +15718 +29820 +21947 +20468 +43 +13957 +29821 +22 +29381 +20499 +3297 +24144 +21947 +29822 +80 +29823 +29824 +29825 +25584 +29826 +14079 +337 +29827 +29828 +9 +590 +2561 +2476 +29829 +28317 +10 +15989 +14330 +29830 +19618 +29381 +29831 +736 +303 +3484 +3546 +1502 +29832 +4862 +29833 +10 +29834 +29835 +25237 +337 +21111 +248 +14 +707 +18191 +590 +24864 +345 +29836 +29837 +3251 +29838 +4438 +1364 +1749 +2577 +19 +2593 +21947 +29839 +17467 +29840 +29841 +696 +3828 +6067 +29628 +820 +29842 +25237 +29843 +872 +43 +29844 +8367 +14369 +20339 +27331 +29845 +29846 +28549 +29847 +29848 +4634 +24896 +29849 +29850 +29851 +29852 +29853 +29854 +29855 +29856 +26744 +18479 +14369 +21947 +14369 +29381 +29381 +13721 +29857 +29858 +29859 +26672 +32 +43 +27414 +4441 +22204 +19618 +27669 +13957 +25 +29860 +519 +29861 +29862 +29863 +96 +10917 +29864 +9 +21947 +29865 +14560 +29866 +27669 +66 +13721 +12247 +14 +5134 +29867 +19618 +1513 +22230 +24403 +15 +713 +29868 +1415 +6341 +365 +29869 +29870 +18310 +9913 +1021 +6487 +2260 +28951 +29871 +29032 +344 +14604 +29872 +29873 +790 +17151 +213 +9 +3546 +29483 +29874 +29875 +5119 +2392 +29876 +29877 +29878 +29628 +25659 +17608 +29879 +29880 +9410 +19404 +29881 +89 +4278 +20883 +17749 +43 +29882 +10717 +15611 +29883 +5837 +16461 +8849 +20182 +15718 +29884 +791 +24920 +29885 +29886 +21947 +25945 +25530 +10 +29887 +15718 +286 +18234 +29888 +29889 +24303 +736 +1425 +14597 +24045 +29890 +29891 +2 +15789 +736 +21468 +29892 +9 +70 +21947 +736 +18234 +29893 +24144 +29894 +590 +28549 +25140 +25237 +29895 +29896 +3023 +29897 +1154 +57 +303 +21947 +29898 +24864 +29899 +43 +17412 +29900 +57 +7935 +1743 +43 +29901 +43 +14 +213 +19009 +15718 +29902 +29903 +16437 +29904 +16107 +29905 +29906 +14369 +3546 +29907 +29908 +29909 +29910 +29911 +19618 +4124 +27836 +4463 +21689 +29912 +29913 +1517 +14369 +8295 +1169 +29914 +29915 +29916 +29917 +29918 +915 +3353 +3252 +21947 +14 +28317 +6225 +694 +9774 +29919 +21931 +44 +29920 +16826 +14477 +9 +590 +27669 +29921 +10117 +345 +1812 +248 +6161 +43 +29922 +29923 +29924 +19618 +1051 +29925 +284 +15855 +29926 +24844 +57 +24896 +12956 +27669 +2342 +12067 +29927 +29928 +29929 +21947 +23867 +14 +14079 +4055 +12560 +179 +29930 +138 +29931 +29932 +21602 +137 +29933 +15158 +1612 +14276 +7799 +9 +1314 +2694 +21947 +248 +213 +7835 +14909 +29934 +5188 +29935 +25316 +12267 +20614 +2577 +29936 +19 +1109 +408 +77 +303 +24896 +29937 +29938 +29483 +29939 +25140 +29940 +13721 +3422 +2136 +10526 +3546 +29941 +8188 +29942 +29943 +29944 +19387 +358 +29945 +1859 +22989 +29946 +28549 +14079 +7053 +590 +13957 +27669 +19618 +29947 +25683 +29948 +13228 +379 +9 +16028 +29012 +43 +29949 +29950 +29951 +14604 +1090 +29952 +29953 +14369 +14 +15718 +25683 +3546 +29954 +29955 +29956 +29957 +29958 +5539 +15789 +29959 +43 +28441 +29960 +23578 +11995 +29961 +29962 +29963 +971 +1907 +14482 +14 +317 +29964 +1047 +14 +29965 +29966 +29967 +29968 +248 +1961 +6223 +29969 +29970 +5629 +248 +29971 +4463 +345 +14 +29972 +29973 +29974 +345 +6364 +29975 +2197 +29483 +29976 +29977 +21947 +25683 +411 +357 +345 +9 +28951 +10781 +29978 +25140 +13721 +27669 +29979 +558 +554 +5780 +29980 +286 +2135 +9600 +5791 +8668 +21889 +25934 +29981 +20132 +29982 +29983 +2795 +613 +29984 +3247 +29985 +29986 +2415 +3287 +28951 +29987 +590 +25668 +29988 +29989 +24144 +11702 +29990 +345 +29991 +590 +29992 +28441 +20161 +3874 +14 +1112 +197 +29993 +29994 +3081 +7053 +248 +29995 +29996 +713 +15207 +66 +21689 +4221 +29997 +6400 +3546 +9 +5326 +10094 +225 +29998 +28317 +1160 +29999 +30000 +7137 +30001 +14 +25683 +21947 +16515 +30002 +745 +30003 +30004 +30005 +25943 +27669 +30006 +19009 +21947 +30007 +2832 +30008 +30009 +29381 +3655 +24843 +30010 +22187 +5297 +6305 +30011 +1503 +337 +27 +16810 +8712 +2773 +1115 +15718 +24207 +9 +590 +30012 +29204 +303 +14363 +14079 +11238 +7508 +30013 +30014 +30015 +30016 +915 +11764 +29799 +21947 +19122 +5188 +4918 +19618 +30017 +185 +13721 +2035 +30018 +29032 +29720 +30019 +30020 +30021 +57 +590 +7706 +8367 +1010 +28745 +201 +19 +286 +30022 +30023 +873 +30024 +30025 +9060 +4634 +14175 +30026 +1168 +43 +30027 +322 +284 +21030 +30028 +13365 +11261 +30029 +43 +30030 +30031 +30032 +21947 +9636 +30033 +349 +30034 +43 +30035 +3484 +8442 +26475 +1021 +30036 +30037 +22 +9160 +19 +14330 +3491 +17749 +25237 +14369 +30038 +30039 +16066 +26940 +16974 +30040 +32 +30041 +519 +15939 +25943 +14436 +6504 +18020 +28951 +24864 +30042 +53 +590 +32 +30043 +76 +27069 +9 +2027 +30044 +30045 +30046 +19798 +30047 +30048 +14871 +5806 +213 +25237 +10389 +30049 +736 +30050 +30051 +30052 +21947 +27065 +19965 +30053 +30054 +32 +30055 +21947 +30056 +30057 +30058 +586 +677 +30059 +1481 +22 +15018 +10038 +15 +25943 +30060 +30061 +14369 +30062 +15718 +349 +3601 +20 +30063 +30064 +30065 +30066 +19563 +15 +30067 +647 +14330 +554 +30068 +590 +9 +548 +357 +25237 +19 +30069 +30070 +14 +30071 +14330 +28753 +43 +30072 +30073 +30074 +30075 +2836 +30076 +30077 +21947 +1011 +89 +201 +30078 +18640 +284 +30079 +13238 +5629 +30080 +30081 +155 +25140 +30082 +474 +19052 +28441 +30083 +6764 +30084 +43 +6976 +30085 +12832 +13543 +22492 +5780 +178 +30086 +29109 +11607 +29381 +14369 +683 +30087 +30088 +43 +19618 +30089 +29956 +11754 +21947 +2197 +28401 +30090 +12351 +3698 +9 +30091 +3546 +29204 +43 +5582 +26549 +4126 +22042 +28441 +30092 +165 +2694 +30093 +43 +1520 +446 +30094 +17635 +19 +1018 +30095 +15718 +30096 +19618 +3978 +2561 +5820 +18421 +14 +30097 +28441 +201 +30098 +6950 +1090 +3601 +23271 +30099 +30100 +30101 +30102 +228 +2902 +6728 +358 +30103 +1234 +9 +6261 +19 +30104 +27669 +14 +9 +26066 +1021 +2260 +29381 +3546 +1011 +14369 +8160 +43 +2330 +30105 +30106 +30107 +5803 +30108 +30109 +3546 +7259 +30110 +21947 +30111 +4752 +30112 +30113 +30114 +1517 +24725 +10 +2029 +30115 +1912 +30116 +3553 +10 +5791 +3067 +30117 +30118 +29381 +30119 +43 +27733 +29 +30120 +27404 +30121 +30122 +222 +30123 +21947 +1885 +60 +13349 +30124 +19 +19 +736 +18869 +30125 +29628 +13566 +14330 +15718 +23649 +2043 +12157 +30126 +345 +399 +6364 +14 +30127 +104 +1765 +6344 +20144 +17477 +14330 +1245 +30128 +20 +24862 +30129 +736 +30130 +30131 +3790 +30132 +30133 +19319 +286 +590 +30134 +2872 +30135 +18951 +43 +19 +30136 +30137 +8378 +30138 +373 +533 +25267 +30139 +25140 +30140 +590 +30020 +3330 +43 +30141 +18896 +30142 +30143 +1606 +15718 +30144 +30145 +2733 +30146 +24435 +19 +1920 +30147 +1765 +30148 +30149 +30150 +30151 +30152 +30153 +18248 +1332 +27069 +30154 +5188 +30155 +30156 +14102 +30157 +5188 +30158 +5088 +28317 +30159 +19618 +27564 +8455 +30160 +26361 +30161 +1056 +7577 +30162 +272 +30163 +30164 +28333 +24303 +30165 +20374 +30166 +30167 +1817 +30168 +2314 +27011 +30169 +14079 +43 +30170 +22999 +1808 +29381 +15 +30171 +30172 +7494 +30173 +30174 +30175 +14 +29799 +27069 +15 +30176 +21947 +19 +2356 +30177 +30178 +30179 +24303 +30180 +14001 +349 +30181 +26181 +14529 +17586 +30182 +2550 +30183 +7053 +30184 +30185 +30186 +20 +30187 +30188 +1066 +21947 +3059 +30189 +14330 +30190 +17271 +17872 +6924 +790 +17151 +30191 +30192 +30193 +590 +30194 +30195 +30196 +21689 +17529 +1401 +1423 +30197 +30198 +1596 +30199 +30200 +30201 +13807 +30202 +18951 +30203 +30204 +30205 +28923 +193 +1688 +15 +23103 +19618 +25829 +24896 +30206 +24725 +24725 +2476 +2787 +19206 +9210 +3858 +30207 +12397 +59 +30208 +29381 +30209 +17586 +30210 +15 +30211 +30212 +30213 +8686 +14604 +30214 +28549 +7053 +990 +30215 +7838 +21947 +2324 +34 +22963 +30216 +11259 +30217 +24207 +590 +1513 +30218 +8610 +24725 +28549 +29483 +24303 +2 +30219 +10583 +30220 +22986 +872 +7137 +30221 +43 +29799 +30222 +5326 +2254 +15718 +3546 +21947 +30223 +345 +677 +1090 +17691 +29381 +25140 +554 +30224 +5650 +25991 +30225 +13576 +25659 +17791 +24303 +15 +30226 +701 +10 +20 +30227 +4230 +30228 +671 +27875 +14 +1870 +30229 +18429 +22818 +15718 +30230 +30231 +8668 +12896 +27069 +30232 +3059 +30233 +21417 +30234 +26040 +30235 +30236 +554 +15541 +21576 +21947 +30237 +213 +30238 +18695 +15 +303 +30239 +114 +28036 +30240 +30241 +14 +29200 +872 +30242 +30243 +337 +495 +3034 +14477 +30244 +3546 +30245 +22599 +30246 +15398 +11217 +12359 +248 +30247 +37 +28661 +30248 +7749 +12956 +764 +30249 +43 +30250 +25683 +21031 +30251 +21947 +7014 +19404 +12696 +30252 +30253 +23162 +30254 +30255 +30256 +30257 +30258 +30259 +29163 +11321 +9 +16 +1011 +30260 +337 +1513 +30261 +30262 +26962 +1267 +30263 +27213 +2764 +99 +21947 +1710 +30264 +17151 +3994 +3908 +9 +30265 +30266 +14477 +19 +30267 +14 +26292 +30268 +32 +30269 +30270 +30271 +5188 +536 +21947 +30272 +30273 +3598 +57 +26496 +9 +30274 +28317 +286 +30275 +19655 +9266 +1442 +30276 +10729 +345 +23603 +30277 +19618 +30278 +30279 +25683 +284 +30280 +30281 +32 +30282 +30283 +2635 +29483 +3978 +790 +30284 +43 +30285 +248 +30286 +4747 +30287 +30288 +30289 +28317 +303 +248 +15 +2 +24303 +30290 +30291 +3994 +25237 +1234 +30292 +30293 +30294 +30295 +7738 +19118 +30296 +48 +9 +15592 +1217 +24303 +590 +25659 +29483 +29381 +28317 +30297 +26538 +2314 +1710 +3242 +590 +3435 +18798 +21849 +14330 +30298 +1655 +11762 +590 +30299 +25237 +30300 +24144 +30301 +30302 +29381 +30303 +30304 +3866 +30305 +16102 +6728 +30306 +20 +27669 +30307 +5085 +29381 +337 +30308 +6571 +30309 +7137 +9 +30310 +19 +8668 +30311 +30312 +3978 +30313 +185 +30314 +26984 +14369 +6145 +3601 +19095 +2040 +25584 +303 +30315 +27069 +2197 +25683 +30316 +30317 +3546 +333 +30318 +30319 +989 +19404 +13721 +411 +99 +2770 +5006 +1234 +4747 +14704 +29835 +1112 +4028 +5188 +30320 +303 +21947 +80 +30321 +586 +30322 +9 +411 +14369 +19 +1578 +24896 +29628 +3376 +30323 +14 +809 +286 +18064 +4278 +30324 +13848 +30325 +705 +14648 +337 +19404 +15718 +30326 +9 +21947 +30327 +4522 +28481 +5780 +9 +1168 +9110 +29381 +20 +27669 +14603 +30328 +14947 +30329 +30330 +30331 +30332 +30333 +590 +1961 +30334 +30335 +24469 +30336 +30337 +2668 +30338 +27669 +1870 +17808 +30339 +28549 +16437 +30340 +18091 +21947 +30341 +17144 +30342 +597 +30343 +24896 +3908 +7053 +323 +24725 +209 +21188 +7215 +29381 +26348 +30344 +43 +590 +519 +30345 +590 +29381 +25943 +590 +30346 +29381 +10 +19404 +30347 +1385 +8270 +30348 +17871 +30349 +25140 +323 +21947 +286 +28317 +30350 +29434 +10 +30351 +647 +6078 +23670 +30352 +7018 +25683 +1224 +14330 +17277 +30353 +23103 +590 +30354 +15939 +17571 +222 +9705 +9 +17670 +78 +590 +303 +30355 +30356 +18607 +30357 +6873 +30358 +6161 +30359 +338 +4 +7137 +30360 +30361 +19618 +30362 +14369 +2561 +30363 +155 +14233 +2260 +14369 +22689 +77 +24928 +21732 +30364 +14330 +30365 +1688 +30366 +30367 +6833 +11762 +22183 +19603 +392 +13905 +30368 +30369 +2392 +30370 +13405 +13725 +286 +21045 +2728 +3354 +5925 +3328 +30371 +8845 +26744 +17698 +14369 +43 +30372 +1112 +30373 +25683 +30374 +2449 +30375 +30376 +284 +590 +4990 +5107 +201 +29963 +3908 +647 +30377 +9 +6595 +19 +30378 +22317 +21947 +43 +155 +44 +27798 +4538 +337 +201 +30379 +1224 +14 +19 +417 +57 +26096 +11170 +30380 +373 +13905 +9214 +2342 +16031 +634 +390 +30381 +15476 +43 +3601 +3642 +668 +30382 +5267 +30383 +17151 +14604 +30384 +24045 +1051 +248 +12907 +5674 +30385 +30386 +3818 +14369 +3353 +30387 +30388 +7756 +30389 +15513 +13361 +349 +6171 +1112 +30390 +25140 +11754 +16505 +30391 +104 +1502 +9095 +44 +43 +17206 +25683 +21469 +34 +30392 +14477 +1524 +30393 +30394 +18760 +25237 +22473 +30395 +30396 +30397 +30398 +19267 +30399 +1217 +24864 +14 +30400 +554 +30401 +1470 +43 +249 +18780 +15 +30402 +29381 +14152 +10 +14 +30403 +30404 +3626 +3341 +21947 +30405 +8460 +13285 +3369 +30406 +446 +20 +284 +736 +10095 +30407 +30408 +590 +30409 +1889 +114 +140 +30410 +28317 +365 +590 +28549 +822 +2919 +590 +24000 +248 +30411 +30412 +25584 +590 +30413 +30414 +43 +14 +213 +3546 +19 +30415 +29483 +12067 +411 +24725 +4900 +1696 +736 +12987 +15824 +25237 +30416 +44 +30417 +378 +30418 +720 +30224 +30419 +21153 +24896 +337 +832 +43 +590 +2851 +248 +24896 +30420 +30421 +14369 +43 +14947 +3559 +28317 +4414 +30422 +17784 +1157 +30423 +104 +19404 +213 +3875 +17349 +6571 +32 +4808 +23752 +408 +30424 +16850 +30425 +24725 +30426 +19096 +43 +30427 +21689 +138 +26303 +16121 +12600 +25758 +286 +30428 +5134 +9 +30429 +213 +213 +43 +18684 +30430 +8297 +30431 +5119 +10239 +20 +590 +1382 +28317 +70 +29381 +43 +30432 +210 +17589 +30433 +19 +29956 +30434 +1559 +209 +29204 +26361 +19852 +30435 +30436 +28317 +10 +7291 +43 +57 +11482 +10527 +720 +14369 +1112 +30437 +30438 +30439 +30440 +18982 +30441 +18250 +1716 +590 +25140 +495 +30442 +6449 +30443 +30444 +30445 +11754 +30446 +1606 +1559 +43 +29483 +5188 +13484 +10 +303 +1364 +57 +3655 +352 +30447 +30448 +22 +30449 +28549 +21947 +1956 +30450 +213 +30451 +30452 +827 +345 +24864 +30453 +30454 +30455 +7137 +26570 +12254 +29916 +29013 +72 +9 +30456 +30457 +323 +30458 +1316 +2975 +30459 +30460 +3995 +14369 +30461 +18310 +7053 +30462 +222 +30463 +11762 +19 +12798 +9801 +8668 +15 +10527 +303 +590 +30464 +30465 +5007 +1234 +21201 +7053 +30466 +29434 +3208 +15 +30467 +15718 +30468 +38 +15533 +21947 +30469 +8668 +30470 +1574 +25683 +30471 +9402 +4364 +17972 +30472 +30473 +30474 +1593 +3546 +5318 +30475 +284 +683 +30476 +21947 +14947 +30477 +30478 +14330 +337 +19582 +27669 +12987 +30479 +9 +30480 +25237 +18951 +1514 +14369 +2043 +27669 +272 +3601 +30481 +30482 +30483 +15925 +6289 +3546 +8814 +1620 +337 +43 +707 +17749 +30484 +28317 +379 +30485 +30486 +13307 +4693 +13721 +14477 +4028 +30487 +30488 +3897 +25683 +29381 +15442 +30489 +30490 +26508 +30491 +7662 +12661 +345 +5336 +19618 +30492 +30493 +13721 +30494 +142 +6732 +27669 +736 +30495 +2410 +7014 +13538 +337 +2577 +15718 +12661 +337 +2768 +3546 +137 +30496 +28082 +1817 +5627 +21947 +30497 +30498 +30499 +19695 +30500 +590 +1961 +25237 +30501 +11 +30502 +22 +345 +5188 +590 +30503 +30504 +43 +30505 +30506 +30507 +29483 +16226 +1332 +3480 +8668 +30508 +24725 +19386 +4196 +30509 +5188 +3546 +30510 +18695 +30511 +14477 +30512 +30513 +30514 +2772 +30515 +14369 +24218 +20572 +30516 +30517 +2314 +647 +613 +2029 +5293 +14369 +19618 +26496 +21776 +683 +30518 +30519 +19618 +30520 +30521 +43 +30522 +2324 +9 +30523 +30524 +30525 +30209 +5780 +9649 +13721 +30526 +14 +10 +28353 +14825 +228 +349 +19 +5188 +30527 +30528 +1021 +30529 +7855 +30530 +48 +30531 +30532 +29483 +7835 +30533 +1809 +30534 +30535 +10 +104 +22680 +8244 +21947 +590 +29381 +30536 +30537 +2 +30538 +3080 +6505 +30539 +18100 +17094 +22552 +30540 +26132 +29381 +23474 +30224 +248 +831 +30541 +686 +30542 +30543 +11607 +30544 +30545 +30546 +29491 +8724 +647 +30547 +30548 +27669 +3328 +27669 +30549 +30550 +2406 +30551 +28317 +24045 +8610 +29483 +8244 +30552 +30553 +27669 +21698 +2208 +3719 +30554 +14369 +4012 +28317 +2593 +28549 +1082 +30555 +17921 +30556 +5267 +30557 +19435 +29381 +10356 +24864 +30558 +17005 +12431 +30559 +989 +272 +30560 +21947 +19 +21509 +1011 +30561 +14369 +30562 +457 +30563 +30564 +29483 +28317 +24860 +18744 +140 +18045 +24418 +1787 +25237 +29381 +7053 +43 +590 +590 +358 +7328 +9 +30565 +24144 +6341 +30566 +13585 +24864 +30567 +30568 +30569 +14369 +29483 +323 +4055 +8110 +15718 +2015 +27905 +15 +21947 +11762 +30570 +43 +20600 +30571 +16437 +15193 +2234 +30572 +30573 +30574 +30575 +590 +29981 +14369 +59 +4341 +1356 +30576 +1799 +24860 +30577 +3480 +30578 +15718 +18079 +1870 +30579 +21947 +30580 +29381 +24045 +30581 +29483 +14947 +30582 +1542 +5085 +3462 +19 +9060 +349 +379 +29381 +22308 +25943 +30583 +19 +1710 +3546 +590 +12287 +30584 +3546 +13229 +25 +21947 +1648 +349 +12222 +5561 +30585 +18982 +30586 +14215 +30587 +14666 +25276 +19 +30588 +590 +21947 +1442 +24725 +25364 +30589 +30590 +30591 +24864 +30592 +5085 +30593 +12987 +29629 +12479 +30594 +57 +5606 +30595 +30596 +30597 +249 +5085 +30598 +26744 +30599 +43 +17151 +1082 +30600 +30601 +29483 +30602 +27798 +5217 +30603 +30604 +25382 +43 +915 +30605 +2060 +29483 +30606 +30607 +26417 +7053 +25237 +30608 +30609 +24864 +30610 +30611 +1300 +15 +15949 +20816 +21031 +30612 +30613 +29483 +30614 +26361 +30615 +5314 +30616 +30617 +1203 +19 +14079 +10511 +30618 +5629 +24896 +19618 +26508 +590 +30619 +20636 +30620 +140 +30621 +26786 +30622 +21947 +26064 +28317 +30623 +30624 +19 +25316 +30625 +30626 +19 +43 +14 +30627 +3034 +30628 +1870 +1083 +15718 +5614 +373 +2 +30629 +30630 +38 +21947 +30631 +8668 +12404 +30632 +30633 +30634 +12062 +1226 +29381 +136 +140 +30635 +15718 +30636 +3913 +286 +14369 +25088 +30637 +4012 +20 +25237 +30638 +1517 +2975 +30639 +30640 +13721 +42 +23617 +30641 +1245 +3546 +671 +30642 +30643 +12987 +3228 +4364 +30644 +21689 +14330 +5785 +590 +17518 +30645 +2925 +24725 +13721 +30646 +21889 +15054 +30647 +30648 +29992 +713 +43 +155 +30649 +590 +30650 +286 +6060 +30651 +43 +17151 +9 +6766 +11754 +2733 +250 +20656 +242 +397 +30652 +9 +1332 +30653 +30580 +3531 +188 +30654 +30655 +12067 +30656 +30657 +30658 +26496 +24896 +23103 +30659 +30660 +30661 +20 +349 +30662 +30663 +188 +29483 +28147 +586 +29381 +30664 +30665 +14369 +8297 +30666 +30667 +164 +1153 +2342 +20 +21947 +10303 +30668 +259 +43 +1852 +4764 +30669 +13619 +9 +30670 +30671 +201 +10946 +3 +357 +30672 +30673 +9 +30674 +16817 +30675 +286 +358 +30676 +14477 +24896 +1889 +29381 +4138 +910 +3546 +21971 +30677 +11906 +30678 +566 +1295 +188 +3546 +30679 +11073 +8668 +19 +2409 +4765 +2260 +22236 +9 +30051 +412 +25620 +2764 +590 +15923 +736 +30680 +24864 +10117 +30681 +736 +14369 +30682 +1013 +30683 +30684 +30685 +30686 +349 +3601 +2 +25683 +1765 +43 +30687 +6893 +30688 +363 +2410 +11083 +25 +27669 +30689 +27669 +14330 +30690 +30691 +30692 +30693 +764 +30694 +30695 +30696 +13777 +14 +24045 +30697 +30698 +873 +30699 +2314 +2694 +30700 +11810 +28441 +30701 +30702 +1157 +30703 +30704 +30705 +30706 +24725 +30707 +8188 +30708 +30458 +27669 +7053 +30709 +30710 +30711 +30712 +30713 +4550 +26690 +13801 +30714 +30715 +30716 +915 +30717 +536 +60 +11087 +28490 +887 +18283 +590 +25971 +17371 +1716 +30718 +2834 +30719 +30720 +30721 +30722 +29984 +30559 +29381 +30723 +30724 +597 +30725 +30726 +30727 +1621 +19 +30728 +43 +30729 +30730 +30731 +30732 +30733 +19404 +30734 +30735 +1287 +30736 +30737 +19 +30738 +3546 +30739 +30740 +14947 +16437 +89 +23226 +10 +590 +30741 +6764 +18934 +30742 +30743 +26361 +2550 +345 +28317 +30744 +1508 +23752 +1698 +30745 +30746 +30747 +10 +1562 +15718 +21947 +2314 +30748 +3950 +30749 +30750 +25159 +30751 +23102 +286 +8668 +209 +30752 +27669 +2325 +21831 +30753 +18695 +19091 +27669 +30754 +2830 +30755 +30756 +6214 +9 +7855 +28317 +30757 +30758 +30759 +30760 +30761 +2065 +30762 +25237 +30763 +25943 +30764 +22098 +30765 +30766 +30767 +7559 +30768 +12987 +29381 +8249 +30769 +4821 +30770 +10 +345 +2804 +27482 +30771 +99 +20555 +30772 +4806 +30773 +30774 +30775 +30776 +27719 +18019 +43 +19618 +2471 +2459 +27669 +590 +9 +30777 +21947 +30778 +30779 +15 +4982 +3353 +17151 +109 +43 +519 +5074 +28441 +30780 +26040 +30781 +30782 +13841 +30783 +4387 +21947 +30784 +30785 +30786 +399 +30787 +1262 +21947 +7108 +30788 +590 +30789 +12231 +30790 +590 +2577 +2320 +5204 +11754 +25659 +43 +30791 +1824 +13662 +26649 +30792 +24864 +865 +30793 +25140 +14369 +30794 +67 +18605 +417 +30795 +30796 +22963 +1224 +19618 +70 +30797 +3546 +29483 +30798 +4364 +861 +14770 +3908 +30224 +30799 +39 +30800 +2459 +30801 +1612 +339 +30802 +817 +30209 +30803 +9629 +13576 +4278 +14343 +9 +20514 +30804 +17151 +30805 +30806 +25943 +30807 +590 +27669 +1300 +30808 +7053 +5601 +1423 +29483 +3546 +590 +30809 +21947 +845 +30810 +355 +14369 +30811 +24725 +30812 +30813 +30814 +12220 +5188 +30815 +590 +28317 +30816 +30817 +30818 +30819 +18186 +15207 +14604 +21337 +30820 +30821 +6334 +4425 +188 +3546 +1291 +14369 +15718 +30822 +30823 +30824 +272 +24896 +15825 +28317 +590 +19655 +57 +30825 +19 +2342 +12579 +30826 +21947 +30827 +13307 +18695 +28568 +19404 +24774 +9095 +2260 +9842 +20952 +1018 +190 +3764 +43 +2896 +30828 +2764 +25943 +14 +30829 +29381 +2049 +24144 +365 +98 +30830 +29483 +14841 +30831 +1018 +6364 +30832 +30833 +17270 +10430 +30834 +30835 +19 +21947 +30836 +1300 +28317 +30837 +30838 +30839 +14133 +43 +30840 +1220 +21947 +30841 +30842 +16437 +30843 +25172 +30844 +30845 +28317 +22 +17046 +30846 +573 +43 +27669 +30847 +30848 +12684 +20108 +30849 +30850 +15718 +30851 +15311 +19 +30852 +446 +4458 +30853 +345 +1992 +30854 +30855 +14363 +30856 +703 +30857 +30858 +861 +30859 +24333 +345 +30860 +14330 +9 +30861 +30862 +30863 +1012 +713 +15718 +26635 +30864 +3 +10360 +30865 +554 +20700 +590 +155 +30866 +30867 +29483 +28923 +416 +18896 +30868 +345 +30869 +30870 +590 +26011 +14 +24790 +30871 +345 +15 +3104 +17320 +15718 +19618 +14 +2314 +590 +1688 +4634 +30872 +21835 +590 +19064 +30873 +286 +30874 +30875 +30876 +17151 +14 +30877 +3626 +30878 +3551 +30879 +30880 +19 +5188 +3601 +10230 +29483 +1021 +22669 +30881 +29483 +30882 +22989 +14330 +38 +13566 +30883 +30884 +1559 +349 +43 +25172 +827 +43 +29497 +20 +30885 +30886 +30887 +5410 +14 +495 +19 +30888 +15 +30889 +14369 +89 +15942 +3546 +14604 +30890 +66 +43 +30891 +15 +30892 +32 +417 +228 +24131 +30893 +12722 +30224 +21499 +19582 +30894 +25237 +30895 +1961 +30896 +19 +30897 +24896 +30898 +304 +3546 +25666 +26711 +30899 +30900 +30901 +77 +827 +30902 +30903 +30904 +16437 +30905 +14330 +103 +30906 +27069 +25659 +1529 +1559 +5662 +12005 +27669 +14 +4306 +14 +30907 +30908 +30909 +30910 +30911 +58 +30912 +28441 +30913 +1245 +25604 +14477 +677 +29483 +30914 +3598 +4195 +281 +17151 +24045 +66 +14000 +43 +46 +30915 +30916 +29483 +25871 +43 +155 +30917 +30918 +18145 +2038 +2872 +30919 +43 +13279 +16437 +30920 +209 +30921 +25 +19655 +13583 +345 +89 +11174 +14527 +17151 +30922 +30923 +736 +13553 +30924 +24919 +1066 +29381 +89 +506 +533 +2 +14898 +442 +713 +14330 +25659 +6877 +30925 +8602 +29483 +3546 +1716 +30926 +349 +30927 +30928 +4028 +1786 +14330 +22308 +30929 +30930 +17608 +3546 +2 +14102 +6459 +30931 +3546 +21947 +30932 +29381 +57 +30933 +5085 +20952 +3546 +14185 +3546 +1521 +2264 +30934 +30935 +30936 +29153 +713 +245 +590 +21947 +30937 +2525 +2733 +30938 +43 +25140 +4502 +27719 +30939 +24896 +26484 +30940 +3044 +30941 +26484 +19618 +5085 +9 +2764 +30942 +30943 +21186 +484 +1444 +30944 +30945 +30946 +30947 +349 +2309 +842 +4086 +14477 +30948 +43 +30949 +22963 +11389 +303 +24063 +30950 +11995 +24144 +14909 +19404 +30559 +248 +30559 +10407 +12907 +915 +29483 +30951 +248 +1021 +30952 +30953 +829 +30954 +590 +30955 +30956 +25683 +30957 +30958 +9705 +30959 +30960 +26484 +25683 +30961 +915 +284 +19 +15718 +10961 +30962 +30963 +43 +284 +30964 +18568 +20514 +1332 +30965 +30966 +21947 +590 +2834 +30967 +30968 +19618 +7835 +30969 +590 +29483 +7522 +30970 +28317 +3790 +2064 +30971 +29483 +1234 +1710 +30972 +58 +23103 +30973 +249 +358 +21947 +358 +379 +32 +1471 +213 +30974 +30975 +6776 +14604 +8967 +713 +1222 +248 +30976 +817 +8256 +27669 +671 +30977 +15718 +30978 +14477 +16437 +73 +21947 +30979 +24951 +43 +14369 +7977 +24303 +27433 +1745 +14660 +26229 +927 +827 +30980 +30981 +25943 +9604 +43 +554 +30982 +30983 +751 +30984 +590 +248 +286 +30985 +677 +30986 +27446 +18946 +11845 +30987 +30988 +29381 +1562 +21947 +379 +2015 +30989 +15356 +3546 +30990 +30991 +1465 +30992 +590 +30993 +30994 +14369 +6095 +29483 +30995 +29381 +2804 +30996 +15259 +1562 +24144 +89 +3480 +9718 +1026 +19965 +66 +2728 +16853 +30997 +30998 +7137 +30999 +272 +1834 +31000 +590 +9 +12697 +31001 +20339 +31002 +2430 +3 +32 +974 +31003 +1169 +28441 +24896 +15824 +31004 +31005 +31006 +28317 +829 +13615 +179 +11138 +15470 +31007 +30051 +2004 +533 +31008 +24374 +29381 +27669 +590 +14369 +14369 +590 +13375 +27996 +1262 +12871 +31009 +31010 +29381 +15718 +1021 +29483 +14363 +31011 +31012 +31013 +22065 +14477 +29381 +43 +8188 +12563 +12053 +15718 +23464 +31014 +315 +303 +31015 +31016 +43 +4518 +278 +303 +31017 +18064 +17151 +31018 +14369 +31019 +3553 +491 +13721 +31020 +31021 +590 +31022 +31023 +20051 +31024 +9232 +4441 +15763 +103 +140 +3546 +25683 +21975 +31025 +31026 +31027 +29204 +31028 +27669 +30538 +286 +5451 +31029 +17151 +31030 +1300 +327 +31031 +3484 +31032 +31033 +21947 +31034 +31035 +16340 +1458 +27794 +2121 +19618 +31036 +29483 +31037 +590 +345 +31038 +31039 +31040 +1208 +8392 +31041 +2636 +31042 +31043 +736 +237 +31044 +26040 +3546 +25584 +791 +29799 +3251 +5089 +25140 +28317 +21853 +1013 +31045 +349 +915 +20532 +28317 +31046 +345 +31047 +26025 +21947 +16919 +648 +12351 +29483 +31048 +155 +31049 +20 +22420 +31050 +201 +3546 +188 +29434 +613 +31051 +15718 +31052 +24864 +9 +77 +4441 +18120 +22355 +13640 +164 +665 +31053 +140 +31054 +19618 +15718 +31055 +18283 +31056 +2485 +915 +31057 +31058 +872 +822 +19 +31059 +6617 +29381 +27669 +21947 +15068 +11670 +397 +31060 +8668 +31061 +3976 +27069 +31062 +31063 +31064 +1382 +31065 +24144 +22010 +590 +31066 +18045 +20404 +1559 +927 +590 +31067 +9 +26744 +31068 +19618 +31069 +1082 +179 +31070 +15980 +379 +43 +31071 +31072 +31073 +31074 +43 +31075 +16211 +11479 +31076 +3546 +22 +29628 +24896 +31077 +14001 +31078 +31079 +31080 +31081 +15 +31082 +10 +31083 +30559 +11582 +31084 +25904 +28549 +303 +25 +8244 +31085 +31086 +31087 +31088 +5780 +9 +12315 +25 +501 +8005 +284 +833 +411 +26744 +345 +31089 +31090 +31091 +3251 +31092 +43 +2694 +590 +29483 +5806 +31093 +31094 +25683 +2795 +31095 +21837 +9287 +188 +31096 +31097 +15348 +31098 +14871 +665 +19792 +31099 +286 +648 +970 +2197 +31100 +31101 +176 +31102 +20538 +590 +31103 +13086 +31104 +89 +19618 +43 +31105 +31106 +31107 +2975 +14477 +14477 +16826 +201 +16645 +26361 +30224 +736 +31108 +1018 +303 +20 +25943 +1051 +345 +29483 +4002 +8351 +14330 +30580 +21947 +31109 +31110 +153 +31111 +25140 +272 +14330 +18310 +31112 +323 +25237 +15569 +14369 +31113 +31114 +21947 +1543 +358 +30051 +2414 +3601 +25316 +12987 +24207 +31115 +31116 +31117 +31118 +286 +29483 +677 +31119 +20 +31120 +31121 +25237 +31122 +178 +31123 +31124 +43 +31125 +478 +27669 +23805 +43 +25943 +3950 +14520 +114 +18951 +31126 +31127 +1559 +31128 +31129 +29483 +26452 +31130 +32 +31131 +31132 +1502 +31133 +5390 +971 +15718 +14369 +30877 +31134 +31135 +31136 +303 +303 +27260 +6950 +28317 +284 +28179 +25659 +9 +14436 +31137 +303 +31138 +31139 +31140 +1047 +31141 +21947 +14330 +11672 +31142 +31143 +24896 +26158 +29381 +4414 +31144 +31145 +31146 +31147 +568 +31148 +31149 +590 +14363 +31150 +2253 +1082 +28441 +2260 +248 +1051 +31151 +31152 +1961 +15183 +286 +10601 +22371 +10793 +595 +19655 +24725 +24896 +43 +31153 +21947 +337 +31154 +18798 +31155 +25202 +21869 +2728 +22420 +11683 +590 +21947 +30877 +25584 +31156 +12987 +31157 +31158 +19 +548 +402 +31159 +19 +31160 +31161 +14643 +861 +2577 +1606 +98 +590 +31162 +9210 +24725 +31163 +3546 +24864 +12987 +1289 +15 +14477 +31164 +31165 +31166 +31167 +31168 +3546 +590 +31169 +31170 +971 +23666 +31171 +3546 +17920 +96 +31172 +43 +15649 +29381 +31173 +30917 +27548 +89 +446 +590 +536 +31174 +448 +323 +31175 +31176 +13905 +31177 +43 +31178 +31179 +8297 +14734 +31180 +15718 +31181 +373 +509 +31182 +31183 +4055 +31184 +379 +13848 +590 +590 +27798 +43 +31185 +31186 +2043 +213 +27669 +16948 +590 +14 +815 +5188 +31187 +31188 +31189 +13721 +17151 +31190 +23103 +26083 +31191 +179 +7983 +14814 +10111 +31192 +5188 +15 +31193 +284 +9 +17151 +57 +31194 +31195 +12474 +14000 +7810 +10 +31196 +14369 +19 +43 +6054 +2197 +31197 +17151 +31198 +2176 +349 +369 +5188 +31199 +31200 +31201 +31202 +1013 +1287 +25140 +31203 +29 +31204 +4056 +5840 +13840 +23103 +4278 +31205 +1066 +31206 +561 +554 +7053 +29381 +14330 +31207 +31208 +365 +31209 +25140 +31210 +14343 +345 +31211 +14369 +22311 +14947 +3059 +46 +31212 +31213 +31214 +7045 +365 +31215 +24144 +31216 +3553 +3978 +270 +19618 +2733 +8721 +31217 +6058 +24896 +31218 +31219 +21947 +201 +31220 +707 +25237 +43 +31221 +566 +60 +43 +31222 +31223 +2260 +31224 +19618 +2577 +13905 +26040 +31225 +31226 +31227 +12987 +31228 +31229 +26571 +31230 +3553 +31231 +31232 +5757 +9 +31233 +14363 +3598 +356 +22 +6970 +31234 +31235 +28441 +31236 +19618 +822 +31237 +19618 +30877 +15718 +25897 +31238 +1559 +31239 +167 +31240 +19618 +31241 +1870 +28326 +31242 +31243 +590 +30559 +25140 +20 +9 +24303 +32 +19655 +19618 +286 +17698 +265 +19189 +31244 +31245 +31246 +440 +31247 +31248 +29483 +31249 +15793 +31250 +5188 +2619 +3964 +14330 +6275 +29483 +31251 +5679 +31252 +31253 +31254 +9754 +11966 +9 +12 +16 +13539 +1094 +31255 +30224 +31256 +21947 +29799 +24725 +16089 +24864 +89 +5085 +15907 +31257 +7385 +27798 +20098 +554 +9 +3598 +17983 +250 +1011 +6331 +30877 +31258 +31259 +31260 +31261 +8668 +30794 +43 +1976 +1011 +31262 +9 +13721 +31263 +554 +3546 +13721 +31264 +24785 +249 +590 +31265 +349 +29381 +31266 +19618 +2308 +19618 +31267 +21947 +14369 +3601 +13576 +3 +31268 +590 +590 +43 +970 +31269 +24864 +31270 +155 +14369 +590 +19618 +9 +14369 +29002 +800 +2891 +27669 +27669 +590 +970 +5119 +12987 +14240 +31271 +31272 +30877 +14947 +15471 +25683 +30826 +31273 +30877 +31274 +77 +3978 +352 +590 +31275 +31276 +5119 +31277 +19618 +31278 +590 +21676 +31279 +1376 +24303 +21947 +31280 +286 +29483 +3406 +16451 +754 +31281 +31282 +31283 +11259 +25683 +809 +736 +31284 +9 +22 +31285 +9 +57 +1083 +14 +764 +23363 +19 +31286 +21947 +31287 +31288 +16437 +9 +736 +14660 +342 +31289 +31290 +27817 +12832 +590 +16466 +19836 +5976 +21309 +11940 +31291 +31292 +29381 +31293 +1612 +11934 +27669 +24864 +286 +2476 +2499 +31294 +31295 +31296 +7665 +14330 +677 +19209 +6877 +887 +9210 +31297 +12259 +43 +31298 +1521 +1027 +31299 +31300 +31301 +209 +2591 +31302 +31303 +31304 +31305 +3369 +53 +9 +32 +31306 +31307 +272 +31308 +31309 +16437 +31310 +8297 +1047 +3546 +15718 +379 +18683 +30559 +31311 +31312 +17902 +21947 +31313 +9 +21947 +31314 +31315 +31316 +31317 +11522 +29483 +26020 +31318 +43 +19618 +2316 +18896 +31319 +9 +21625 +3546 +31320 +24207 +31321 +27669 +11738 +31322 +31323 +11702 +89 +31324 +31325 +31326 +12987 +185 +14369 +31327 +533 +590 +25237 +31328 +19 +31329 +31330 +590 +16931 +22 +14330 +1920 +43 +15 +209 +31331 +31332 +6741 +30051 +31333 +720 +31334 +30877 +9782 +31335 +31336 +20496 +21947 +31337 +3546 +19618 +3343 +31338 +31339 +10 +4550 +248 +43 +21716 +8297 +19 +31340 +24588 +31341 +849 +31342 +31343 +15 +31344 +31345 +30877 +32 +155 +1013 +736 +15824 +4441 +31346 +887 +3994 +13396 +25943 +24045 +519 +30209 +29884 +10028 +25047 +31347 +31348 +29956 +21947 +31349 +590 +1090 +31350 +10362 +18112 +31351 +915 +31352 +77 +18695 +15853 +6197 +31353 +14603 +31354 +30224 +17834 +31355 +57 +8005 +4285 +31356 +27719 +21947 +17206 +1384 +31357 +31358 +31359 +31360 +31361 +31362 +2121 +30877 +1352 +18928 +18045 +66 +31363 +31364 +30877 +5512 +31365 +17168 +31366 +6395 +28441 +34 +29483 +3950 +31367 +31368 +31369 +29483 +31370 +31371 +27069 +28317 +31372 +13721 +31373 +31374 +31375 +9 +29786 +31376 +11472 +1046 +31377 +665 +19 +28317 +31378 +31379 +31380 +25237 +25584 +756 +13030 +14477 +31381 +14 +201 +31382 +138 +590 +43 +31383 +43 +24725 +98 +25382 +31384 +21045 +286 +29381 +30877 +89 +31385 +25140 +19618 +20897 +31386 +31387 +29483 +5085 +14660 +213 +19 +14369 +701 +29381 +31388 +28339 +24045 +11754 +31389 +30877 +29381 +31390 +31391 +10880 +19 +31392 +31393 +31394 +20536 +31395 +31396 +31397 +31398 +31225 +28317 +2 +1154 +25683 +20 +31399 +284 +31400 +31401 +3353 +2043 +14594 +7053 +16 +213 +24725 +17 +9 +30224 +29381 +590 +248 +31402 +42 +31403 +31404 +3546 +31405 +1847 +315 +248 +27798 +109 +14947 +31406 +1107 +21947 +31407 +31408 +345 +500 +1038 +31409 +19 +31410 +30224 +6179 +31098 +28317 +2264 +31411 +29483 +140 +21681 +10973 +30877 +1013 +31412 +28961 +1352 +31413 +5080 +31414 +21947 +31415 +14599 +31416 +25871 +53 +17 +14 +27798 +31417 +19618 +8668 +31418 +43 +24303 +31419 +8668 +9 +3601 +31420 +31421 +31422 +7835 +26727 +2314 +4609 +31423 +31424 +248 +1090 +470 +15718 +30877 +26496 +3546 +3160 +1992 +303 +31425 +31426 +7137 +31427 +25237 +1784 +20897 +9 +284 +31428 +2913 +31429 +170 +29628 +28317 +554 +31430 +22 +2668 +31431 +412 +43 +13390 +2489 +21776 +10 +19 +26508 +13776 +31432 +1224 +4550 +31433 +109 +1531 +31434 +31435 +284 +4028 +31436 +1924 +31437 +29483 +14001 +15718 +31438 +31439 +31440 +18695 +14369 +30877 +23103 +31441 +15 +31442 +20094 +31443 +20888 +4055 +9451 +31444 +31445 +16865 +303 +17033 +32 +22963 +31446 +43 +17136 +9 +4025 +19126 +29381 +13030 +1716 +685 +31447 +17084 +31448 +31449 +9939 +209 +29381 +31450 +28317 +25140 +590 +169 +18034 +31451 +31452 +19655 +541 +2593 +14369 +31453 +24303 +20 +9 +8721 +31454 +397 +415 +31455 +990 +716 +31456 +1765 +31457 +31458 +4684 +554 +14369 +536 +1131 +22064 +3408 +29381 +26496 +31459 +31460 +21689 +1335 +31461 +31462 +249 +9 +31463 +31464 +17151 +31465 +24675 +20 +13150 +10117 +31466 +43 +28339 +31234 +317 +31467 +31468 +27669 +23103 +14 +31469 +31470 +29381 +26744 +29483 +7253 +337 +1090 +31471 +31472 +411 +554 +15824 +31473 +491 +671 +31474 +31475 +31476 +590 +31477 +31478 +14369 +14 +915 +31479 +31480 +7868 +31481 +9 +29483 +31482 +6090 +31483 +28471 +31484 +31485 +31486 +941 +6877 +31487 +1817 +31488 +22 +720 +915 +31489 +31490 +5498 +24010 +31491 +31492 +19 +31493 +390 +29483 +2577 +31494 +14363 +31495 +29483 +31496 +31497 +249 +9 +16656 +5188 +19817 +28999 +970 +6595 +31498 +11304 +5780 +3546 +27069 +31499 +31500 +3599 +31501 +31502 +31503 +31504 +25683 +284 +9548 +533 +9994 +43 +25683 +14369 +57 +3 +12832 +31505 +2315 +590 +5169 +1332 +31506 +31507 +559 +27669 +15718 +31508 +31509 +31510 +1578 +590 +31511 +28000 +31512 +19 +31513 +31514 +165 +31515 +558 +213 +31225 +1765 +31516 +1927 +1352 +31517 +31518 +5085 +15631 +31519 +27669 +590 +379 +28877 +30650 +10750 +28317 +29483 +31520 +25237 +8961 +19 +18951 +22464 +7233 +31521 +345 +31522 +31523 +30921 +31524 +31525 +31526 +29799 +745 +31527 +31528 +15718 +31529 +24952 +9132 +31530 +14301 +2009 +31531 +8367 +3465 +31532 +30877 +24864 +28317 +31533 +5085 +31534 +31535 +8668 +31536 +24302 +16444 +31537 +446 +31293 +3553 +2259 +31538 +31539 +25237 +590 +30309 +31540 +30877 +491 +2187 +31541 +31542 +31543 +31544 +5659 +27069 +958 +31545 +196 +31546 +31293 +31547 +24207 +13721 +31548 +865 +2117 +18695 +345 +31197 +2515 +24896 +665 +13919 +31549 +1019 +1937 +31550 +15718 +31551 +31552 +22063 +1905 +14369 +9 +820 +15718 +1716 +201 +286 +19883 +16118 +31553 +7053 +31554 +31555 +15718 +31556 +284 +4463 +31557 +31558 +533 +31559 +31560 +26361 +5627 +31561 +31562 +77 +286 +31563 +14330 +31564 +29381 +30224 +7855 +854 +19618 +31565 +31566 +31567 +2728 +936 +29109 +29483 +373 +89 +337 +1831 +4144 +31568 +28317 +30309 +10 +15 +31569 +31570 +6991 +13721 +31571 +970 +25097 +31572 +5780 +9578 +10407 +7053 +358 +43 +213 +15 +31573 +31574 +16640 +31575 +8247 +29032 +12987 +31576 +31577 +25237 +24725 +7053 +43 +31578 +46 +31579 +30551 +31580 +24864 +3546 +213 +11838 +30921 +213 +31581 +31582 +284 +31583 +11607 +11754 +5780 +14477 +27669 +25943 +345 +274 +25943 +31584 +27473 +213 +29381 +31585 +15370 +1458 +16656 +10 +31586 +31587 +30877 +19618 +26647 +31588 +31589 +31590 +43 +2314 +27669 +29200 +31591 +1768 +9 +564 +1021 +286 +5707 +31592 +286 +29483 +4918 +2086 +6557 +31593 +9 +18607 +970 +11571 +337 +1051 +26190 +31594 +31595 +274 +19095 +3546 +21947 +9335 +31596 +284 +2993 +29032 +31597 +155 +21947 +2356 +31598 +31599 +554 +31600 +31601 +10356 +14477 +17 +720 +31602 +30877 +554 +2728 +28317 +6766 +31603 +11210 +31604 +43 +31605 +9 +1559 +18561 +31606 +14 +668 +23806 +3553 +31607 +19655 +31608 +31609 +590 +31610 +31611 +21947 +25140 +31612 +31613 +677 +31614 +1517 +15 +29628 +337 +31615 +31616 +31617 +29483 +66 +31618 +31619 +31620 +31621 +31622 +22 +5188 +22963 +29791 +25097 +337 +31623 +4808 +29483 +31624 +5188 +2694 +25237 +4242 +25109 +31625 +31626 +31627 +22 +13840 +12067 +31628 +2029 +4606 +13349 +19 +24896 +3575 +3457 +21126 +31629 +14477 +31630 +30877 +19372 +17997 +31631 +586 +31632 +12987 +31633 +303 +16472 +43 +31634 +1244 +31635 +32 +4174 +1862 +31636 +31637 +14369 +14330 +31638 +17039 +1745 +15718 +24403 +12987 +31639 +15718 +31640 +6736 +791 +66 +31641 +31642 +31643 +21947 +16437 +29483 +31644 +590 +31645 +30877 +2289 +25140 +43 +31646 +31647 +36 +15718 +9 +590 +29576 +31648 +31649 +24045 +1414 +43 +31650 +3 +18919 +2 +31651 +185 +21947 +31652 +31653 +31654 +31655 +31656 +1047 +31657 +31658 +13150 +31659 +30877 +317 +337 +2 +4055 +31660 +31661 +671 +2694 +28317 +19852 +3546 +31662 +1956 +29483 +1090 +14330 +5976 +25723 +15584 +736 +32 +178 +31663 +377 +3067 +730 +21947 +31664 +17144 +15 +5820 +31665 +2694 +517 +31666 +6459 +43 +25402 +13721 +31667 +12013 +19618 +31381 +11224 +5041 +24864 +882 +31668 +10 +970 +4808 +720 +18418 +31669 +29483 +248 +31670 +25140 +31671 +25943 +345 +3477 +590 +31672 +57 +31673 +4055 +31674 +31675 +24896 +13721 +245 +30224 +19618 +22868 +31676 +31677 +2260 +30458 +29204 +18136 +29483 +21031 +7137 +30877 +142 +14603 +9 +31678 +14369 +1604 +31679 +21947 +31680 +31681 +31682 +31683 +736 +31684 +16413 +14216 +7835 +17907 +18982 +2733 +25140 +5435 +590 +28549 +31685 +31686 +31687 +27939 +379 +31688 +31689 +31690 +31691 +38 +43 +15718 +28013 +31692 +337 +26361 +613 +31693 +6086 +112 +31694 +1384 +31695 +28140 +5780 +9 +13150 +7855 +32 +9 +31696 +31697 +31698 +31699 +10356 +2 +76 +2476 +2577 +249 +1208 +3104 +22075 +1423 +3470 +31700 +349 +15483 +24864 +27681 +13566 +1157 +1765 +31701 +12267 +5344 +20058 +43 +17151 +31702 +21776 +23841 +30877 +32 +590 +1012 +8798 +1224 +345 +31703 +19618 +1011 +3739 +24896 +19618 +611 +12788 +24896 +9 +31704 +31705 +3335 +15504 +2990 +1716 +31706 +14363 +1208 +31707 +4026 +1090 +1090 +179 +1051 +770 +8263 +24896 +286 +30051 +22 +337 +31708 +5085 +31709 +31710 +17151 +31711 +31712 +31713 +1765 +31714 +28500 +31715 +9 +1212 +31716 +31717 +27719 +9 +24144 +3 +31718 +19618 +345 +43 +31719 +31720 +4 +31721 +31722 +24725 +29381 +5387 +28441 +43 +28317 +31723 +18951 +31724 +31725 +14369 +15718 +9 +57 +5007 +31726 +22098 +29381 +16377 +29483 +31727 +345 +19 +22986 +9 +31728 +2769 +24725 +31729 +4028 +27669 +17151 +590 +31730 +29381 +14363 +31731 +24371 +590 +43 +2286 +286 +31732 +19852 +222 +24303 +11321 +590 +1115 +14330 +8967 +533 +17749 +2019 +14 +31733 +3546 +14477 +2 +30655 +20952 +590 +21947 +20792 +30877 +31734 +18951 +25683 +31735 +1514 +31736 +31737 +43 +31738 +14369 +30580 +31739 +6627 +31740 +43 +21947 +31741 +31742 +31743 +2976 +25943 +31744 +104 +19 +31745 +31746 +31747 +31748 +18695 +4124 +31749 +31750 +31751 +31752 +31753 +30877 +22963 +43 +18568 +31754 +31755 +25164 +2064 +1316 +15448 +14477 +13325 +43 +21947 +12987 +29463 +21947 +31756 +31757 +17151 +590 +30877 +9194 +19 +31758 +272 +5601 +31759 +3055 +30877 +42 +31760 +2694 +402 +3546 +30877 +31761 +14363 +31762 +590 +31763 +861 +15989 +554 +31764 +31765 +1224 +31766 +910 +9 +17920 +8668 +155 +31767 +554 +19585 +31768 +26496 +31293 +3406 +31769 +31770 +31293 +31771 +31772 +26779 +27110 +31773 +43 +272 +27279 +9 +379 +164 +19618 +272 +31774 +24864 +861 +566 +590 +31775 +31776 +2764 +8037 +14477 +751 +4028 +349 +23103 +3 +30851 +29483 +31777 +31778 +31779 +5085 +20517 +57 +20785 +31780 +10580 +179 +1100 +24045 +6499 +5438 +31781 +15718 +31782 +29483 +31293 +26744 +16966 +31783 +31784 +970 +31785 +31786 +31787 +770 +24864 +31788 +13721 +19404 +43 +31789 +31790 +31791 +25991 +10 +28441 +31792 +4805 +15481 +43 +31793 +24765 +26361 +31794 +19585 +8249 +3999 +590 +29381 +597 +21947 +31795 +31796 +1090 +31797 +3790 +15183 +23368 +14832 +25140 +31798 +28295 +1870 +31799 +4128 +31800 +25584 +26724 +1382 +738 +196 +31801 +43 +5415 +21947 +27069 +31802 +19 +31803 +31804 +31805 +25140 +31806 +379 +31807 +43 +27669 +1514 +242 +31808 +31809 +3764 +31810 +31811 +31812 +29799 +27069 +29951 +31813 +2260 +31814 +7357 +1356 +19618 +23103 +31815 +31816 +26011 +795 +1465 +21261 +10139 +31817 +31818 +104 +57 +14363 +31819 +31820 +29483 +29289 +21947 +1208 +27069 +1612 +43 +26040 +31821 +27448 +31822 +66 +31823 +29381 +31824 +5908 +21947 +703 +31720 +31825 +138 +4550 +402 +338 +31826 +14 +19655 +31827 +3061 +590 +1262 +484 +28441 +31828 +29849 +13848 +25140 +179 +345 +31829 +4793 +24045 +590 +1961 +21947 +4244 +29483 +10038 +28317 +31830 +3546 +31831 +30224 +27719 +8110 +31832 +8255 +25683 +590 +31833 +19868 +43 +2260 +14477 +19 +31834 +284 +28317 +31835 +9 +2764 +31836 +24896 +9 +31837 +43 +3301 +4468 +29483 +7137 +31838 +31839 +29381 +43 +24951 +31840 +282 +13721 +31841 +31842 +1942 +21095 +1559 +31843 +31844 +21947 +31845 +1562 +4855 +8675 +31846 +1513 +31847 +28000 +284 +14330 +1524 +31848 +43 +31849 +31850 +31851 +3546 +21776 +5629 +284 +14947 +17112 +31852 +1384 +286 +104 +707 +19 +26680 +20700 +21947 +176 +26680 +66 +25237 +31853 +31854 +29628 +31855 +31856 +31857 +13721 +31858 +248 +286 +43 +31859 +576 +16618 +590 +1090 +10717 +16205 +3417 +10578 +5022 +590 +5976 +19618 +8950 +31860 +31861 +25140 +25683 +31862 +31863 +1563 +303 +31864 +4441 +3095 +2314 +18920 +31865 +713 +31866 +13848 +9 +25237 +57 +9 +31867 +31868 +16391 +11762 +16437 +495 +303 +29381 +5085 +337 +19404 +31869 +31870 +1136 +43 +31871 +31872 +6518 +31873 +31874 +29200 +31875 +5627 +31876 +19618 +31877 +31878 +24458 +788 +31879 +5188 +24253 +5119 +7053 +31880 +23103 +31881 +31882 +373 +720 +540 +31883 +31884 +27159 +1907 +31885 +237 +13307 +31886 +24896 +3353 +31887 +597 +3546 +31888 +1224 +31889 +2733 +303 +31890 +248 +595 +31891 +284 +4441 +9707 +66 +21947 +20340 +12159 +31892 +31893 +196 +9351 +31894 +31895 +27798 +23103 +31896 +21947 +17151 +30260 +3044 +31897 +57 +31898 +31899 +31900 +31901 +43 +9 +29483 +31902 +25140 +31903 +970 +31904 +26706 +19918 +89 +43 +4055 +9 +31905 +303 +31906 +20058 +29483 +9 +27843 +53 +31907 +31908 +5852 +25140 +14001 +31909 +2577 +1524 +28804 +31910 +31911 +411 +32 +5614 +31912 +14947 +12573 +30143 +31913 +31914 +2550 +31915 +155 +30650 +791 +15718 +14330 +31916 +31917 +9 +31918 +15428 +31919 +31920 +21947 +31921 +29483 +25237 +4717 +42 +21207 +29483 +31922 +3546 +24026 +13848 +14330 +31923 +337 +31924 +8367 +21947 +31925 +14898 +29770 +26738 +31926 +179 +20616 +31927 +31928 +31929 +5188 +31930 +29381 +31931 +31932 +31933 +1113 +15629 +21947 +31934 +31935 +286 +716 +31936 +31937 +24144 +554 +31938 +31939 +20616 +323 +31940 +1716 +379 +15541 +970 +29381 +31941 +31942 +31943 +31944 +21689 +18394 +8263 +31945 +25159 +29381 +31946 +86 +57 +15718 +31293 +31947 +31948 +31949 +31950 +25659 +31951 +1083 +21776 +31952 +29381 +29483 +13721 +31953 +15718 +9 +27719 +29381 +31954 +9501 +189 +536 +30347 +30209 +29434 +31955 +31956 +31957 +31958 +31959 +31960 +861 +31961 +31962 +590 +11056 +736 +31963 +573 +24063 +31964 +31965 +21947 +213 +209 +31966 +345 +27069 +5083 +3546 +31967 +31968 +31168 +31969 +31970 +8030 +31971 +31972 +21889 +24864 +43 +31973 +31974 +28317 +15718 +31975 +352 +15718 +169 +576 +31976 +31977 +892 +20871 +31293 +31978 +4820 +3745 +14330 +412 +26136 +31168 +21394 +31979 +12956 +28317 +28317 +970 +31980 +31981 +12166 +12907 +14532 +4441 +19939 +31098 +1249 +43 +14369 +31982 +31983 +31984 +31985 +31986 +15718 +18503 +31987 +24896 +5614 +23103 +683 +31988 +31989 +25053 +339 +31990 +31991 +3317 +31992 +31993 +31994 +16205 +31995 +31996 +31997 +345 +31998 +597 +31999 +32000 +9 +19091 +24907 +30877 +32001 +9688 +32002 +25659 +60 +32003 +1224 +6873 +32004 +9 +1823 +5865 +18503 +3546 +32005 +12987 +464 +32006 +32007 +9048 +4 +1615 +32008 +21947 +1090 +30877 +32009 +32010 +138 +32011 +1314 +32008 +1437 +6557 +32012 +32013 +32014 +2136 +32015 +22420 +6171 +22411 +32016 +32017 +32018 +32019 +29798 +13721 +21031 +21947 +1356 +32020 +21947 +32021 +32022 +29381 +32023 +7987 +6382 +317 +21947 +21947 +7977 +1300 +31293 +23111 +32024 +43 +21947 +13484 +590 +32025 +32026 +32027 +32028 +14604 +21504 +32029 +696 +5297 +6595 +14477 +32030 +32031 +32032 +25140 +21863 +25584 +18045 +24896 +32033 +15718 +32034 +3908 +12202 +19 +1112 +1920 +18695 +32035 +19 +43 +21947 +32036 +16571 +7619 +32037 +25584 +1382 +2243 +1444 +32038 +32039 +32040 +16413 +32041 +31603 +43 +331 +31293 +9 +9560 +720 +14369 +915 +32042 +32043 +32044 +32045 +32046 +32047 +791 +32048 +32049 +1332 +32050 +31860 +345 +178 +32051 +14369 +2700 +32052 +32053 +12400 +21698 +32054 +9410 +16 +2697 +25683 +32055 +590 +209 +32056 +1249 +2243 +17151 +16437 +19 +3626 +1226 +32057 +32058 +8297 +32059 +248 +27669 +32060 +13721 +2302 +32061 +32062 +66 +30877 +32063 +32064 +32065 +1442 +213 +19091 +78 +30877 +28317 +1320 +32066 +30224 +32067 +303 +32068 +590 +21947 +28549 +29836 +32069 +32070 +32071 +345 +32072 +2591 +24864 +9 +32073 +338 +22963 +3353 +28317 +32074 +284 +19 +6732 +12798 +1425 +2314 +26724 +6072 +21947 +18792 +337 +30877 +15718 +32075 +590 +745 +32076 +915 +32077 +32078 +32079 +28317 +28549 +14330 +1234 +32080 +32081 +1295 +5188 +32082 +5780 +213 +25683 +14870 +13765 +865 +9160 +38 +32083 +32084 +18112 +10482 +213 +31293 +590 +9 +4441 +4278 +30260 +43 +14000 +32085 +2919 +699 +32086 +713 +32087 +29109 +201 +32088 +32089 +970 +32090 +751 +29483 +32091 +21947 +5791 +30224 +5627 +29387 +303 +29483 +32092 +19 +32093 +43 +3044 +32094 +303 +32095 +15718 +32096 +19009 +32097 +232 +2941 +28549 +32098 +32099 +25683 +14 +15718 +32100 +32101 +32102 +286 +66 +13897 +32103 +32104 +32105 +23706 +5188 +736 +13296 +32106 +32107 +13781 +24864 +32108 +18234 +10500 +1907 +32109 +14369 +20871 +9 +32110 +284 +2577 +590 +201 +109 +590 +32111 +16 +23547 +284 +32112 +25683 +32113 +541 +32114 +25683 +20514 +32115 +32116 +32117 +1454 +32118 +2155 +564 +32119 +30877 +1103 +30877 +4606 +337 +30877 +17151 +536 +9 +26744 +30877 +32120 +27178 +8460 +32121 +32122 +29981 +1226 +138 +590 +7835 +32123 +29483 +21947 +32124 +22 +686 +15718 +21377 +4388 +1018 +31293 +32125 +3546 +32126 +32127 +32128 +20 +590 +28522 +32129 +6122 +32130 +32131 +13279 +5908 +32132 +16121 +233 +32133 +32134 +970 +1384 +138 +17809 +28753 +14660 +30224 +1100 +32135 +32136 +32137 +6110 +32138 +27669 +32139 +19 +3 +29381 +1090 +3546 +9 +6095 +4954 +32140 +32141 +77 +2043 +1838 +491 +2525 +590 +272 +20232 +26736 +13594 +12097 +32142 +3875 +16511 +32143 +5344 +2577 +18503 +756 +16437 +32144 +14330 +1920 +9705 +1444 +32145 +32146 +1637 +29956 +31168 +9 +15481 +32147 +29483 +13260 +32148 +9 +27849 +32149 +14330 +2415 +29483 +21947 +10583 +24725 +10262 +1047 +3994 +32150 +11452 +32151 +31168 +736 +25237 +536 +23519 +25943 +15594 +32152 +32153 +345 +5893 +12005 +970 +21947 +12387 +32154 +357 +14947 +6086 +32155 +18346 +9 +18200 +17151 +26040 +5627 +31364 +24303 +15382 +18307 +1082 +25237 +1090 +3480 +32156 +9 +32157 +32158 +22986 +32159 +32160 +29381 +13675 +671 +29032 +32161 +32162 +21947 +32163 +32164 +11808 +3546 +32165 +32166 +7835 +29200 +32167 +32168 +411 +349 +24303 +19 +29 +32169 +19 +20 +112 +29381 +28490 +590 +32170 +32171 +19 +15804 +25140 +1018 +32172 +32173 +15718 +10933 +4403 +32174 +29661 +32175 +32176 +19618 +18045 +29381 +32177 +32178 +29200 +32179 +3548 +970 +30224 +43 +25140 +1335 +17670 +32180 +32181 +677 +7137 +32182 +30515 +21947 +32183 +13648 +31293 +32184 +115 +22960 +3484 +24332 +32185 +3059 +32186 +514 +18265 +936 +9 +32187 +32188 +1502 +89 +32189 +32190 +32191 +32192 +32193 +15 +31493 +25140 +21947 +3635 +21947 +7855 +20 +14369 +2673 +15167 +3470 +29483 +590 +4055 +22963 +9548 +32194 +32195 +32196 +7855 +24339 +10348 +32197 +1112 +32198 +25683 +25 +32199 +32200 +32201 +30051 +15 +32202 +32203 +15 +576 +32204 +32205 +1508 +5085 +14369 +20315 +21112 +24725 +32206 +32207 +15718 +13721 +32208 +19218 +3546 +32209 +21947 +32210 +32211 +7053 +9402 +554 +19238 +32212 +13721 +32213 +274 +9 +32214 +32215 +32216 +14563 +21947 +10 +24864 +32217 +915 +17144 +28549 +15497 +1824 +32218 +6302 +32219 +16839 +5097 +27669 +6294 +32220 +19624 +32221 +1012 +8188 +1870 +32222 +29483 +28549 +18048 +286 +32223 +30051 +22922 +32224 +32225 +32226 +31053 +29381 +1051 +32227 +32228 +26060 +32229 +59 +32230 +13474 +25778 +15 +29483 +42 +377 +19974 +7746 +32231 +32232 +32233 +590 +5780 +32234 +25683 +3050 +43 +32235 +3543 +32236 +32237 +32238 +7835 +29483 +14604 +3759 +24303 +1332 +32239 +5204 +590 +32240 +23507 +32241 +32242 +32243 +2733 +3081 +15718 +32244 +30577 +32245 +32246 +14120 +32247 +32248 +24725 +32249 +15718 +14477 +23226 +10818 +32250 +29483 +32251 +32252 +4684 +43 +29483 +32253 +32254 +3421 +32255 +1356 +32256 +3119 +32257 +32258 +26361 +32259 +57 +32260 +27798 +3484 +590 +32261 +32262 +31293 +3553 +32263 +590 +32264 +25140 +32265 +21698 +11702 +323 +27669 +28317 +4196 +1727 +1743 +237 +1927 +30877 +26355 +5188 +32266 +30877 +357 +892 +32267 +32268 +10 +32269 +32270 +32271 +3543 +32272 +8036 +32273 +17151 +349 +32274 +32275 +32276 +8668 +665 +14 +155 +3030 +4055 +32277 +29984 +19 +3484 +15245 +32278 +31225 +15718 +1720 +32279 +28549 +1012 +32280 +12479 +19995 +32281 +32282 +323 +32283 +24303 +27918 +30877 +27669 +24907 +14330 +26952 +11286 +32284 +32285 +10 +32286 +32287 +14369 +27260 +4550 +24050 +21371 +99 +30877 +1992 +26119 +1458 +32288 +32289 +89 +249 +6741 +32290 +1562 +32291 +155 +32292 +32293 +43 +4242 +25943 +32294 +14369 +32295 +32296 +39 +971 +590 +1090 +3995 +30051 +32297 +32298 +32299 +1208 +10791 +32300 +3635 +15356 +27669 +32301 +2562 +32302 +32303 +265 +32304 +357 +3546 +32305 +32306 +32307 +9 +720 +5601 +27260 +1437 +29007 +32308 +32309 +31293 +1090 +32310 +5627 +32311 +10869 +9139 +9573 +32312 +25943 +3406 +1817 +30877 +14369 +9210 +32313 +32314 +32315 +32316 +4820 +25659 +16102 +32317 +5577 +32318 +28549 +19927 +590 +11027 +32319 +1612 +32320 +32321 +32322 +5764 +21947 +22793 +20315 +1531 +9900 +13457 +32323 +32324 +27669 +1090 +14363 +4245 +1044 +32325 +279 +11995 +176 +32326 +16763 +5908 +32327 +13566 +9 +379 +43 +6217 +32 +32328 +970 +14648 +32329 +8188 +25140 +32330 +349 +13129 +32331 +13405 +6086 +25829 +1502 +32332 +9 +448 +19618 +1716 +18695 +23603 +32333 +32334 +20185 +24896 +30877 +1790 +8668 +32335 +19 +14343 +14477 +67 +6620 +573 +32336 +32337 +9 +32338 +32339 +24864 +32275 +32340 +32341 +32342 +1352 +9396 +25683 +1090 +2064 +2832 +19 +9 +24864 +24253 +11762 +249 +1011 +89 +20599 +32343 +28549 +25140 +28490 +31293 +286 +590 +3546 +43 +28317 +31293 +89 +323 +32344 +43 +15 +32345 +32346 +15914 +29483 +19618 +32347 +32348 +32349 +25237 +32350 +32351 +6116 +18982 +1208 +32352 +28549 +23103 +2806 +25683 +17082 +32353 +27669 +18914 +32354 +29483 +2243 +32355 +32356 +32357 +32358 +2 +4230 +28441 +5780 +272 +210 +2410 +32359 +32360 +32361 +27669 +4765 +30224 +31691 +43 +15 +32362 +32363 +32364 +590 +13848 +26047 +32365 +3546 +32366 +25237 +32367 +15481 +32368 +26060 +32369 +13150 +32370 +7208 +1047 +32371 +1356 +4055 +32372 +32373 +32374 +30551 +3546 +19 +16437 +32375 +6441 +1710 +2035 +720 +4436 +30388 +32376 +32377 +29956 +27669 +1503 +23103 +32378 +32379 +222 +25659 +32380 +24303 +15398 +648 +3604 +671 +29047 +32381 +30580 +6072 +3546 +14330 +32382 +33 +18695 +819 +4651 +19 +43 +32383 +32384 +43 +30877 +29483 +32385 +29483 +32386 +32387 +1090 +1245 +25624 +21090 +1817 +32388 +32389 +14604 +27719 +927 +32390 +15718 +30877 +32391 +32392 +32393 +32394 +19 +32395 +32396 +14 +1559 +27669 +32397 +29032 +8905 +9 +4055 +32398 +736 +32399 +32400 +2427 +31637 +19 +27669 +32401 +32402 +32403 +32404 +32405 +25683 +2029 +32406 +31293 +32407 +4055 +4055 +43 +416 +24725 +201 +32408 +344 +24303 +14001 +3376 +32409 +103 +32410 +9 +32411 +176 +7014 +43 +32412 +32413 +5773 +32414 +14647 +104 +10727 +43 +21689 +32415 +29483 +17402 +21947 +32416 +32417 +9 +5188 +43 +32418 +31098 +31637 +25683 +3480 +24403 +2093 +28549 +32419 +590 +9 +27669 +26496 +32420 +3546 +32421 +22963 +32422 +32423 +32424 +32425 +32426 +24864 +4028 +286 +18429 +3994 +14369 +14330 +32427 +43 +18045 +3546 +31668 +21576 +11056 +26744 +3857 +4682 +31434 +849 +32428 +2009 +27069 +4055 +26496 +21947 +15765 +31637 +25683 +533 +32429 +31637 +32430 +24154 +586 +32431 +5326 +29381 +15 +1198 +32432 +28000 +32433 +1812 +32434 +32435 +6122 +30877 +1688 +32436 +25140 +13430 +32437 +32438 +27669 +32439 +32440 +7137 +1090 +345 +32441 +32442 +2944 +32443 +138 +32444 +15 +32445 +228 +32446 +28901 +23103 +13721 +3546 +32447 +28317 +22236 +32448 +14424 +32449 +32450 +32451 +32452 +2 +11762 +15342 +3553 +32453 +24303 +12053 +32454 +3994 +2259 +92 +9 +32455 +29799 +27069 +9497 +21947 +27669 +32456 +5188 +32 +32457 +13317 +25237 +590 +31995 +4055 +4547 +4023 +7855 +14477 +14 +1310 +9 +32458 +32459 +323 +12987 +6341 +30877 +25316 +1425 +32460 +23103 +13829 +910 +32461 +32462 +32463 +10280 +21776 +32464 +15018 +7253 +25683 +43 +32465 +3239 +32466 +32467 +1961 +23103 +32468 +32469 +32470 +18695 +379 +32471 +32472 +32473 +6968 +25237 +6621 +32474 +272 +30877 +32475 +11930 +970 +12340 +1596 +1812 +26496 +32476 +13943 +29483 +8849 +32477 +23216 +32478 +32479 +7694 +671 +9 +4765 +14603 +1316 +1615 +31293 +25237 +32480 +32481 +533 +2944 +8465 +32482 +4387 +32483 +30224 +32484 +9 +12916 +32485 +32486 +2035 +590 +32487 +26361 +10 +32488 +32489 +4242 +32490 +201 +32491 +30877 +1524 +590 +32492 +24919 +32493 +178 +8188 +21947 +25683 +19 +18364 +32494 +16437 +32495 +32496 +590 +32497 +32498 +53 +26361 +3546 +29381 +32499 +14909 +9 +358 +28317 +32500 +32501 +3666 +30877 +29204 +32360 +30877 +24864 +32502 +43 +7900 +2764 +12304 +4055 +32503 +21947 +30309 +32504 +3553 +32505 +590 +32506 +3559 +32507 +28665 +32 +8721 +10601 +14369 +21947 +3416 +28301 +18568 +9 +32508 +1961 +32509 +9259 +32510 +2692 +32511 +32512 +519 +7855 +595 +32513 +17082 +9 +4441 +155 +14330 +3546 +32514 +9705 +10 +2101 +25237 +7835 +284 +21947 +2550 +19618 +32515 +32516 +43 +3067 +11482 +32517 +25140 +1559 +32518 +23688 +1316 +32519 +1011 +2577 +1517 +20 +32520 +32521 +3119 +20952 +32522 +8465 +32523 +32524 +29200 +370 +1562 +32525 +1382 +30877 +32526 +5393 +9 +14001 +397 +9 +32527 +3546 +32528 +31293 +32529 +25683 +2769 +24864 +491 +31293 +3242 +32530 +30516 +32531 +583 +9 +13721 +5022 +14330 +14369 +303 +286 +29503 +213 +25943 +25683 +12304 +32532 +32533 +284 +32534 +32535 +32536 +971 +32537 +6595 +11273 +284 +15758 +213 +32538 +1244 +32539 +5806 +32540 +671 +4055 +29483 +248 +43 +14369 +284 +27669 +554 +32541 +1090 +18763 +1090 +25683 +9 +29822 +14330 +13317 +284 +32542 +1539 +32 +349 +32543 +32544 +2457 +28644 +19347 +3544 +32545 +31293 +21957 +14477 +17151 +14330 +213 +32546 +32547 +32449 +3601 +32548 +11762 +96 +3381 +32549 +6496 +19655 +12916 +533 +2410 +5125 +19 +1090 +14855 +23103 +3553 +32550 +32551 +27378 +286 +337 +17767 +32552 +248 +32553 +32554 +32555 +57 +32556 +1529 +32557 +155 +32558 +26020 +14369 +43 +25140 +32559 +30877 +32560 +104 +32561 +188 +32562 +19618 +1112 +30877 +28317 +30051 +7053 +9 +14 +32563 +29434 +14887 +337 +27514 +25584 +21031 +26744 +32564 +1224 +32565 +14369 +32566 +32567 +1168 +5780 +43 +32568 +32569 +15718 +27669 +32570 +32571 +9 +1090 +19 +19646 +21536 +32572 +12907 +21089 +3994 +352 +29381 +15240 +25584 +21947 +32573 +29679 +19655 +32574 +536 +213 +8540 +23103 +1415 +32575 +32576 +4055 +1090 +19478 +14856 +4055 +32577 +6571 +27669 +32 +30051 +337 +32578 +32579 +32580 +25237 +89 +32581 +5085 +15824 +213 +2649 +32582 +32583 +14 +32584 +14369 +303 +3330 +32585 +19655 +17635 +32586 +4055 +12 +12907 +77 +10748 +590 +30877 +3908 +14 +21947 +365 +141 +286 +24303 +31293 +32587 +9863 +32588 +1637 +19335 +32589 +178 +32590 +32591 +32592 +32593 +36 +25683 +19 +6171 +6656 +30877 +30224 +32594 +32595 +22989 +20666 +32596 +99 +738 +9 +5299 +32 +19 +21947 +30877 +31293 +21947 +32597 +32598 +14369 +32599 +2733 +32600 +32601 +2577 +27427 +2787 +20339 +18684 +14947 +1517 +32602 +4055 +10 +32603 +4463 +176 +32604 +32605 +43 +9 +27069 +25683 +1301 +15235 +43 +24303 +30877 +32606 +639 +1051 +971 +9497 +1870 +25237 +3484 +9 +32607 +32608 +32609 +29628 +1013 +32610 +13528 +9445 +32611 +5650 +25868 +32612 +3959 +17151 +2035 +32613 +32614 +9 +2694 +32615 +24628 +27096 +32616 +21835 +14477 +32617 +12095 +29381 +1100 +22 +30854 +6095 +32618 +13956 +3128 +42 +15331 +32619 +14947 +13875 +31293 +3610 +32620 +10482 +32621 +222 +665 +32622 +28317 +3978 +22 +9 +31733 +32623 +24423 +32624 +484 +8188 +32625 +3976 +32626 +32627 +1364 +15897 +32628 +373 +32629 +32630 +21947 +4944 +1870 +26496 +32631 +32632 +31098 +30877 +14369 +29483 +17151 +13961 +17670 +849 +32 +8015 +11873 +28494 +3994 +1524 +24862 +829 +32633 +32634 +32635 +32636 +248 +15718 +694 +26787 +32637 +32638 +15845 +32639 +32640 +32641 +19618 +32642 +31637 +2694 +5662 +32643 +15718 +2314 +13721 +286 +11341 +22986 +24303 +415 +2733 +25683 +23037 +32644 +25 +554 +31637 +32645 +32646 +43 +32647 +1524 +14369 +32648 +32649 +248 +32650 +32651 +32652 +14066 +21947 +14869 +616 +32653 +25140 +8150 +29483 +15718 +32654 +32655 +24743 +32656 +32657 +20600 +32658 +29275 +32659 +1066 +22621 +32660 +704 +32661 +32662 +22455 +30170 +5614 +15510 +32663 +30224 +9894 +32664 +32665 +3743 +590 +32666 +284 +32667 +32668 +32669 +13012 +25683 +32670 +9254 +27069 +3553 +1090 +3743 +9784 +25683 +24303 +32671 +32672 +32673 +32674 +554 +3746 +1090 +9 +32675 +32676 +32677 +32261 +21947 +590 +32678 +19489 +32679 +250 +1090 +29200 +134 +1082 +971 +32680 +5212 +32681 +19 +25683 +19618 +32682 +32683 +29483 +32684 +9 +30458 +2132 +736 +26361 +32685 +4278 +19 +193 +32686 +43 +14363 +16656 +21689 +32687 +32688 +14330 +11762 +21031 +32689 +32690 +2764 +2035 +32691 +32692 +14485 +971 +53 +32693 +32694 +11907 +14330 +3546 +2136 +32695 +32696 +31234 +416 +32697 +14660 +10775 +7960 +32698 +17064 +32699 +6877 +17951 +32700 +822 +10880 +32701 +5801 +32702 +32703 +5188 +32704 +32705 +20952 +5204 +26328 +32706 +19478 +2668 +27669 +32707 +32708 +20551 +28845 +590 +32709 +24154 +1131 +10789 +284 +25960 +29204 +21947 +32710 +24952 +21947 +196 +1808 +4441 +15537 +46 +15718 +32711 +32712 +379 +32713 +32714 +15493 +21753 +32715 +43 +19 +1153 +104 +32716 +32717 +32718 +590 +32719 +22901 +373 +29032 +32720 +32721 +32722 +32723 +15718 +2865 +25364 +30877 +31293 +21947 +1513 +32724 +7855 +32725 +15718 +32726 +17058 +24303 +28441 +32727 +29986 +32728 +32729 +590 +32730 +6190 +303 +30877 +9 +32731 +32732 +15370 +16640 +21947 +32733 +32734 +23103 +32563 +9 +15 +14000 +303 +32735 +32736 +99 +29483 +16571 +32737 +28961 +12401 +29483 +32738 +25991 +24464 +17897 +20617 +32739 +2 +16102 +23103 +32740 +201 +32741 +20512 +29483 +21947 +21947 +32742 +32743 +22922 +32744 +3546 +29483 +19 +32745 +12236 +32746 +259 +26496 +29483 +32747 +31293 +32748 +5438 +32749 +590 +32750 +9573 +155 +15718 +32751 +29483 +1090 +14330 +30051 +22922 +5188 +6161 +15 +29200 +13721 +10642 +32752 +36 +32753 +213 +19797 +31293 +317 +989 +31042 +14369 +1710 +1765 +104 +32754 +21947 +9928 +17136 +44 +31098 +32755 +32756 +28036 +30650 +32757 +1109 +32758 +7291 +32759 +2318 +1316 +32760 +17151 +20 +32761 +14814 +32762 +32763 +398 +30224 +32764 +6086 +32765 +32766 +32767 +24435 +4195 +14369 +14771 +303 +1090 +27669 +29483 +32768 +9 +31098 +20942 +4055 +21947 +213 +1090 +2019 +19618 +43 +1051 +573 +5085 +32769 +5067 +541 +32770 +303 +411 +43 +30877 +32771 +32772 +28219 +1300 +32773 +26496 +32774 +31293 +32775 +43 +24615 +32776 +3546 +32777 +213 +1774 +971 +3 +213 +303 +19 +24864 +648 +30853 +971 +616 +30551 +32778 +29007 +32779 +32780 +20645 +1382 +26626 +19618 +178 +9 +24864 +15718 +28845 +8210 +32781 +20952 +1234 +32782 +2132 +484 +12871 +249 +3546 +5925 +32783 +32784 +2836 +32785 +24303 +31406 +32786 +13721 +377 +32787 +284 +14477 +32788 +32789 +32790 +7276 +5827 +32791 +533 +5694 +2239 +32792 +32793 +20276 +25140 +2260 +19 +14369 +872 +14477 +358 +22 +32794 +32795 +32796 +32797 +43 +32798 +43 +14 +209 +32799 +32800 +32801 +14001 +28317 +43 +66 +613 +21689 +21947 +8849 +15536 +31293 +32802 +42 +32803 +317 +32804 +32805 +32806 +3546 +13721 +32807 +23913 +20984 +32808 +32809 +4764 +21947 +32810 +14871 +32811 +32812 +1617 +1012 +30458 +10470 +32813 +32814 +14477 +23103 +30877 +5780 +32815 +32816 +25943 +29483 +8386 +29483 +32817 +2406 +32818 +31896 +32819 +32820 +3757 +15718 +11811 +32821 +270 +32822 +14477 +8188 +11762 +795 +29483 +17151 +25943 +32823 +1021 +1090 +13375 +1224 +19 +2832 +32523 +1217 +32824 +3601 +32825 +14369 +18969 +14 +29840 +21947 +14025 +19 +32826 +19 +24864 +32827 +32828 +14369 +32829 +32830 +19618 +24807 +32831 +29651 +9 +32832 +46 +590 +19618 +1090 +32833 +2117 +43 +18469 +32834 +32835 +3353 +32836 +32837 +32838 +5169 +349 +15 +155 +4747 +32839 +32840 +32841 +2560 +32842 +32843 +566 +32844 +57 +27767 +32845 +32846 +20719 +14369 +12987 +32847 +13652 +2243 +19 +590 +32848 +43 +12579 +32849 +10245 +32850 +196 +15810 +1382 +3546 +32851 +32852 +9 +155 +19 +32853 +32854 +32855 +32856 +573 +104 +2459 +358 +104 +32857 +29170 +32858 +284 +190 +566 +6994 +6499 +32859 +32860 +21947 +19 +32861 +3251 +2314 +25683 +25943 +9160 +27798 +32862 +57 +9 +872 +13897 +188 +24864 +8668 +17083 +1090 +491 +24864 +32863 +7119 +2427 +32864 +32636 +1018 +32865 +32866 +32867 +2721 +1853 +590 +32868 +14869 +25237 +32869 +32870 +14330 +209 +32871 +32872 +14477 +31293 +32873 +701 +19478 +32874 +32875 +2 +882 +4055 +24864 +29200 +4055 +30877 +32876 +18503 +21031 +32877 +590 +13963 +28893 +32878 +42 +720 +32879 +32880 +5601 +26992 +32881 +28317 +32882 +6877 +16437 +32883 +23603 +1655 +1437 +32884 +32885 +1091 +1520 +32886 +32887 +4775 +10111 +32888 +30224 +9 +32889 +23103 +32890 +29204 +25943 +27619 +279 +21947 +10450 +32891 +25140 +22963 +16584 +397 +12987 +32892 +32893 +20 +694 +2804 +32894 +32895 +43 +32896 +19 +1318 +31293 +17716 +14330 +32897 +32 +31293 +1559 +25140 +19618 +32898 +9 +3491 +25530 +32899 +32900 +31293 +3599 +32901 +2577 +43 +3546 +32902 +32903 +590 +14369 +448 +24725 +32904 +23785 +32905 +32906 +13721 +4055 +11321 +32907 +29381 +354 +12013 +24725 +43 +32908 +14369 +24961 +32909 +32910 +32911 +32912 +19618 +32913 +436 +6528 +3484 +20617 +2832 +27669 +14477 +32914 +536 +683 +13721 +178 +590 +720 +32915 +32916 +32917 +32918 +32919 +89 +32920 +15718 +14330 +21689 +7014 +1823 +30051 +29381 +26484 +89 +32921 +1604 +32922 +1262 +20096 +1817 +21947 +32923 +14 +1698 +32924 +32925 +1838 +14330 +9 +19582 +32926 +9713 +573 +1615 +595 +13129 +32927 +7137 +32 +13721 +936 +23103 +3546 +25316 +32928 +32929 +887 +32930 +29 +27748 +24725 +27599 +9 +19618 +43 +32931 +32642 +32932 +7835 +32933 +32934 +32935 +694 +2132 +16437 +6161 +32936 +3317 +32937 +1082 +32938 +15356 +19858 +25140 +32939 +32940 +22473 +10 +32941 +16527 +3546 +590 +32942 +188 +15975 +491 +32943 +26161 +27708 +1090 +24775 +32944 +14 +32945 +32946 +6110 +32386 +3231 +19318 +21689 +32449 +32947 +30224 +32948 +188 +32949 +32950 +9125 +32951 +345 +32952 +32953 +32954 +32955 +237 +31293 +19 +32956 +19618 +2971 +15718 +32957 +17151 +3599 +5659 +7835 +32958 +43 +32959 +1154 +14477 +4856 +32960 +7835 +30877 +28239 +11191 +14369 +32961 +31293 +11568 +32962 +872 +21835 +32963 +17830 +27096 +30215 +32964 +32965 +32966 +32967 +32 +22307 +4547 +20941 +24303 +32968 +9 +10320 +7292 +8787 +3553 +827 +9 +21947 +3026 +32969 +32970 +29979 +32971 +12462 +32972 +32973 +9 +4550 +6764 +28549 +32974 +57 +2260 +24303 +32975 +32976 +2832 +15536 +32977 +20462 +3 +29381 +2953 +25237 +564 +32978 +32979 +7835 +32980 +31293 +27069 +1046 +1517 +436 +4487 +7835 +32261 +22552 +323 +32981 +1011 +4055 +598 +411 +1234 +32982 +788 +32983 +32984 +14147 +12063 +3553 +745 +32985 +32986 +1244 +32987 +274 +32988 +21947 +19852 +4550 +4055 +1051 +25584 +14330 +32989 +15535 +32990 +32991 +19 +14343 +286 +11321 +10792 +24045 +6939 +590 +32992 +32993 +21045 +1688 +1749 +32994 +23103 +14 +9 +971 +32995 +32996 +31168 +32997 +32998 +349 +43 +665 +32999 +1765 +33000 +25237 +31293 +1765 +2694 +272 +33001 +33002 +33003 +30835 +6612 +33004 +21165 +790 +9 +4918 +33005 +33006 +12956 +27669 +671 +1300 +827 +33007 +970 +33008 +33009 +10 +1090 +23103 +590 +33010 +3546 +33011 +9 +33012 +33013 +33014 +57 +16121 +153 +32 +24725 +33015 +270 +33016 +7053 +15 +25710 +33017 +33018 +33019 +33020 +9 +17412 +43 +33021 +33022 +24303 +9 +21834 +33023 +16391 +11762 +31098 +7137 +33024 +33025 +14369 +3546 +24698 +57 +33026 +30877 +33027 +33028 +1961 +4606 +19655 +1470 +2324 +13721 +30224 +970 +1090 +16437 +33029 +4055 +33030 +26158 +5627 +14 +5041 +33031 +104 +21689 +33032 +3272 +19 +18982 +7345 +590 +14369 +2 +24045 +3959 +33033 +18684 +24 +33034 +270 +21947 +33035 +1710 +1688 +30224 +33036 +349 +26152 +33037 +19618 +20842 +31293 +33038 +24523 +3353 +155 +590 +25943 +24303 +1716 +209 +18107 +29434 +1310 +14369 +17911 +33039 +23103 +3122 +13517 +590 +33040 +33041 +33042 +33043 +7835 +21947 +33044 +33045 +33046 +33047 +13265 +1377 +33048 +29483 +9 +18695 +590 +6423 +15718 +33049 +33050 +33051 +27818 +29483 +25683 +33052 +349 +33053 +7835 +21947 +14079 +33054 +671 +17119 +33055 +8137 +11 +2004 +16102 +33056 +25382 +14477 +60 +33057 +33058 +33059 +33060 +317 +2132 +590 +13977 +14477 +24725 +33061 +970 +9 +720 +24862 +33062 +3546 +16640 +33063 +33064 +317 +21947 +33065 +694 +4441 +1364 +33066 +19 +21577 +9 +33067 +33068 +19618 +23103 +6275 +31293 +1090 +33069 +7855 +33070 +33071 +153 +9688 +357 +17151 +33072 +23454 +770 +1364 +1674 +19618 +33073 +24864 +33074 +33075 +33076 +3407 +27719 +19 +3 +33077 +12055 +21947 +33078 +5877 +22 +4884 +33079 +3601 +21947 +33080 +30051 +33081 +590 +21245 +33082 +33083 +590 +11341 +33084 +29381 +33085 +33086 +28036 +7053 +1051 +25943 +23103 +33087 +17151 +25316 +33088 +7479 +12005 +2040 +22420 +6095 +30139 +33089 +30224 +1234 +43 +1090 +15 +33090 +1920 +33091 +20886 +270 +33092 +24144 +720 +1100 +14000 +3844 +11341 +164 +25237 +2132 +15517 +27816 +27719 +33093 +33094 +19655 +29381 +33095 +19655 +1559 +4041 +33096 +9688 +686 +249 +14369 +33097 +249 +15 +14588 +20 +32636 +15718 +9 +33098 +19318 +43 +15 +9649 +21689 +33099 +4367 +6122 +21947 +21947 +33100 +29720 +30877 +66 +33101 +5904 +16466 +29483 +43 +12005 +33102 +1090 +33103 +5188 +14666 +18695 +11762 +286 +33104 +43 +30877 +33105 +25140 +14330 +33106 +590 +14553 +33107 +3353 +1154 +33108 +29381 +43 +30877 +33109 +861 +711 +20 +345 +14 +5188 +23103 +1013 +33110 +849 +21874 +14369 +33111 +21968 +33112 +8961 +25140 +13897 +25683 +28441 +19 +24725 +4055 +33113 +24725 +13777 +29628 +155 +19 +13150 +7369 +377 +20383 +14001 +33114 +33115 +590 +8038 +3546 +33116 +590 +33117 +33118 +14942 +20507 +32 +1090 +24303 +33119 +8465 +33120 +2919 +32575 +15718 +33121 +31728 +15541 +33122 +33123 +33124 +1208 +703 +33125 +25140 +33126 +32386 +33127 +15 +354 +33128 +17215 +27954 +1090 +33129 +15 +2006 +164 +19 +33130 +25237 +43 +10990 +6054 +33131 +514 +270 +12281 +33132 +9 +3337 +19655 +43 +33133 +9 +30877 +6627 +21835 +12430 +26158 +11469 +29483 +21 +33134 +342 +22065 +1001 +378 +14477 +31293 +33135 +19 +19 +31225 +28745 +33136 +5662 +27276 +2733 +33137 +17139 +970 +33138 +33139 +33140 +12185 +33141 +14216 +23103 +2733 +1524 +1208 +15718 +5085 +7053 +33142 +14330 +14369 +14477 +33143 +33144 +32642 +14 +1316 +19624 +15718 +28317 +10531 +14369 +3546 +33145 +123 +2035 +4055 +27719 +15 +76 +1937 +1013 +22573 +15318 +33146 +2410 +24449 +33147 +9 +33148 +13045 +33149 +16437 +33150 +32 +25316 +33151 +19091 +25 +13528 +1083 +33152 +33153 +2694 +33154 +21003 +33155 +33156 +33157 +33158 +33159 +33160 +60 +33161 +1251 +33162 +30224 +3546 +33163 +13566 +33164 +4055 +33165 +14330 +2243 +24045 +17151 +3353 +24303 +33166 +1045 +12684 +33167 +33168 +1870 +25237 +590 +155 +33169 +970 +99 +33170 +15 +32919 +1181 +22703 +5080 +33171 +57 +4055 +31098 +179 +32410 +6914 +11321 +14330 +25382 +989 +7381 +33172 +33173 +33174 +20 +3994 +12120 +27669 +32787 +33175 +33176 +10364 +32254 +30710 +19618 +33177 +43 +33178 +9 +18695 +32813 +2832 +519 +20 +14477 +33179 +9 +17790 +33180 +586 +33181 +33182 +25140 +9245 +29483 +33183 +33184 +31293 +33185 +25237 +33186 +33187 +33188 +14 +590 +15718 +590 +33189 +30877 +33190 +9 +29204 +1181 +3981 +379 +2356 +13307 +20510 +33191 +270 +491 +11283 +4701 +33192 +352 +27669 +20 +3601 +165 +597 +33193 +6328 +33194 +33195 +1612 +33196 +33197 +38 +16437 +33198 +33199 +519 +25683 +31293 +28317 +31978 +33200 +12120 +28441 +15718 +26127 +28482 +19918 +1224 +491 +165 +33201 +33202 +14330 +4979 +237 +43 +23394 +33203 +21947 +9 +30209 +1332 +33204 +33205 +18798 +27874 +286 +33206 +13807 +31719 +17631 +9 +14604 +43 +9845 +1517 +22669 +33207 +8256 +28036 +25281 +590 +4055 +60 +16272 +30794 +16152 +15419 +57 +24303 +33208 +1090 +14330 +33209 +33210 +19618 +33211 +9 +1683 +5316 +21947 +16437 +33212 +33213 +57 +548 +33214 +25904 +4855 +33215 +1157 +33216 +15758 +345 +1224 +33217 +33218 +6275 +33219 +19 +30877 +1236 +28317 +4274 +33220 +18372 +33221 +21689 +533 +2919 +17687 +24303 +33222 +33223 +99 +21947 +9 +14369 +28242 +33224 +33225 +32919 +9 +24864 +3359 +33226 +9 +28295 +13857 +33227 +33228 +33229 +417 +25140 +14477 +33230 +554 +9144 +4055 +12325 +99 +33231 +1047 +6877 +33232 +24864 +21947 +33233 +9 +2161 +568 +33234 +970 +647 +26040 +22918 +11683 +8668 +33235 +1961 +43 +43 +21031 +11762 +3330 +33236 +33237 +18695 +4544 +21947 +8668 +33238 +33239 +15 +23103 +31042 +25943 +33240 +33241 +971 +17151 +8407 +33242 +25237 +23226 +26496 +33243 +33244 +32 +33245 +14369 +20514 +1382 +21187 +29483 +33246 +201 +1356 +6039 +873 +228 +31098 +15511 +4185 +2561 +33247 +21507 +33248 +33249 +33250 +1066 +33251 +33252 +33253 +349 +3030 +16437 +33254 +33255 +648 +33256 +425 +19 +12 +27798 +827 +33257 +8171 +11571 +66 +8297 +33258 +8249 +33259 +1765 +21947 +590 +33260 +9 +14369 +25943 +9 +33261 +57 +12005 +665 +43 +19 +28549 +20258 +22752 +33262 +30877 +4550 +3491 +33263 +33264 +15718 +29163 +33265 +5085 +14947 +39 +2117 +17848 +29 +4006 +33266 +349 +28317 +399 +683 +970 +13754 +4055 +2804 +33267 +32 +286 +33268 +33269 +8864 +15718 +33270 +162 +33271 +590 +19478 +33272 +21627 +33273 +21947 +4414 +3546 +33274 +8967 +33275 +17730 +29381 +249 +5904 +14477 +1234 +29956 +25140 +33276 +33277 +683 +15961 +33278 +379 +33279 +6294 +33280 +17151 +33281 +33282 +33283 +18695 +19730 +43 +33284 +29381 +19618 +1612 +32 +1688 +1425 +31520 +3994 +4055 +33285 +9396 +33286 +33287 +13566 +33288 +43 +17670 +43 +1089 +19 +3055 +33289 +9 +1300 +3075 +5792 +4634 +3973 +19 +8297 +558 +36 +25237 +1529 +33290 +115 +14947 +33291 +25237 +17602 +28317 +1222 +19153 +33292 +7532 +1100 +24864 +6294 +7014 +23770 +1559 +23742 +19 +1561 +671 +1612 +43 +2733 +33293 +12203 +33294 +19618 +25316 +28036 +17749 +519 +19 +33295 +141 +14477 +33120 +24725 +14330 +33296 +33297 +33298 +30877 +31293 +33299 +17911 +33300 +1870 +33301 +33302 +33303 +354 +33304 +1090 +10356 +19655 +33305 +6161 +33306 +22023 +4805 +33307 +39 +1454 +3546 +21689 +33308 +19 +33309 +30589 +21689 +19318 +2764 +33310 +3842 +33311 +33312 +33313 +33314 +33315 +33316 +13448 +9 +2009 +33317 +809 +33318 +2804 +9 +7053 +33319 +1090 +33155 +3908 +33320 +33321 +112 +33322 +11111 +30224 +33323 +541 +30551 +1157 +22884 +33324 +3546 +6505 +1090 +6035 +33325 +286 +33326 +33327 +1520 +33328 +27669 +873 +16066 +19344 +1107 +17698 +33329 +33330 +28317 +1021 +33331 +6258 +14477 +19 +33332 +586 +16371 +478 +33333 +27669 +33334 +24969 +15683 +53 +14369 +24303 +9 +33335 +2459 +33336 +33337 +1154 +14597 +9 +53 +4411 +19491 +33338 +43 +1716 +33339 +33340 +286 +30224 +27669 +33341 +33342 +33343 +17821 +10350 +33344 +33345 +2649 +2061 +33346 +29513 +9 +683 +33347 +33348 +33349 +33350 +33351 +17151 +9 +590 +33352 +33353 +25316 +872 +25683 +286 +590 +43 +21947 +14330 +33354 +33355 +24303 +33356 +26066 +30877 +25736 +6072 +14131 +3353 +26361 +9 +23103 +1224 +3553 +14378 +33357 +2600 +33358 +1018 +31293 +33359 +1384 +15720 +564 +33360 +31098 +147 +28036 +29381 +9 +20616 +11762 +33361 +1300 +6285 +33362 +30466 +33363 +13863 +28755 +1090 +33364 +33365 +14369 +4055 +33366 +18989 +25904 +345 +33367 +29483 +30224 +33368 +32 +3546 +541 +4414 +4961 +683 +21186 +32953 +33369 +4028 +22986 +33370 +33371 +33372 +14574 +21126 +111 +966 +14604 +2449 +9 +1364 +33373 +33374 +20514 +14001 +1738 +33375 +26142 +30224 +349 +33376 +33377 +33378 +1571 +2733 +33379 +2836 +15985 +12260 +33380 +14369 +30051 +33381 +11808 +24725 +17406 +33382 +19618 +33383 +9 +25683 +590 +213 +33384 +33385 +9963 +19 +33386 +28474 +57 +15740 +33387 +33388 +9144 +3416 +33389 +33390 +30051 +21947 +590 +14017 +1090 +2550 +19095 +6364 +248 +33391 +484 +720 +15 +33392 +33393 +188 +941 +33394 +33395 +33396 +33397 +3239 +33398 +7600 +33399 +33400 +4432 +28746 +33401 +5022 +303 +4028 +1684 +1415 +14477 +25316 +19 +5582 +32421 +165 +33402 +1562 +372 +12315 +33403 +33404 +242 +19545 +17217 +19 +2356 +1961 +19 +15718 +248 +358 +33405 +33406 +317 +19 +701 +9064 +970 +337 +33407 +33408 +16579 +14102 +2517 +33409 +209 +1437 +3546 +22099 +33410 +25316 +17277 +33411 +25237 +13721 +17872 +1765 +3067 +33412 +33413 +15654 +33414 +27178 +21947 +303 +43 +33415 +1090 +30224 +33416 +12 +15718 +33417 +32 +33418 +33419 +1090 +1217 +20374 +33420 +22114 +248 +970 +33421 +31168 +665 +21689 +46 +197 +3546 +3546 +5119 +33422 +33423 +16149 +27669 +15541 +533 +28036 +33424 +27748 +30747 +22922 +21426 +29716 +33120 +4824 +22063 +1021 +9 +213 +21947 +19 +14603 +33425 +33426 +29483 +197 +9 +155 +33427 +30949 +33428 +29483 +5780 +33429 +25237 +5634 +33430 +19 +33431 +33432 +2132 +33433 +33434 +33435 +9 +538 +648 +33436 +323 +30877 +33437 +2415 +3546 +1090 +33438 +33439 +284 +2132 +2197 +33440 +30650 +33441 +33442 +3546 +33368 +969 +33443 +33444 +29597 +29172 +20952 +2325 +12228 +33445 +6086 +43 +30877 +33446 +21947 +10617 +369 +2029 +15384 +33447 +12479 +33448 +33449 +33450 +33451 +29483 +2561 +4055 +2604 +3655 +12603 +1112 +19 +24896 +303 +23351 +317 +7053 +16515 +7786 +272 +446 +43 +33452 +33453 +15718 +5088 +590 +2577 +2668 +27719 +27669 +33454 +248 +33455 +18869 +33456 +303 +4526 +13524 +9 +1090 +29859 +33457 +33458 +20 +213 +33459 +209 +3407 +1817 +33460 +4028 +971 +33461 +892 +29260 +43 +24896 +25683 +14604 +15989 +29066 +4055 +16139 +24873 +1090 +5625 +15286 +140 +665 +19 +14369 +33462 +33463 +3994 +29483 +33464 +33465 +25620 +6614 +33466 +12203 +13964 +33467 +33468 +29381 +33469 +1560 +33470 +33471 +33472 +6439 +1716 +33473 +26361 +265 +29209 +13710 +28036 +33474 +31225 +249 +33475 +1063 +33476 +33477 +33478 +5923 +33479 +33480 +209 +8668 +284 +33481 +33482 +33483 +33484 +2132 +15778 +23103 +31293 +33485 +9 +33486 +248 +33487 +554 +4055 +33488 +5188 +7014 +19 +2260 +33489 +15824 +2572 +4717 +9 +6950 +18683 +13360 +21365 +5780 +33490 +491 +6344 +4 +2410 +33491 +33492 +27669 +33493 +29981 +33494 +33495 +12013 +1444 +33496 +33497 +33498 +43 +21947 +1656 +590 +33499 +57 +33500 +33501 +12560 +25612 +1090 +33502 +14369 +1559 +33503 +29200 +33504 +1817 +33505 +323 +25316 +1817 +24982 +33506 +14 +3188 +342 +29381 +590 +21630 +33225 +1090 +2733 +519 +33507 +2459 +33508 +2 +14385 +4 +9 +165 +33509 +33510 +2457 +1332 +349 +33511 +4463 +16905 +590 +19618 +14947 +33512 +33513 +24988 +514 +720 +31098 +33514 +33515 +9 +9410 +31293 +33516 +33517 +2289 +33518 +2132 +1066 +43 +5464 +28402 +6505 +2577 +19 +1429 +21947 +15718 +3546 +9 +26104 +33519 +33520 +15718 +33521 +2121 +12987 +33522 +595 +5188 +33523 +18418 +33524 +32636 +17151 +21947 +33525 +17112 +13721 +9 +33526 +533 +7053 +33527 +31293 +590 +29483 +1513 +25351 +33528 +31098 +2577 +33529 +249 +33530 +5130 +248 +33531 +30224 +33532 +1812 +33533 +33534 +33535 +14947 +5340 +15540 +15 +33536 +33537 +33538 +13721 +9 +4055 +33539 +317 +33540 +24303 +33541 +33542 +33543 +887 +33544 +683 +28036 +345 +248 +10727 +13484 +31873 +33545 +33546 +33547 +27069 +3546 +33548 +1090 +15718 +14825 +33549 +19618 +14957 +31293 +9 +25683 +222 +33550 +1090 +33551 +491 +33552 +33553 +33554 +19 +647 +6595 +33555 +31293 +15 +9433 +265 +33556 +197 +33557 +33558 +33559 +3553 +2318 +1578 +2537 +590 +15718 +25316 +29483 +30589 +33560 +16981 +43 +2 +42 +33561 +28248 +303 +17911 +33562 +33563 +4471 +303 +33564 +21708 +7987 +33565 +33566 +13721 +32 +4990 +15718 +213 +33567 +33568 +14415 +213 +668 +33569 +9986 +30877 +9 +33570 +185 +22787 +33571 +13848 +590 +25683 +27069 +33572 +14330 +33573 +16925 +15054 +9 +1012 +33574 +9 +20 +15 +33575 +24045 +33576 +33577 +17151 +6571 +5627 +33578 +33579 +18989 +9 +2744 +33580 +30589 +222 +33581 +33582 +1013 +15 +33583 +14719 +1230 +33584 +213 +8332 +43 +6465 +25991 +33585 +768 +23464 +33586 +25683 +1090 +19304 +3369 +33587 +1123 +14282 +12 +33588 +265 +4055 +33589 +1710 +33590 +32 +33591 +33592 +11336 +14574 +43 +284 +4055 +33593 +165 +33594 +33595 +337 +2958 +33596 +2694 +33597 +33598 +29483 +11210 +284 +103 +21689 +248 +245 +33599 +28031 +3601 +33600 +8566 +736 +10230 +33601 +671 +29200 +1090 +9 +25237 +20442 +13279 +26496 +9 +33602 +25943 +2733 +33603 +8367 +33604 +2314 +21947 +18982 +27599 +11185 +1175 +33605 +33606 +21947 +29573 +398 +590 +9400 +33607 +590 +24725 +284 +8360 +33608 +33609 +25140 +24045 +33610 +2122 +30551 +33611 +823 +272 +5188 +5318 +24864 +5169 +33612 +33613 +33614 +33615 +31042 +8668 +21947 +27150 +30877 +33616 +5035 +33617 +10 +2769 +29641 +9 +9 +14527 +27669 +6058 +303 +3553 +33618 +33619 +10947 +33620 +33621 +33622 +2324 +28036 +284 +14369 +11098 +33623 +33624 +33625 +19 +1524 +179 +1542 +13905 +77 +14330 +33626 +43 +284 +33627 +9 +22407 +2568 +33628 +25584 +31293 +2310 +26544 +138 +342 +25683 +2132 +14369 +33629 +33630 +349 +7855 +28295 +7964 +18045 +20952 +33631 +16025 +2540 +446 +213 +286 +248 +14477 +1559 +590 +2694 +27669 +33632 +18312 +379 +28549 +3546 +24045 +33633 +337 +33634 +12896 +30835 +25316 +33635 +33636 +9410 +33637 +590 +33638 +284 +33639 +677 +33640 +1716 +43 +286 +24303 +33641 +15 +33642 +33643 +33644 +4550 +303 +33645 +28317 +16014 +248 +33646 +770 +10381 +33647 +345 +24460 +33648 +33649 +13129 +32609 +11754 +33650 +2719 +5188 +9 +1605 +33651 +25140 +33652 +141 +1559 +33653 +3546 +989 +33654 +33655 +33656 +25683 +3548 +33657 +27069 +33658 +33659 +373 +33660 +9 +14871 +33661 +33662 +33663 +31293 +2419 +28549 +33664 +23867 +13621 +1090 +15 +66 +26680 +8392 +536 +140 +7375 +33665 +20810 +53 +15645 +33666 +201 +33667 +1920 +33668 +303 +19618 +24303 +29483 +33669 +33670 +33671 +185 +9132 +30224 +33672 +33673 +27335 +19618 +9 +33674 +33675 +33676 +303 +936 +33677 +509 +428 +33678 +13307 +3546 +10 +33679 +33680 +33681 +33682 +33683 +185 +11754 +21947 +33684 +33685 +33686 +33687 +33688 +33689 +33690 +33691 +33692 +5798 +33693 +30877 +33694 +14369 +478 +28036 +5803 +19618 +33695 +213 +33226 +30877 +439 +2117 +33696 +33697 +38 +155 +33698 +9233 +33699 +20803 +33700 +1705 +671 +2459 +140 +20952 +14604 +33701 +770 +33702 +478 +677 +23231 +23103 +33703 +1090 +18553 +33704 +19218 +554 +33705 +33706 +33707 +33708 +1181 +286 +33709 +33710 +1169 +31293 +14947 +30877 +33711 +33712 +23226 +10 +10624 +27669 +33713 +5169 +18798 +33714 +3546 +33715 +590 +3369 +11675 +554 +2550 +33716 +412 +700 +24426 +9 +7049 +13503 +33627 +33717 +33718 +19 +26484 +33719 +33720 +248 +21947 +22 +14369 +26157 +15718 +29628 +29209 +25140 +194 +30877 +33721 +33722 +14330 +33723 +30458 +28317 +33724 +25683 +249 +22605 +33725 +2655 +14330 +33726 +33727 +411 +23675 +24045 +33728 +29997 +33729 +33730 +10678 +33731 +33732 +33733 +33734 +3546 +4055 +3546 +16145 +20435 +33735 +14330 +33736 +33737 +33738 +1090 +33739 +33740 +25659 +28151 +19050 +7945 +98 +751 +11207 +1230 +751 +14947 +590 +33120 +57 +23103 +33741 +33742 +270 +2694 +25140 +27669 +13956 +33743 +15718 +33744 +694 +17920 +19009 +222 +590 +33745 +1090 +33746 +9688 +33747 +33748 +15384 +12005 +33749 +22 +18815 +33750 +1870 +33751 +25140 +286 +24896 +18821 +2009 +13465 +33752 +6086 +33753 +23481 +33754 +33755 +970 +6161 +28441 +3546 +19 +209 +5561 +15907 +33756 +10 +16437 +4088 +33757 +13721 +345 +28549 +33758 +27669 +33759 +19 +33760 +16437 +33761 +33762 +33763 +3 +354 +18434 +7891 +33764 +18896 +33765 +33766 +541 +5326 +19618 +33767 +19 +18045 +9898 +6595 +33768 +33769 +4055 +284 +5780 +22 +22 +66 +33770 +33771 +19618 +33772 +33773 +2577 +33577 +16979 +33758 +33774 +4055 +1559 +33775 +33776 +4055 +33777 +33778 +892 +322 +29483 +33779 +2410 +14330 +720 +28441 +99 +213 +26320 +33780 +345 +398 +20822 +24339 +21947 +19 +337 +232 +27669 +13956 +33781 +29381 +28317 +13570 +33782 +33783 +33784 +1332 +11762 +349 +33061 +9 +33785 +33786 +14 +15971 +9573 +25683 +33787 +33788 +566 +14369 +43 +33789 +7291 +33790 +720 +14161 +33791 +33792 +14369 +33793 +33794 +30224 +14079 +12936 +1991 +33795 +4055 +14369 +52 +1157 +18434 +3994 +33796 +213 +33797 +1352 +33798 +22963 +29483 +7823 +66 +33799 +33800 +33801 +26943 +21947 +33802 +33803 +33804 +1384 +2129 +25584 +1013 +439 +33805 +15718 +33806 +33393 +33807 +33808 +33809 +5700 +24144 +354 +33388 +21947 +30877 +33810 +33811 +6095 +14369 +1090 +1077 +736 +4124 +11762 +286 +337 +31434 +16437 +33812 +29981 +19 +19655 +33813 +736 +3755 +25237 +8946 +33814 +33815 +590 +33816 +33817 +33818 +514 +14840 +21416 +33819 +33820 +33821 +284 +33822 +33823 +19618 +3019 +3546 +25683 +2668 +27748 +33824 +248 +3026 +21947 +115 +33825 +31293 +33826 +25237 +28036 +3601 +3546 +1812 +694 +21248 +303 +33827 +30224 +303 +33828 +345 +248 +21689 +32 +12552 +26361 +17093 +33829 +33830 +250 +345 +33831 +13985 +33832 +17029 +284 +33833 +33834 +31577 +33835 +178 +24725 +337 +1749 +27069 +32 +33836 +9 +30224 +5188 +822 +9 +337 +33837 +25683 +27113 +3546 +33838 +33839 +590 +33840 +24864 +5085 +33841 +590 +33842 +29 +286 +9024 +6095 +19 +33843 +248 +33198 +1051 +8454 +33844 +915 +33845 +33846 +33847 +1044 +33848 +4002 +1961 +33849 +33850 +33851 +1047 +33852 +13721 +30877 +337 +10757 +1920 +33853 +43 +33854 +3317 +33855 +18946 +46 +33177 +583 +14059 +33856 +22098 +24 +1090 +303 +21681 +2135 +33650 +33857 +248 +677 +15718 +2260 +5085 +28036 +33858 +24864 +5085 +25584 +33859 +33860 +5208 +6006 +590 +1870 +2015 +25 +337 +1605 +248 +31906 +5085 +33861 +13721 +284 +33862 +25683 +13848 +29880 +33863 +33864 +349 +2577 +33865 +16413 +4151 +179 +123 +33866 +1531 +22986 +250 +25237 +683 +33867 +123 +10 +24864 +33868 +33869 +1562 +3160 +33368 +5808 +25584 +33870 +30224 +29204 +9 +1605 +2338 +3684 +33871 +23103 +33872 +25140 +33650 +15 +27669 +30224 +292 +464 +23871 +33873 +33874 +272 +590 +33875 +33876 +33877 +33141 +3546 +137 +33878 +30084 +590 +17972 +2372 +33879 +30051 +19 +8367 +2764 +33880 +105 +1090 +33881 +33882 +15718 +3668 +31293 +2314 +2264 +33883 +26744 +1316 +16332 +33627 +1559 +6537 +33884 +19974 +33885 +33886 +22308 +4075 +33887 +14909 +590 +8239 +21947 +239 +18250 +33888 +33889 +14330 +33890 +20 +14001 +33891 +19048 +15 +248 +1562 +9 +286 +33892 +3904 +1716 +7601 +2485 +33893 +7801 +736 +2537 +17151 +861 +33894 +33895 +33896 +19618 +22922 +33897 +2577 +595 +33898 +9 +4055 +279 +33899 +7532 +33900 +33901 +26361 +4502 +33902 +14330 +24630 +33903 +33904 +1502 +33307 +11639 +12987 +6187 +89 +14604 +33650 +6122 +25140 +33905 +16798 +3546 +25683 +18283 +936 +7816 +3660 +33906 +9210 +345 +31346 +12919 +25140 +1765 +33907 +286 +14 +33908 +17749 +21947 +19618 +43 +872 +29483 +33627 +33909 +33910 +25237 +1870 +464 +345 +14604 +14369 +1090 +29 +12120 +33911 +22823 +33912 +736 +33913 +13721 +18897 +6441 +14523 +14814 +33914 +33915 +33916 +33917 +115 +13721 +707 +12916 +284 +13976 +31293 +33918 +53 +590 +33919 +9 +25996 +13905 +10946 +43 +32642 +33920 +30224 +33921 +89 +13943 +887 +19 +18869 +33922 +12431 +1051 +29483 +20063 +1090 +7522 +21947 +194 +33923 +33650 +33924 +14330 +33925 +33926 +10 +33927 +21947 +194 +30051 +43 +2677 +9 +30224 +33928 +27669 +873 +1513 +33929 +33930 +33931 +18815 +4028 +26081 +33932 +21947 +33933 +43 +20745 +33934 +33935 +25539 +22269 +1870 +25316 +9 +31293 +2865 +1169 +33936 +736 +28317 +14577 +23394 +29502 +13813 +11321 +26712 +33120 +99 +33937 +30877 +38 +33938 +43 +33939 +5085 +25237 +379 +32938 +33940 +38 +1605 +10230 +736 +590 +33941 +8849 +15718 +15 +20563 +2865 +751 +29381 +24144 +33942 +33943 +33944 +590 +14 +1090 +12407 +357 +14000 +538 +3491 +349 +30877 +43 +20426 +33945 +33946 +533 +9210 +1289 +1765 +2018 +14369 +1364 +32566 +19 +32 +33947 +33948 +19 +33949 +7128 +33950 +33951 +16437 +25316 +9 +9 +31098 +19618 +33952 +323 +33953 +25140 +25683 +33954 +33955 +33956 +23231 +33957 +29926 +1090 +33958 +721 +2601 +33959 +33643 +33960 +495 +33961 +17635 +228 +1234 +1300 +13375 +24303 +33962 +33963 +25584 +33964 +33965 +28609 +19 +33966 +33967 +25659 +33968 +21371 +10117 +33969 +38 +590 +12075 +2197 +31249 +33970 +22922 +665 +29172 +20776 +33971 +33972 +30224 +33973 +15 +2459 +1224 +29483 +33974 +66 +665 +33975 +33976 +28317 +33977 +14707 +5780 +29381 +1090 +33978 +31375 +33979 +57 +33980 +33981 +22986 +28317 +43 +590 +4624 +33982 +19996 +6618 +9 +33963 +1090 +21947 +33983 +33984 +66 +30224 +9074 +6054 +98 +17749 +28549 +861 +29 +29032 +33985 +12120 +33986 +5085 +43 +12203 +1011 +17670 +33987 +33988 +736 +274 +24303 +33989 +6701 +33990 +33211 +33991 +33992 +29483 +10239 +33120 +25316 +33993 +19 +3353 +1824 +3999 +12214 +33994 +33995 +21922 +4055 +33996 +25683 +670 +33997 +2577 +30051 +33627 +33650 +25140 +43 +33998 +8188 +33999 +1716 +18357 +34000 +34001 +30224 +34002 +15483 +4028 +379 +34003 +32640 +1090 +31098 +15718 +15511 +34004 +1384 +34005 +21947 +34006 +34007 +21947 +5629 +13375 +34008 +1446 +31098 +15356 +415 +4603 +34009 +34010 +7291 +34011 +27387 +15 +26361 +38 +18695 +34012 +1011 +34013 +14369 +77 +60 +34014 +14079 +66 +32 +34015 +3546 +34016 +7835 +137 +398 +1013 +34017 +2832 +34018 +1992 +34019 +34020 +9 +34021 +34022 +24907 +29716 +357 +34023 +34024 +43 +34025 +34026 +14330 +34027 +15541 +13897 +1720 +25237 +31293 +34028 +7610 +13150 +1090 +1961 +34029 +34030 +538 +27069 +26361 +2 +34031 +21947 +1543 +21486 +3601 +34032 +34033 +24948 +25140 +26582 +43 +3349 +34034 +34035 +34036 +8188 +25 +1817 +377 +34037 +27669 +2769 +12987 +32332 +34038 +21947 +34039 +590 +736 +34040 +8037 +34041 +14363 +1134 +34042 +25237 +590 +14604 +34043 +34044 +1157 +12555 +34045 +43 +4533 +5085 +1559 +26434 +3601 +736 +26744 +21947 +34046 +482 +34047 +34048 +32 +34049 +34050 +4123 +31293 +34051 +34052 +14909 +9 +34053 +28441 +34054 +13807 +33650 +34055 +193 +34056 +1090 +6439 +19007 +16102 +34057 +590 +17730 +34058 +7855 +613 +4124 +21947 +34059 +34060 +14330 +4677 +25859 +34061 +34062 +28638 +842 +34063 +12480 +34064 +32 +1224 +11762 +21947 +34065 +34066 +12987 +2694 +34067 +17872 +8186 +109 +34068 +25683 +34069 +1508 +12987 +26666 +34070 +32 +424 +34071 +33650 +16116 +34072 +26040 +34073 +3546 +1090 +9024 +34074 +34075 +34076 +34077 +33650 +24144 +30458 +34078 +34079 +30877 +1112 +33758 +2971 +29483 +34080 +5080 +31293 +16375 +33650 +8005 +34081 +34082 +34083 +5627 +30877 +34084 +1961 +34085 +209 +8668 +33650 +9 +34086 +1082 +3553 +201 +34087 +26496 +34088 +25584 +1470 +34089 +1612 +34090 +34091 +34092 +34093 +43 +1870 +17698 +34094 +34095 +34096 +2064 +34097 +34098 +30877 +15 +2 +694 +30877 +13030 +34099 +4055 +5780 +1157 +19655 +15718 +16875 +34100 +9 +34101 +21947 +590 +34102 +34103 +111 +9560 +31293 +232 +34104 +34105 +34106 +9 +3067 +43 +29381 +4055 +13566 +34107 +178 +27669 +576 +34108 +491 +1090 +15718 +9 +533 +34109 +14330 +34110 +6354 +34111 +34112 +1382 +1810 +34113 +20 +9 +4055 +5408 +590 +3946 +8994 +34114 +15018 +34115 +2581 +5683 +14369 +9 +10 +19 +1107 +34116 +24303 +19 +3546 +345 +25316 +7835 +35 +28441 +9 +4367 +15 +33650 +19 +34117 +34118 +20850 +14001 +34119 +34120 +20 +18798 +30877 +34121 +29483 +22587 +31293 +30877 +1668 +3546 +34122 +9 +2733 +373 +720 +30877 +24303 +3546 +34123 +34124 +34125 +43 +28116 +34126 +8668 +34127 +20443 +34128 +345 +1529 +34129 +33650 +34130 +1310 +1870 +10 +33650 +590 +8593 +34131 +19918 +201 +43 +34132 +34133 +9 +713 +849 +43 +27669 +57 +34134 +34135 +32 +34136 +43 +12987 +34137 +18874 +34138 +736 +34139 +21947 +595 +22592 +30877 +34140 +28549 +196 +31293 +33963 +16264 +8766 +14102 +4388 +9 +34141 +34142 +34143 +971 +2872 +24458 +25237 +18421 +533 +27249 +9904 +34144 +23368 +29204 +208 +3746 +34145 +19 +2 +26127 +34146 +14588 +9 +31503 +4055 +34147 +34148 +22236 +34149 +34150 +9 +1374 +8357 +43 +8249 +2988 +34151 +26946 +12987 +703 +4055 +10 +573 +1514 +2356 +34152 +282 +2 +1961 +11754 +648 +25050 +7835 +13474 +541 +34153 +34154 +2325 +1648 +34155 +24725 +34156 +34157 +25871 +98 +14330 +98 +21947 +28549 +33650 +34158 +34159 +34160 +19 +102 +9 +2064 +34161 +43 +43 +25140 +34162 +15 +34163 +20586 +34164 +14776 +43 +34165 +12302 +34166 +10199 +20666 +3999 +34167 +66 +14759 +29800 +27096 +30224 +19618 +590 +14343 +34168 +209 +34169 +34170 +590 +13721 +5629 +34171 +1524 +43 +34172 +30051 +34173 +34174 +9 +32537 +34175 +24939 +14 +5192 +34176 +3484 +34177 +278 +34178 +14947 +14477 +34179 +34 +34180 +31293 +16437 +34181 +32900 +34182 +34183 +17698 +9 +34184 +3546 +34185 +25237 +34186 +21947 +17272 +349 +15718 +34187 +34188 +34189 +5803 +17151 +34190 +34191 +34192 +34193 +4026 +10256 +34194 +43 +14369 +25237 +179 +377 +14216 +21494 +3546 +34195 +25160 +720 +21947 +19855 +9 +43 +21947 +98 +5085 +1529 +5817 +34196 +19 +34197 +34198 +34199 +33650 +34200 +1382 +8351 +57 +19 +647 +6499 +31603 +31293 +34201 +2550 +18045 +38 +9 +29381 +34202 +34203 +286 +2577 +10031 +1961 +34204 +34205 +590 +17675 +12005 +9402 +4055 +770 +2071 +34206 +936 +237 +7053 +1385 +25237 +3546 +21947 +11697 +201 +34207 +34208 +34209 +15463 +14 +3959 +34210 +34211 +828 +5188 +34212 +21947 +34213 +590 +34214 +34215 +43 +21689 +19655 +713 +34216 +790 +34217 +21835 +34218 +736 +34219 +9 +34220 +176 +28295 +21947 +34221 +34222 +34223 +11966 +32642 +34224 +34225 +590 +34226 +1090 +34227 +2260 +30551 +14369 +34228 +34229 +1529 +590 +34230 +416 +34231 +28317 +15671 +14 +34232 +34233 +19 +34234 +3871 +34235 +4791 +34236 +34237 +34238 +3959 +17281 +34239 +34240 +31500 +196 +15216 +34241 +736 +3143 +519 +34242 +19 +34243 +34244 +34245 +13721 +34246 +42 +34247 +34248 +554 +1524 +16447 +10003 +34249 +1765 +34250 +9 +34251 +24 +34252 +43 +18043 +6294 +33650 +27669 +14477 +34253 +34254 +30051 +14594 +2926 +104 +2314 +34255 +33445 +17784 +738 +1208 +15718 +34256 +250 +9 +34257 +34258 +34259 +14369 +568 +34260 +34261 +34262 +34263 +34264 +15718 +34265 +34266 +3584 +34267 +29204 +1066 +34268 +26744 +34269 +23990 +19523 +30877 +34270 +317 +34271 +29483 +29715 +34272 +18283 +21689 +34273 +31585 +34274 +34275 +28471 +34276 +26040 +358 +5085 +1716 +14369 +34277 +34278 +29658 +19618 +30224 +286 +23675 +34279 +34280 +2009 +27117 +34281 +34282 +34283 +19 +1090 +34284 +34285 +34286 +34287 +34288 +3546 +25584 +34289 +23313 +34290 +77 +4752 +1291 +1364 +12 +34291 +34292 +155 +14660 +10 +19 +34293 +31293 +1169 +29628 +34294 +15 +34295 +34296 +1992 +32636 +9 +34297 +155 +29381 +28549 +31293 +34298 +13638 +43 +34299 +34300 +286 +34301 +21947 +34302 +1684 +34303 +14330 +25140 +936 +34304 +342 +77 +19 +352 +140 +21758 +32863 +15514 +3994 +2042 +22963 +34305 +24303 +8418 +4055 +20443 +34306 +3978 +34307 +34308 +19 +34309 +27669 +25943 +21947 +2919 +39 +14079 +590 +9460 +34310 +4808 +21904 +34311 +6725 +34312 +34313 +34314 +21889 +33963 +34315 +34316 +10 +34317 +20952 +590 +34318 +21947 +3790 +34319 +34320 +9 +31293 +21947 +590 +9 +5839 +33818 +34321 +15718 +14369 +34322 +34323 +31467 +176 +34324 +34325 +30877 +22986 +590 +34326 +4055 +43 +43 +34327 +34328 +491 +34329 +554 +21947 +34330 +34331 +1090 +8746 +21187 +6335 +29483 +554 +4364 +1513 +342 +1508 +34332 +11423 +18283 +34333 +32805 +179 +671 +15 +18045 +11362 +6883 +34334 +34335 +25943 +286 +34336 +27669 +34337 +21499 +349 +14 +30224 +34338 +1157 +34339 +25237 +590 +19 +34340 +34341 +19 +25316 +34342 +34343 +34344 +10049 +34345 +8996 +34346 +286 +30551 +34347 +34348 +34349 +7836 +34350 +533 +25683 +43 +34351 +590 +22464 +34352 +1021 +34353 +17151 +24864 +7855 +34354 +16014 +6142 +1655 +349 +30224 +10717 +28317 +887 +43 +176 +30051 +29483 +34355 +14604 +34356 +2129 +20700 +7835 +484 +34357 +22922 +34358 +28036 +27669 +14477 +34359 +9 +2286 +30712 +7053 +34360 +27669 +1234 +3546 +15320 +34361 +1425 +33963 +31293 +4951 +34362 +16883 +34363 +34364 +5188 +352 +2253 +34365 +1018 +1688 +34366 +34367 +3601 +411 +34368 +379 +1716 +1529 +179 +1157 +34369 +19618 +24725 +26040 +5119 +33021 +31293 +25683 +558 +34370 +21947 +1364 +34371 +14369 +13068 +3369 +2570 +34372 +20 +34373 +478 +27669 +19 +11653 +770 +27074 +222 +13566 +17136 +30877 +27669 +34374 +34375 +345 +34376 +25237 +34377 +33368 +34378 +849 +34379 +34380 +9 +34381 +19 +32 +34382 +34383 +7154 +25943 +34384 +736 +34385 +34386 +694 +1090 +34387 +34388 +970 +34389 +713 +590 +34390 +933 +4 +14174 +15718 +19852 +34391 +34392 +9 +19 +14369 +34393 +349 +1765 +34394 +27886 +25140 +703 +34395 +14410 +34396 +33445 +34397 +34398 +43 +34399 +34400 +720 +3044 +5741 +28317 +34401 +4 +34402 +1442 +43 +24864 +2093 +34403 +31293 +15 +5990 +18995 +43 +397 +4055 +19618 +16780 +34404 +34405 +286 +34406 +34407 +1566 +17535 +34408 +19939 +31293 +34409 +27864 +33278 +26178 +6945 +34410 +25237 +32646 +34411 +34412 +29381 +29483 +373 +8476 +1090 +34413 +12346 +5085 +34414 +188 +363 +43 +28745 +29483 +331 +34415 +20 +22 +5489 +24864 +12987 +27719 +19618 +34416 +14330 +22666 +34417 +34418 +11341 +7835 +11966 +1578 +115 +590 +36 +34419 +10173 +2318 +32538 +648 +3546 +25683 +34420 +34421 +32782 +34422 +6054 +18695 +34423 +34424 +1779 +892 +34425 +22986 +34426 +683 +34427 +34428 +34429 +34430 +34431 +30877 +34432 +66 +10781 +379 +4055 +970 +30877 +590 +533 +14369 +31293 +3589 +19582 +2799 +34433 +11282 +249 +17121 +915 +34434 +5085 +43 +910 +25 +29200 +34435 +34017 +5169 +19 +2356 +34436 +730 +34437 +34438 +3 +2015 +30551 +19618 +34439 +188 +7108 +25683 +28219 +7379 +34440 +18045 +25683 +34441 +19 +349 +34442 +34443 +590 +9 +34444 +34445 +19838 +19335 +34446 +15039 +34447 +34448 +7835 +24864 +34449 +25140 +23239 +14 +13566 +21947 +17151 +12005 +24864 +14603 +34450 +970 +34451 +34452 +34453 +34454 +34455 +21947 +34456 +6287 +20 +14763 +34457 +34458 +29200 +22453 +1870 +12916 +27669 +34459 +5792 +4550 +31293 +34460 +34461 +34462 +34463 +1234 +8855 +34464 +29720 +34465 +21947 +1090 +34466 +736 +22922 +33758 +34467 +89 +27669 +34468 +66 +34469 +21835 +34079 +34470 +736 +14369 +24864 +34471 +34472 +48 +34473 +34474 +33963 +536 +27153 +34475 +5188 +3546 +34476 +20 +14604 +14369 +34477 +57 +9204 +34478 +34479 +13721 +9 +19655 +34480 +34481 +7522 +34482 +29483 +5908 +352 +823 +34483 +286 +3343 +34484 +22315 +1131 +21947 +179 +707 +598 +25584 +25943 +34485 +1425 +34486 +11672 +34487 +23406 +29981 +1710 +34488 +5085 +8210 +9 +29381 +249 +28036 +43 +34489 +34490 +31168 +692 +13794 +43 +1230 +22 +43 +25237 +9 +14369 +1107 +34491 +34492 +34493 +34494 +43 +34495 +478 +34496 +971 +34497 +11321 +349 +590 +34498 +21947 +33650 +14369 +22236 +34499 +34500 +34501 +28348 +34502 +34503 +5188 +278 +34504 +2260 +399 +34505 +34506 +36 +29204 +34507 +34508 +34509 +34510 +34511 +34512 +34513 +34514 +915 +5316 +590 +24896 +4028 +3100 +29483 +683 +34515 +1090 +29483 +197 +9 +18145 +2314 +34516 +34517 +14369 +34518 +5559 +34519 +31293 +34520 +34521 +14369 +34522 +28295 +31406 +34523 +34524 +34525 +349 +2619 +4055 +34526 +849 +13797 +7291 +34527 +9660 +34528 +14330 +15845 +34529 +34181 +7053 +21947 +20386 +25237 +34530 +345 +3546 +249 +254 +34531 +34532 +34533 +25140 +34534 +34535 +13510 +19 +4055 +23752 +9 +22198 +14604 +34536 +26361 +24725 +1817 +1090 +24864 +33697 +3330 +24951 +7835 +16437 +23603 +25683 +29884 +9 +43 +32359 +24303 +345 +379 +34537 +9 +34538 +3546 +34539 +1090 +18503 +14188 +34540 +15 +25237 +2762 +16121 +34541 +1157 +34542 +57 +34543 +188 +286 +1090 +34544 +1286 +2197 +415 +33963 +34545 +16437 +2694 +34546 +28317 +42 +416 +32 +7053 +29204 +34547 +15135 +34548 +34549 +34550 +14369 +165 +209 +345 +182 +34551 +43 +33141 +34552 +4441 +5188 +1090 +14216 +9 +25683 +34553 +34554 +2 +34555 +34556 +34557 +9 +25237 +33627 +248 +34558 +7835 +196 +26561 +21947 +25683 +286 +34559 +11762 +25140 +1320 +34560 +337 +43 +19 +2117 +34561 +586 +25683 +1122 +34562 +34563 +34564 +34565 +19688 +36 +31293 +89 +33627 +34566 +34567 +21947 +284 +1220 +19 +34568 +4979 +5188 +34569 +1742 +10 +31293 +29204 +250 +30224 +4055 +17267 +2347 +34570 +21947 +17972 +89 +4650 +34571 +8367 +284 +28317 +4116 +2410 +29032 +30917 +337 +16440 +19 +34572 +19 +4055 +1696 +34573 +19 +248 +1481 +590 +25659 +34574 +2289 +34575 +34576 +34577 +34 +34578 +700 +34579 +4278 +248 +6617 +34580 +248 +397 +2540 +707 +345 +1090 +34581 +34582 +21689 +915 +25237 +665 +337 +736 +3119 +6294 +34583 +34584 +43 +25584 +20 +14759 +34585 +17060 +213 +34586 +34587 +19 +2550 +34588 +3546 +43 +17151 +23506 +178 +34589 +21947 +5188 +34590 +248 +3077 +34591 +6962 +721 +21947 +34592 +402 +34593 +34594 +9 +9396 +25683 +25991 +34595 +13721 +34596 +1090 +18982 +34597 +9 +99 +28317 +34598 +4227 +519 +31293 +10642 +703 +34599 +3546 +34600 +30051 +10 +34601 +1863 +9 +931 +34602 +34603 +23103 +711 +34604 +248 +34605 +2289 +25943 +34606 +317 +34607 +10544 +34608 +1120 +10 +33627 +7137 +29483 +590 +11925 +828 +15718 +3484 +15 +34609 +11719 +29 +26355 +25298 +14330 +34610 +19 +337 +936 +1817 +51 +34611 +15 +14 +25683 +34612 +34613 +34614 +891 +2260 +15 +34531 +1559 +5188 +9939 +9 +1384 +12987 +34615 +12425 +872 +34616 +14369 +12153 +34617 +25140 +354 +3391 +34618 +34619 +34620 +9497 +33963 +15 +22922 +123 +23103 +34621 +9 +34622 +34623 +34624 +114 +1247 +34625 +13721 +29688 +28549 +14884 +34626 +34627 +12987 +24423 +34628 +19 +21429 +25943 +33963 +34629 +25584 +22269 +34630 +2577 +34631 +16239 +25683 +34632 +19 +373 +33977 +34633 +14 +34634 +14369 +34635 +33683 +8593 +17281 +21394 +34636 +3553 +213 +34637 +14477 +590 +34433 +4055 +201 +105 +34638 +24303 +34639 +34640 +27719 +18684 +34641 +14369 +869 +27238 +442 +8460 +24725 +590 +1219 +11970 +57 +25683 +19618 +13361 +9808 +34642 +411 +21689 +32 +21947 +21947 +1696 +15018 +4368 +2446 +24725 +34643 +25316 +30877 +30650 +178 +303 +34644 +34645 +34646 +30209 +1090 +57 +317 +34647 +34648 +597 +34649 +43 +19 +20 +31293 +33445 +34650 +25316 +2342 +1382 +823 +5904 +196 +34651 +46 +34652 +15881 +590 +533 +22868 +24896 +21947 +248 +27669 +28317 +24864 +7362 +34653 +12013 +21947 +4306 +12178 +179 +32161 +1090 +590 +34654 +34655 +30224 +34656 +15354 +1716 +34657 +4055 +349 +24129 +19 +185 +20 +286 +28294 +1013 +34658 +23547 +9 +19618 +14369 +1920 +16826 +179 +24864 +586 +358 +15881 +4631 +34659 +19 +22787 +27669 +22864 +23103 +34660 +15384 +34661 +34662 +4055 +3476 +670 +9 +736 +34663 +176 +30877 +31293 +31293 +34664 +34665 +34666 +43 +2197 +358 +34667 +5731 +4856 +32920 +8218 +209 +29172 +815 +213 +1112 +14504 +27669 +3061 +8668 +3 +9 +354 +20328 +25683 +12479 +2769 +8670 +19618 +34668 +155 +34669 +17698 +24058 +34670 +34671 +34672 +34673 +29381 +2 +31293 +10 +17238 +14769 +701 +27178 +20722 +34674 +34675 +713 +34676 +2009 +554 +21563 +7835 +984 +10 +34677 +34678 +21947 +34679 +3005 +34680 +15331 +33650 +34681 +34682 +6364 +2197 +34683 +13247 +34684 +19 +19655 +590 +358 +34685 +3546 +495 +34686 +34687 +34688 +33963 +34689 +30224 +5376 +34690 +11983 +34438 +16102 +99 +19618 +213 +12987 +34691 +1090 +34692 +34693 +284 +24725 +2577 +34694 +1109 +34695 +24045 +15 +34696 +34697 +2764 +34698 +155 +34699 +19655 +34700 +1508 +15718 +34701 +34702 +19042 +80 +34703 +32 +34704 +20 +33650 +34705 +2949 +213 +34706 +34707 +34708 +9682 +9 +2463 +15597 +9 +3055 +377 +31098 +34709 +33 +34710 +46 +345 +33963 +34711 +14774 +484 +3655 +303 +8849 +34712 +123 +23271 +15718 +14025 +34713 +13279 +34714 +1018 +671 +349 +25140 +3601 +27669 +9 +34715 +21510 +322 +34716 +34717 +34718 +11762 +1465 +34719 +1861 +213 +29204 +30877 +284 +29733 +16401 +2998 +22 +34720 +34721 +27669 +34722 +15718 +43 +5665 +286 +19 +34723 +284 +9 +283 +590 +34724 +34725 +3546 +34726 +34727 +22922 +34728 +19618 +1425 +4055 +1364 +12157 +2721 +21553 +299 +34729 +17404 +10961 +33650 +34730 +201 +30877 +23150 +14485 +379 +25237 +19 +34731 +34732 +7048 +540 +3247 +25316 +7259 +11483 +43 +19618 +284 +34733 +1141 +34734 +4055 +34735 +4055 +34736 +34737 +89 +19 +34738 +4961 +23103 +34739 +21689 +34740 +352 +34741 +31293 +34742 +17571 +3981 +590 +7717 +34743 +25625 +34744 +15718 +5780 +14369 +21689 +18953 +77 +2550 +34745 +34746 +33427 +30775 +16437 +9617 +34747 +21647 +228 +34748 +4 +9160 +16 +18811 +19874 +3546 +25382 +43 +19928 +19523 +34749 +34750 +89 +4055 +27669 +2 +14330 +12722 +30210 +34751 +12299 +3546 +33693 +1503 +20 +34752 +34753 +17698 +9 +5188 +7053 +27669 +42 +34754 +32642 +27669 +18571 +15718 +34755 +15 +33627 +1011 +34756 +464 +34757 +29483 +34758 +34759 +23103 +2560 +34760 +337 +22292 +31293 +25683 +34761 +3182 +19321 +25584 +34762 +1502 +4425 +13390 +2040 +9 +34763 +1559 +155 +34764 +14001 +34765 +34766 +3546 +13721 +57 +3908 +26815 +18479 +28441 +9 +66 +15 +1529 +34767 +34768 +7418 +29109 +34769 +66 +33650 +28961 +15718 +34770 +34771 +14520 +3546 +13566 +1224 +2260 +34772 +5908 +15 +18896 +26176 +43 +668 +3659 +15088 +44 +12988 +970 +34773 +12987 +1524 +645 +33650 +9 +3739 +7292 +2694 +27669 +34774 +4055 +25237 +13228 +6595 +34775 +1090 +32871 +1090 +1829 +14 +7053 +4055 +30051 +21089 +34776 +31293 +28845 +32269 +22963 +4463 +815 +23103 +15194 +2600 +25164 +10780 +34777 +10318 +30877 +1116 +34778 +34779 +3337 +30051 +3361 +34780 +60 +34781 +30051 +34782 +34783 +98 +337 +34784 +1089 +286 +1295 +10 +34785 +1021 +3 +19 +34786 +34787 +43 +34788 +6732 +27669 +12013 +29483 +34789 +34790 +34791 +5659 +736 +1149 +33627 +137 +28317 +34792 +25316 +34793 +25683 +1513 +2009 +1013 +33650 +25140 +8297 +861 +590 +24725 +43 +33650 +34794 +34795 +9 +849 +31437 +34796 +34797 +34798 +25237 +33650 +24144 +34799 +245 +34800 +345 +14369 +34801 +9 +19852 +22290 +12005 +6782 +3908 +34802 +3484 +34803 +34804 +23926 +358 +176 +4693 +3546 +2197 +32604 +33113 +5433 +8188 +34805 +34806 +14 +416 +34807 +34808 +34809 +29381 +98 +19618 +6617 +34810 +16334 +11754 +43 +34811 +1817 +34812 +30877 +43 +2372 +259 +34813 +34814 +379 +34815 +104 +464 +13721 +43 +25140 +34816 +3369 +809 +3876 +590 +1090 +34817 +25140 +72 +13754 +34818 +33113 +29200 +6741 +34819 +9410 +3476 +31315 +19 +43 +14947 +358 +34820 +34821 +15 +554 +34822 +24303 +43 +34823 +22144 +21776 +25237 +416 +34824 +34825 +436 +33963 +19618 +17320 +2764 +11057 +9 +1244 +179 +1090 +554 +34826 +590 +123 +28639 +19618 +34827 +3976 +33758 +34828 +378 +34829 +12093 +14369 +34830 +3559 +250 +19 +34831 +16264 +34832 +14330 +1090 +29483 +34833 +19 +34834 +6999 +34835 +34836 +17281 +34837 +14399 +29549 +3546 +31098 +677 +34838 +34839 +34840 +34841 +15504 +16371 +2260 +6463 +21947 +15768 +15718 +34394 +33120 +25683 +4055 +1765 +34842 +338 +34843 +3546 +25316 +28317 +34844 +34845 +2593 +415 +34846 +209 +27860 +1236 +34847 +15718 +43 +34848 +26724 +27069 +19618 +16413 +16146 +3553 +29381 +4487 +19289 +1508 +43 +34849 +34181 +34850 +7072 +43 +1090 +34 +33650 +201 +25683 +34851 +34852 +2975 +34853 +345 +34854 +59 +34855 +34856 +1559 +25280 +9 +12 +1765 +590 +845 +34857 +20600 +345 +15914 +34858 +19852 +1870 +27669 +11321 +34859 +3202 +34860 +20482 +622 +34861 +32137 +16109 +140 +34862 +323 +554 +806 +98 +720 +34863 +9 +4326 +21689 +34864 +34865 +34583 +34866 +1090 +2058 +5995 +1026 +34867 +34868 +1461 +34869 +3252 +1870 +34870 +19276 +34871 +19618 +34872 +13375 +19618 +2694 +22 +34873 +3484 +5217 +43 +34874 +14369 +34875 +1090 +2043 +34876 +1453 +34402 +30877 +1817 +3790 +34877 +34878 +25943 +15 +26496 +34879 +34880 +19 +34881 +20785 +25659 +34882 +12348 +9 +18045 +34883 +501 +34884 +7105 +6463 +5080 +1051 +21947 +3546 +22963 +24 +15583 +34885 +2406 +34886 +34887 +1612 +34888 +915 +15718 +30500 +15649 +34889 +34890 +34891 +34892 +6310 +2537 +9460 +31936 +22463 +31098 +34893 +25943 +34894 +331 +9 +34895 +2049 +2 +5188 +2410 +2812 +9 +34896 +34897 +25683 +533 +21947 +1090 +66 +19618 +20340 +29483 +3599 +34898 +1710 +3170 +8418 +1090 +34899 +14477 +34900 +13721 +4806 +34901 +25316 +43 +1013 +43 +34902 +19 +34903 +1992 +32886 +26419 +21553 +34904 +1912 +34905 +3655 +398 +738 +19618 +34906 +6883 +1090 +34907 +3546 +16 +590 +16437 +8188 +19618 +66 +345 +34908 +9 +490 +377 +14013 +33113 +14369 +34909 +15 +3239 +34910 +31735 +1090 +23226 +24864 +34 +15483 +34911 +43 +66 +25140 +29381 +30877 +33120 +19 +34912 +25904 +1655 +24144 +34913 +34914 +34915 +34916 +34917 +34918 +34919 +15718 +19344 +18479 +34920 +357 +34921 +34833 +5389 +21947 +137 +25237 +554 +415 +14458 +7834 +736 +33650 +43 +31293 +34922 +34923 +2260 +2537 +31293 +34924 +33758 +34925 +31293 +1090 +34926 +34927 +32 +16102 +1090 +34928 +34402 +7053 +32 +15572 +34929 +3923 +34930 +25237 +5188 +34931 +34932 +178 +19618 +358 +14 +34933 +19355 +34934 +34935 +32517 +5601 +12642 +2 +541 +958 +19852 +970 +112 +2027 +34936 +6214 +15718 +34937 +32680 +21947 +34938 +533 +34939 +19 +34940 +971 +34941 +9 +377 +349 +34942 +590 +34943 +28317 +10642 +34402 +5649 +34944 +25036 +28923 +34945 +34946 +14693 +34947 +34948 +34949 +14079 +34950 +34951 +1212 +34952 +34953 +9 +34954 +30224 +6214 +34955 +34956 +736 +34957 +34958 +34959 +5080 +590 +32922 +34960 +34961 +18503 +14330 +19655 +2260 +34962 +286 +15 +887 +43 +34963 +4441 +842 +694 +590 +34964 +34965 +14 +43 +6095 +29200 +15718 +34966 +34967 +19 +28845 +6116 +941 +9 +31293 +872 +9 +34968 +29746 +19 +34402 +34969 +7176 +861 +345 +1051 +34970 +1090 +10600 +34971 +1090 +34972 +28295 +1716 +13721 +3553 +34973 +14 +27355 +34974 +9 +57 +29628 +13656 +34975 +34976 +590 +16437 +887 +26358 +2724 +19787 +7376 +155 +34977 +10199 +24303 +34 +201 +34978 +34979 +7176 +34980 +209 +34981 +31873 +25237 +14330 +34982 +34983 +34984 +34985 +34986 +34987 +34988 +1157 +34989 +34990 +34991 +34992 +29815 +12987 +12987 +34993 +317 +57 +28317 +301 +1090 +10510 +33650 +21947 +1100 +27161 +9 +12701 +34994 +34995 +34996 +34997 +829 +228 +9 +34998 +25316 +2410 +34999 +354 +25943 +35000 +6095 +25943 +24144 +9 +15068 +17400 +286 +43 +317 +4764 +21822 +9 +14240 +26560 +29855 +35001 +35002 +1513 +35003 +24864 +6217 +35004 +13178 +43 +35005 +3994 +765 +26496 +57 +6950 +35006 +137 +34641 +1047 +5370 +21947 +35007 +35008 +11754 +590 +4055 +35009 +648 +35010 +14434 +104 +28317 +35011 +14330 +31293 +27669 +10031 +35012 +30451 +35013 +33627 +35014 +15718 +35015 +3546 +14369 +30458 +57 +35016 +915 +25140 +11471 +35017 +1090 +6766 +27669 +14693 +24864 +4055 +209 +35018 +1680 +35019 +35020 +28549 +30301 +9 +736 +484 +35021 +43 +5188 +694 +9 +35022 +345 +249 +35023 +27719 +5925 +18120 +35024 +29381 +4518 +20 +35025 +35026 +29628 +33508 +30877 +970 +31293 +35027 +4411 +35028 +590 +140 +15647 +25140 +21947 +35029 +317 +27669 +2314 +35030 +35031 +425 +20841 +19839 +2 +25382 +4528 +35032 +2769 +35033 +35034 +554 +34804 +35035 +31501 +35036 +21261 +15514 +14369 +33203 +35037 +822 +6525 +32153 +24632 +35038 +35039 +35040 +8668 +30224 +35041 +35042 +23103 +398 +1637 +3546 +35043 +14947 +23958 +2988 +35044 +15683 +35045 +249 +35046 +35047 +33650 +13566 +35048 +694 +26861 +35049 +590 +35050 +19 +35051 +5314 +30224 +35052 +25683 +35053 +43 +33693 +25172 +3095 +10 +2782 +28549 +1090 +18869 +29381 +2314 +1716 +4414 +140 +109 +2446 +35054 +17206 +2625 +43 +35055 +18956 +27669 +6142 +10990 +2349 +35056 +35057 +15730 +35058 +14369 +1559 +345 +1829 +1090 +1927 +1732 +7835 +5188 +12987 +3351 +35059 +4388 +35060 +34 +28745 +15699 +4502 +15718 +35061 +35062 +3977 +35063 +19026 +1710 +31293 +35064 +10535 +12005 +35065 +35066 +34402 +28474 +15 +177 +5085 +1394 +14330 +9 +35067 +5659 +16102 +16422 +16818 +35068 +29574 +34402 +34402 +2260 +35069 +1442 +43 +35070 +35071 +19 +1100 +35072 +35073 +12916 +11135 +35074 +28441 +6532 +1517 +35075 +26361 +1371 +35076 +791 +8160 +3842 +35077 +18394 +35078 +464 +35079 +301 +35080 +25683 +35081 +33650 +970 +35082 +35083 +4055 +35084 +386 +35085 +35086 +29483 +28036 +1291 +35087 +26361 +5780 +2082 +25140 +2 +3369 +1295 +15718 +590 +14363 +4 +35088 +1019 +25943 +8465 +29434 +19 +7776 +4055 +30177 +3546 +35089 +35090 +533 +35091 +34436 +29800 +32523 +2744 +35092 +9 +176 +5642 +35093 +35094 +323 +3777 +33650 +29200 +26559 +35095 +21947 +35096 +27843 +30224 +16 +3452 +2764 +34534 +1520 +1674 +13360 +42 +18284 +35097 +35098 +3575 +35099 +25237 +35100 +8668 +201 +35101 +103 +35102 +5188 +14369 +3385 +16 +9 +15 +35103 +19172 +35104 +35105 +665 +35106 +9020 +14369 +9 +34795 +9 +35107 +3460 +35108 +98 +35109 +29459 +25683 +35110 +24727 +35111 +14689 +4907 +35112 +1332 +11554 +25316 +1090 +3376 +35113 +31346 +35114 +7811 +4055 +1021 +15718 +15 +11727 +33606 +464 +25 +2694 +8297 +35115 +35116 +2550 +13578 +736 +35117 +35118 +6950 +31293 +33650 +32001 +25382 +15231 +9 +18250 +2406 +590 +35119 +35120 +5923 +14 +25683 +34 +2593 +3997 +4 +1743 +3287 +23764 +35121 +35122 +1382 +35123 +12987 +7835 +35124 +12851 +677 +30051 +35125 +19 +14369 +35126 +35127 +21947 +25316 +35128 +14330 +5085 +286 +35129 +12309 +33120 +613 +35130 +35131 +1051 +28295 +35132 +35133 +586 +15 +11341 +35134 +26704 +8668 +35135 +10544 +590 +21947 +4055 +35136 +9 +35137 +3958 +35138 +6915 +24258 +1160 +19655 +354 +32 +16437 +9 +43 +19 +286 +18045 +14369 +736 +1090 +43 +17151 +10298 +237 +1914 +17698 +4055 +28036 +22787 +3330 +35139 +14886 +736 +15718 +2316 +35140 +19 +2636 +35141 +6751 +35142 +35143 +35144 +35145 +35146 +29981 +36 +35147 +13484 +35148 +22697 +35149 +32 +2314 +12307 +22208 +35150 +19655 +33125 +24864 +35151 +35152 +694 +2117 +35153 +57 +35154 +35155 +2287 +29381 +4083 +18045 +29483 +228 +35156 +3601 +14 +33821 +23867 +345 +14001 +19 +35157 +6048 +14369 +8362 +1648 +282 +872 +35158 +11515 +1870 +2260 +29200 +6617 +1300 +35159 +14369 +5579 +137 +35160 +35161 +35162 +35163 +35164 +828 +590 +694 +9941 +17 +35165 +2733 +14947 +1091 +35166 +31293 +491 +1481 +284 +2 +28339 +4055 +35123 +8670 +3353 +35167 +2061 +28803 +533 +33445 +8895 +35168 +26361 +35099 +16206 +35169 +7276 +3546 +284 +19 +33120 +1141 +35170 +22213 +1520 +35171 +14604 +349 +1090 +35172 +35173 +1889 +35174 +1224 +337 +3546 +213 +1090 +29981 +35175 +8668 +33758 +2694 +861 +27669 +27069 +35176 +31293 +27069 +23958 +3553 +595 +35177 +14193 +4848 +29628 +1139 +17911 +35178 +35179 +35180 +9 +35181 +849 +590 +21689 +15511 +24303 +33120 +2310 +25943 +35182 +35183 +57 +284 +20187 +2117 +76 +35184 +35185 +104 +35186 +5503 +31293 +213 +8338 +31603 +736 +35187 +7053 +8021 +35188 +303 +19 +12684 +11321 +5080 +1090 +303 +14102 +303 +35189 +35190 +301 +35191 +33650 +27850 +354 +13391 +3787 +35192 +19 +1090 +43 +828 +3711 +35193 +34 +35194 +245 +2764 +35195 +35196 +25140 +35197 +1021 +15 +14576 +35198 +3 +35199 +16205 +35200 +1019 +35201 +18695 +35202 +2769 +337 +31293 +188 +303 +35203 +19 +25683 +35204 +248 +33758 +34 +25 +35205 +21227 +35206 +24303 +30051 +11552 +35207 +6658 +28908 +3764 +19852 +1090 +33627 +284 +35208 +17088 +2140 +18706 +597 +5326 +303 +1169 +2828 +27293 +284 +33494 +24303 +337 +35209 +19218 +18869 +9 +43 +35210 +1542 +399 +178 +35211 +30458 +15 +35212 +9 +8668 +4055 +35213 +35214 +3365 +2308 +5085 +34402 +35215 +10094 +2837 +16437 +35216 +373 +35217 +35218 +379 +337 +5188 +25129 +9 +284 +35219 +11851 +35220 +35221 +9 +14369 +31293 +98 +35222 +35223 +9 +20 +35224 +1090 +849 +31246 +694 +303 +228 +9 +345 +29381 +35225 +11647 +17834 +590 +4764 +2040 +35226 +57 +35227 +28036 +35228 +30877 +35229 +337 +26496 +35230 +35231 +43 +35232 +3994 +1027 +35233 +2157 +33650 +597 +53 +9384 +43 +286 +3546 +25237 +35234 +28441 +613 +30393 +4055 +35235 +597 +936 +1470 +24207 +35236 +35237 +3067 +586 +35238 +713 +35239 +43 +35240 +27669 +15718 +35241 +1290 +648 +16121 +19618 +35242 +89 +4055 +35243 +43 +35244 +24302 +3546 +8297 +35245 +16826 +35246 +1900 +17920 +35247 +5188 +9 +15261 +19486 +1295 +33627 +2804 +3553 +35248 +20291 +43 +35249 +20443 +35250 +35251 +21947 +29483 +31293 +35252 +35253 +303 +22552 +14947 +2038 +35254 +104 +9941 +28036 +43 +286 +533 +35255 +14369 +4055 +35256 +25865 +26724 +25307 +34402 +15 +6616 +24978 +28757 +337 +25793 +35257 +3814 +790 +20514 +17151 +9 +1090 +35258 +35259 +35260 +872 +35261 +8408 +35262 +27669 +9 +402 +43 +590 +35263 +32858 +31293 +25683 +24303 +35264 +10356 +19 +12178 +30877 +2430 +1047 +915 +35265 +35266 +35267 +4278 +1870 +24972 +430 +35268 +35269 +35270 +8512 +19 +18798 +35271 +35272 +8685 +11754 +31293 +32449 +18310 +13721 +1976 +25316 +586 +19618 +35273 +1203 +35274 +35275 +22666 +35276 +35277 +5908 +16102 +989 +35278 +21758 +248 +2694 +35279 +10264 +35280 +35281 +3546 +15 +22922 +11683 +19 +3546 +1612 +35282 +57 +35283 +21027 +3814 +4116 +3828 +142 +25584 +35284 +18659 +9 +1186 +5119 +35285 +29483 +590 +33120 +21527 +34402 +21947 +1401 +861 +35286 +29483 +35287 +2525 +23691 +14025 +35288 +1529 +27719 +35289 +1716 +35290 +35291 +2029 +1481 +35292 +35293 +32523 +57 +35294 +35295 +7053 +24864 +4547 +12120 +35296 +13905 +286 +22752 +1208 +35297 +35298 +30224 +2832 +1314 +26209 +155 +19 +25584 +9 +2501 +35299 +24864 +32 +35300 +21509 +165 +24021 +248 +19 +35301 +22666 +35302 +35303 +35304 +35305 +35306 +27669 +14562 +1021 +745 +1698 +20 +21947 +31168 +9560 +16437 +1011 +35307 +35308 +24864 +35309 +809 +35310 +89 +35311 +861 +9 +25683 +35312 +35313 +213 +35314 +303 +33120 +35315 +915 +29483 +590 +3546 +21689 +15951 +1870 +590 +2577 +153 +12202 +17422 +35316 +35317 +12432 +4055 +35318 +1090 +21426 +35319 +21947 +35320 +35321 +18654 +17020 +35322 +35323 +20130 +19618 +35324 +665 +1864 +21031 +286 +4055 +9 +35325 +25316 +33120 +2577 +1082 +35326 +4001 +34264 +25237 +19618 +33650 +2318 +35327 +35328 +3546 +35329 +25316 +345 +16437 +24144 +15533 +35330 +13721 +13390 +35331 +35332 +35333 +17497 +2 +14369 +35334 +35335 +35336 +27669 +736 +26861 +1584 +248 +9 +35337 +1924 +8460 +1154 +5925 +14935 +3010 +14 +1112 +35338 +19 +9 +21947 +3376 +35339 +53 +28036 +35340 +35341 +1612 +14888 +35342 +4055 +188 +5075 +3926 +35343 +35344 +1716 +19 +2289 +24144 +35320 +35345 +210 +188 +849 +35346 +1082 +35347 +35348 +17956 +970 +60 +28441 +35349 +35350 +16826 +35351 +14330 +590 +301 +66 +12936 +29483 +27669 +35352 +14477 +3546 +4 +19907 +5431 +345 +284 +35353 +17151 +17714 +19 +77 +213 +323 +32538 +1013 +35354 +3330 +35355 +1090 +26683 +27708 +1090 +35356 +35357 +16437 +6658 +32 +21689 +57 +35358 +337 +35359 +15 +23776 +35360 +7034 +16677 +35361 +4055 +35362 +35363 +209 +337 +140 +234 +34531 +303 +28317 +35364 +284 +4565 +35365 +495 +248 +15517 +3104 +33120 +35366 +35367 +35368 +35369 +35370 +35371 +17349 +7991 +284 +20700 +35372 +22922 +35373 +14369 +35374 +35375 +35376 +4055 +6294 +4765 +14477 +35377 +35378 +35379 +35380 +66 +613 +35381 +35382 +27669 +35383 +9 +43 +103 +35384 +971 +89 +19 +8670 +815 +57 +15 +33120 +35385 +35386 +16389 +34402 +19 +5780 +155 +35387 +35388 +19 +24864 +35389 +13829 +4698 +19 +27954 +3815 +19 +303 +35368 +35390 +25316 +1604 +35391 +25237 +5839 +590 +35392 +13279 +10028 +694 +18154 +713 +35393 +35394 +35395 +30877 +533 +35396 +17635 +35397 +5217 +35398 +7817 +35399 +1991 +31293 +14369 +303 +35400 +35401 +15669 +22989 +35402 +317 +32 +720 +25943 +35403 +15718 +3546 +35404 +35405 +35406 +533 +4634 +35407 +34 +5192 +35408 +14369 +35409 +35410 +4055 +24303 +30917 +25237 +3553 +21947 +35411 +35412 +29200 +35413 +35414 +35415 +21836 +35416 +3202 +15 +16258 +25239 +35417 +19 +19 +331 +2135 +21947 +35418 +8392 +357 +9 +12751 +14856 +6344 +2197 +35419 +21689 +554 +35420 +12987 +35421 +18310 +8372 +35422 +35423 +35424 +3316 +35425 +19 +30877 +35426 +373 +34402 +35427 +35428 +35429 +35430 +33113 +2770 +303 +35431 +21031 +484 +20218 +23442 +35432 +2724 +17571 +35433 +35434 +2310 +19 +142 +345 +35435 +21947 +33963 +30877 +30051 +4634 +19335 +7998 +35436 +31098 +35437 +35438 +25683 +337 +4055 +24666 +35439 +35440 +35441 +35442 +35443 +1300 +24864 +34402 +1867 +284 +35444 +9 +3137 +29 +24725 +28490 +24967 +598 +822 +14369 +43 +35445 +35446 +35447 +10028 +24864 +1021 +495 +35448 +5085 +33434 +284 +29381 +35449 +665 +27669 +349 +35450 +35451 +590 +35452 +35453 +35454 +15718 +19618 +35455 +1330 +464 +24864 +2577 +27669 +35456 +43 +14330 +286 +15989 +32 +2694 +8769 +29434 +35457 +17472 +15718 +2117 +35458 +35459 +35460 +20 +35461 +1091 +9410 +1090 +15367 +28317 +31293 +345 +19 +35462 +683 +9 +28028 +24303 +21573 +35320 +5806 +25237 +35463 +43 +24896 +35464 +35318 +35465 +35466 +35467 +15 +24303 +13721 +35468 +35469 +57 +4055 +35470 +14363 +2 +35471 +35472 +99 +2577 +35473 +1316 +35474 +35475 +35476 +4311 +19 +35477 +13638 +24263 +35478 +35479 +19205 +35480 +574 +1090 +14369 +35481 +16887 +2260 +4944 +35482 +35483 +694 +9 +20 +29381 +3743 +345 +57 +25237 +35484 +1107 +34656 +16443 +35485 +18896 +1376 +35486 +35487 +9 +35488 +2274 +25683 +35489 +14369 +342 +35490 +35491 +35492 +25281 +28753 +4055 +9 +25584 +35493 +30317 +590 +8525 +35494 +495 +29636 +35495 +35496 +35497 +26702 +20290 +35498 +35499 +1010 +736 +1234 +35500 +11471 +33128 +9738 +35501 +21947 +18951 +35502 +35503 +11822 +2733 +590 +12158 +2 +35504 +24303 +25683 +35505 +35506 +345 +66 +35507 +533 +35508 +11003 +35509 +2315 +28247 +35510 +15 +35511 +274 +35512 +736 +21947 +5318 +9 +573 +1208 +35513 +35514 +35515 +35516 +21947 +21947 +35517 +35518 +14330 +8670 +31293 +595 +19 +4055 +35519 +19618 +21031 +595 +509 +19 +7053 +35520 +35521 +35522 +35523 +15718 +35524 +33120 +35525 +3546 +35526 +19655 +249 +29483 +14102 +9 +31488 +5629 +35527 +35528 +35529 +3976 +6505 +19852 +24864 +2853 +25140 +33627 +1107 +25943 +32920 +35530 +363 +32359 +35531 +35532 +35533 +14369 +9 +21791 +1090 +2561 +19579 +14 +35534 +14369 +35535 +1090 +1208 +1090 +89 +4921 +35536 +22308 +971 +35537 +21947 +35538 +57 +35539 +12005 +1310 +35540 +6533 +35541 +25943 +9 +16437 +590 +35542 +35543 +35544 +35545 +35546 +35547 +35548 +29483 +4116 +35549 +18479 +32 +32 +35550 +4247 +809 +34619 +14947 +35551 +6071 +21678 +39 +1157 +33693 +35552 +13913 +201 +24426 +10247 +9 +35553 +35554 +251 +138 +20572 +14712 +5188 +35555 +35556 +35557 +14604 +35558 +12926 +179 +35559 +21947 +8316 +14369 +1604 +566 +197 +9 +373 +21947 +10212 +5773 +1524 +35560 +35561 +35562 +35563 +35564 +27669 +15718 +20471 +30877 +677 +35565 +24045 +590 +736 +43 +15718 +35566 +35567 +19 +35568 +35569 +35570 +25683 +35571 +9 +35572 +29483 +3200 +590 +34402 +35573 +14369 +16 +43 +424 +19091 +35574 +16102 +35575 +35576 +35577 +178 +30224 +887 +35578 +25683 +35579 +33 +176 +35580 +21947 +18503 +21947 +35581 +11469 +35582 +25237 +231 +24303 +17093 +1090 +25242 +14175 +35583 +33278 +770 +3119 +8249 +43 +5780 +1073 +21947 +43 +35584 +694 +209 +35585 +21947 +9 +33650 +35586 +35587 +35588 +35589 +98 +35590 +30877 +35591 +4055 +30877 +13424 +34402 +33627 +29007 +3601 +12 +29 +3119 +35592 +20952 +35593 +35594 +35595 +251 +2 +3442 +35596 +35597 +28494 +2260 +4634 +35598 +4055 +25316 +18695 +96 +5393 +5188 +29956 +35599 +23103 +34212 +5780 +694 +35600 +35601 +1612 +21947 +15 +16375 +33758 +13848 +35602 +35603 +931 +14871 +188 +5394 +14001 +1689 +34804 +21947 +35604 +32816 +28230 +35605 +8053 +9 +43 +31293 +28672 +4364 +19646 +30877 +590 +12552 +35606 +14 +100 +2919 +35607 +9 +20616 +1047 +35608 +1090 +15583 +28199 +1655 +20805 +8967 +1090 +35609 +35610 +4055 +3767 +179 +590 +2694 +16102 +2410 +242 +15718 +35611 +35612 +35613 +8053 +28441 +26945 +33650 +35614 +15206 +35615 +22738 +5004 +13963 +60 +30209 +35616 +35617 +35618 +35619 +3553 +11428 +936 +590 +43 +3984 +15524 +35620 +35621 +33693 +35622 +14340 +2314 +31424 +35623 +27514 +286 +286 +279 +590 +35624 +35625 +35626 +35627 +35628 +35629 +5601 +35630 +140 +21947 +12055 +35631 +35632 +35633 +590 +1563 +27669 +16437 +590 +22552 +31293 +19 +35634 +1529 +76 +19091 +14477 +35635 +736 +4 +671 +35636 +7817 +35637 +1517 +30877 +27669 +35638 +35639 +28036 +35640 +35641 +35642 +43 +1889 +28490 +77 +33674 +7015 +27069 +35643 +20218 +5629 +19 +35644 +10591 +35645 +1090 +35646 +5119 +21309 +35647 +29483 +1715 +14947 +3407 +31293 +35648 +1812 +21947 +1112 +66 +35649 +590 +35650 +35651 +35652 +2314 +397 +1605 +27178 +28441 +20260 +34433 +19655 +31168 +35653 +9953 +35654 +15718 +35655 +2769 +35656 +31293 +35657 +35658 +176 +25683 +6950 +19294 +1157 +27453 +1090 +21689 +35659 +35660 +35661 +35662 +21689 +35663 +3546 +2502 +21885 +730 +35664 +35665 +35666 +43 +35667 +43 +35668 +35669 +2514 +35670 +35671 +22898 +677 +4116 +188 +26638 +35672 +349 +9163 +89 +33650 +2811 +1918 +35673 +35320 +446 +1924 +35674 +5400 +35675 +4795 +43 +35676 +35677 +14186 +15 +35678 +14 +33650 +35679 +5420 +34204 +35680 +590 +25316 +29483 +28441 +35681 +35682 +25943 +35683 +35684 +30551 +43 +19 +9095 +35685 +590 +43 +33627 +35686 +35687 +30307 +35688 +35689 +13666 +5188 +2446 +25316 +27669 +590 +35690 +2561 +24303 +15054 +9 +17165 +35691 +35692 +26159 +35693 +17698 +21698 +35694 +25140 +14630 +9 +35695 +7912 +31873 +35696 +9 +24303 +16803 +5415 +590 +21689 +14482 +101 +35697 +35698 +2872 +2342 +35699 +35700 +4155 +35701 +20 +35702 +39 +20161 +3828 +29032 +9 +1465 +96 +590 +8910 +745 +15081 +3408 +35703 +1013 +10271 +35704 +1817 +2310 +31098 +153 +2694 +33137 +14482 +20825 +24192 +9 +14369 +35705 +3480 +14369 +416 +25943 +35706 +3908 +24896 +554 +25943 +178 +14825 +15471 +178 +57 +35707 +30877 +3104 +35708 +35709 +35710 +11483 +35711 +18553 +2019 +35712 +35713 +11762 +590 +35714 +25584 +17891 +1060 +595 +25237 +4502 +18951 +30580 +209 +25140 +5400 +11966 +249 +77 +16024 +35715 +17897 +345 +35716 +31873 +57 +12371 +35717 +24864 +35718 +27069 +590 +35719 +35720 +30877 +35721 +123 +34433 +14161 +9 +35722 +35723 +35320 +35724 +35725 +24803 +89 +31293 +5085 +10961 +43 +29065 +25683 +4820 +590 +14369 +35726 +7835 +35727 +43 +7891 +28036 +31293 +32438 +21947 +2537 +35728 +35729 +25140 +16437 +9 +32725 +19 +35730 +21698 +7480 +20 +35731 +35732 +43 +9 +4598 +1743 +19 +4028 +5780 +5409 +29527 +60 +35733 +3251 +32410 +18064 +35734 +35735 +5832 +35736 +21947 +286 +35737 +35738 +34402 +35739 +35740 +9 +586 +34964 +21947 +35741 +36 +970 +35742 +7328 +6294 +35743 +15 +12661 +11073 +35744 +2253 +4885 +16466 +35745 +29981 +25683 +736 +19 +33258 +7053 +9 +16975 +21947 +24247 +35746 +35747 +35748 +2023 +35749 +1423 +694 +14604 +35750 +222 +35751 +1090 +35752 +27069 +1738 +18130 +25316 +9 +910 +6029 +25069 +14369 +590 +8392 +35753 +1434 +8967 +35754 +19383 +28961 +15718 +33659 +17670 +35507 +27355 +43 +286 +21102 +7553 +35755 +35756 +14343 +27507 +35757 +25943 +707 +34402 +915 +35758 +21947 +34 +694 +26150 +43 +2625 +16102 +1716 +35759 +6595 +35760 +35761 +35762 +35763 +16085 +35764 +34402 +24303 +35765 +270 +33627 +35766 +590 +35767 +9 +795 +43 +286 +446 +35768 +827 +35769 +1090 +200 +30209 +35770 +35771 +18503 +12417 +24751 +35772 +35773 +18951 +35774 +29483 +13287 +31293 +4055 +1489 +35 +29200 +3908 +35775 +2655 +590 +35776 +35777 +35778 +9 +9941 +33627 +15535 +35779 +32 +35780 +35781 +25316 +25683 +15655 +15 +1920 +35782 +590 +317 +707 +3492 +958 +19 +14330 +646 +554 +22 +18350 +349 +31796 +35783 +35784 +35785 +25 +35786 +16102 +35787 +7855 +35320 +22963 +66 +35788 +15718 +2324 +31293 +8418 +28480 +14330 +19655 +4055 +4398 +35789 +35790 +35791 +21947 +7045 +21027 +342 +35792 +34402 +9561 +35793 +5409 +554 +35794 +8668 +23271 +3598 +27581 +25237 +201 +19 +35795 +10239 +14369 +35796 +112 +14330 +35797 +35798 +5755 +3481 +665 +35799 +250 +3287 +1224 +286 +2006 +185 +301 +5065 +176 +27719 +18331 +155 +43 +35800 +3829 +27669 +33278 +12013 +30877 +1478 +14992 +5188 +1437 +25316 +43 +43 +4055 +35801 +35802 +379 +35803 +5627 +35804 +35805 +33120 +286 +12987 +14604 +9 +178 +35806 +240 +35807 +34 +2 +23651 +31293 +2 +35808 +1415 +7537 +35809 +35810 +3484 +24864 +27669 +2919 +35811 +33368 +677 +35812 +14 +77 +590 +35813 +66 +17058 +590 +35814 +34908 +12987 +35320 +35815 +3842 +19 +35816 +35817 +323 +694 +357 +35481 +35818 +35819 +32782 +14240 +30051 +590 +35820 +24303 +179 +2 +29381 +28549 +8393 +35821 +970 +35822 +10111 +35823 +2253 +35824 +24864 +35825 +15718 +35826 +43 +137 +26724 +35827 +573 +9 +35828 +35829 +13721 +1515 +5780 +19 +15718 +970 +2537 +2619 +30877 +28194 +13721 +10230 +1502 +27140 +35830 +24045 +861 +19 +35831 +13721 +35832 +31293 +35833 +43 +9 +176 +35834 +35829 +30877 +34402 +5085 +1559 +21947 +14688 +14840 +24303 +21027 +18079 +8357 +43 +5075 +31293 +35835 +35836 +35837 +1157 +35838 +25129 +19983 +35839 +27705 +35840 +35841 +35842 +345 +514 +14001 +35843 +9 +590 +35844 +99 +35845 +35846 +15384 +35847 +13570 +28082 +35848 +35849 +34402 +35850 +11593 +24253 +35851 +17553 +35852 +683 +286 +35853 +33120 +2537 +35854 +29483 +35855 +115 +169 +46 +25237 +16511 +27954 +17151 +5085 +35856 +5197 +35857 +342 +35858 +14962 +33553 +27329 +1415 +9 +35859 +32518 +98 +30051 +590 +24864 +9460 +35860 +35861 +35862 +15428 +16102 +14827 +28441 +3553 +15 +35863 +352 +26496 +1139 +35864 +35865 +2476 +35866 +8798 +33758 +446 +590 +35867 +1056 +35868 +16437 +9 +327 +27669 +35869 +35870 +35871 +13538 +1100 +35872 +35873 +17864 +35874 +9 +1870 +57 +26323 +14 +12404 +35875 +14 +1524 +35876 +971 +35877 +35878 +29483 +43 +35879 +15 +35880 +35881 +286 +207 +15 +35882 +21947 +35883 +823 +671 +35884 +936 +27798 +4752 +27069 +1924 +25683 +1533 +352 +43 +155 +23103 +18982 +1300 +35885 +15989 +19 +35886 +8717 +35887 +10601 +35888 +25237 +35889 +2804 +26787 +30969 +6161 +9 +15 +7019 +8756 +13721 +35890 +35891 +35892 +14 +35893 +3 +35894 +209 +12916 +35895 +989 +2694 +35896 +35897 +815 +1189 +590 +6251 +35898 +2310 +27669 +576 +35899 +24864 +616 +17911 +4693 +35900 +1249 +35901 +24862 +15718 +19 +17911 +3546 +29200 +4055 +188 +15666 +35902 +970 +9871 +29483 +16618 +35903 +590 +35904 +1172 +35905 +35906 +12936 +21947 +35907 +35908 +26946 +2064 +25237 +12240 +35909 +28317 +286 +19091 +2410 +43 +19 +35910 +21031 +27669 +52 +20 +4803 +21947 +514 +35911 +201 +671 +25140 +7835 +35912 +5085 +29381 +35913 +1364 +35914 +35915 +2243 +4055 +35916 +35917 +21006 +26361 +22963 +33693 +10643 +25133 +35918 +29424 +31293 +5780 +10979 +23103 +35919 +9 +5021 +6766 +29721 +32805 +35920 +377 +8756 +35921 +35922 +35923 +1090 +25683 +22109 +35844 +1566 +3213 +341 +24303 +35924 +33650 +9 +35925 +14435 +399 +34402 +35926 +29483 +26666 +33113 +14909 +35927 +35928 +1442 +35929 +3055 +9 +29483 +4055 +14477 +35930 +25140 +16437 +35931 +35932 +17151 +10239 +35933 +35934 +31293 +31293 +35935 +703 +13365 +35936 +35937 +14369 +548 +32 +35938 +35939 +4908 +554 +35940 +35320 +18695 +3353 +677 +8961 +2694 +29629 +30877 +35941 +31293 +35942 +43 +2769 +823 +259 +28116 +35943 +35944 +35945 +26744 +35946 +35947 +35948 +35949 +14001 +35950 +9210 +35951 +270 +1090 +35952 +209 +5908 +35953 +11593 +35954 +416 +10601 +35955 +35956 +590 +35957 +35958 +5085 +970 +1710 +35959 +7813 +573 +29483 +1090 +35960 +9953 +1234 +19 +35961 +590 +24303 +32449 +35962 +35963 +34433 +22607 +14477 +35964 +43 +35965 +14669 +9 +209 +14942 +137 +27525 +24045 +21729 +6095 +14477 +35966 +35967 +30877 +35968 +35969 +1976 +2561 +495 +9 +32 +35970 +35773 +35971 +20442 +1316 +7912 +35972 +35973 +35974 +3 +15718 +26069 +25659 +35975 +29687 +35976 +27024 +35977 +25061 +12555 +35978 +19 +35979 +43 +1100 +19 +35980 +7480 +35981 +35982 +30877 +2314 +35983 +3407 +317 +35984 +272 +35985 +35986 +35987 +35988 +21947 +19 +8849 +869 +35989 +9 +1808 +35990 +14103 +20138 +1834 +28490 +35991 +4055 +35992 +35993 +35994 +1604 +27262 +25237 +29628 +2356 +3003 +35995 +35996 +1531 +25316 +613 +13304 +2136 +35997 +35998 +4658 +35999 +19618 +1575 +15298 +43 +15718 +36000 +36001 +36002 +21947 +36003 +19 +2619 +36004 +29204 +28186 +379 +36005 +11176 +36006 +36007 +36008 +1425 +36009 +15035 +36010 +9 +36011 +36012 +1013 +13721 +22963 +36013 +25300 +36014 +42 +36015 +36016 +20952 +16328 +30224 +36017 +10 +19372 +14299 +29483 +36018 +16437 +4775 +36019 +36020 +36021 +33627 +19618 +36022 +24678 +7191 +36023 +9258 +19009 +31293 +32564 +10853 +14369 +28307 +1790 +36024 +36025 +36026 +36027 +2537 +36028 +36029 +3755 +5780 +12827 +36030 +36031 +9 +2463 +36032 +26496 +29800 +576 +5188 +36033 +24303 +36034 +36035 +36036 +36037 +16 +25528 +33444 +36038 +29597 +36039 +317 +1090 +36040 +36041 +36042 +1082 +21947 +27669 +36043 +14369 +12185 +338 +686 +36044 +36045 +36046 +36047 +43 +22 +861 +5344 +4367 +36048 +36049 +36050 +25316 +21947 +36051 +31873 +24303 +943 +24303 +29145 +3976 +15 +1090 +36052 +14477 +17549 +13529 +4938 +12198 +13680 +36053 +9561 +1615 +1013 +29938 +32 +36054 +36055 +36056 +36057 +248 +32402 +970 +286 +36058 +36059 +36060 +36061 +36062 +25140 +34346 +36063 +201 +4624 +1021 +141 +17356 +36064 +36065 +248 +1745 +27669 +337 +43 +17956 +317 +43 +13317 +14477 +14477 +28036 +36066 +30877 +1812 +33368 +19 +34641 +36067 +36068 +1013 +2814 +19 +31346 +36069 +25237 +3994 +18350 +27669 +36070 +15989 +35427 +21027 +8297 +21689 +36071 +98 +36072 +36073 +36074 +115 +36075 +13905 +32402 +36076 +14342 +36077 +14369 +36078 +1090 +36079 +1116 +248 +14369 +36080 +495 +2019 +36081 +4502 +398 +36082 +18844 +36083 +2324 +1710 +36084 +36085 +36086 +6116 +3546 +337 +5085 +178 +9163 +21947 +16798 +36087 +36088 +36089 +36090 +36091 +4463 +1090 +36092 +349 +303 +77 +2410 +14553 +36093 +27387 +1637 +12371 +36094 +34957 +19 +20 +30877 +373 +736 +6627 +36095 +17151 +36096 +36097 +30224 +831 +7176 +36098 +36099 +2577 +36100 +77 +36101 +11483 +29 +1562 +36102 +14947 +213 +36103 +337 +31474 +345 +337 +36104 +21947 +24303 +590 +30040 +8282 +3964 +736 +36105 +338 +36106 +43 +5085 +164 +9 +30877 +33627 +15 +43 +554 +1090 +36107 +36108 +590 +14369 +284 +303 +36109 +36110 +36111 +20 +13207 +533 +24864 +1090 +36112 +9 +43 +1090 +3657 +36113 +11171 +36114 +6571 +28441 +29381 +1605 +14330 +57 +26577 +568 +89 +36115 +36116 +36117 +36118 +36119 +3186 +32642 +36120 +36121 +303 +34181 +1090 +31293 +36122 +31603 +36123 +2525 +36124 +36125 +19318 +27719 +36126 +25237 +36127 +4885 +14369 +1224 +25237 +3569 +213 +9 +270 +7615 +36128 +31098 +2694 +9396 +36129 +27599 +342 +1090 +27669 +36130 +14079 +36131 +34402 +36132 +25 +5229 +33120 +36133 +28441 +20 +31225 +14369 +36134 +36135 +17730 +22412 +2616 +915 +36136 +345 +3335 +17151 +1710 +29402 +114 +213 +36137 +9 +36138 +12597 +60 +554 +2195 +36139 +22986 +36140 +21088 +36141 +3994 +9 +6505 +19907 +887 +36142 +3978 +1361 +13721 +36143 +24303 +36144 +377 +36145 +15718 +36146 +2619 +30917 +36147 +36148 +36149 +1090 +36150 +36151 +36152 +590 +4 +36153 +24154 +29544 +7053 +11026 +2525 +23103 +36154 +19 +3546 +5780 +36155 +36156 +14013 +13539 +57 +3546 +36157 +3546 +14369 +36158 +24864 +6054 +1637 +36159 +2206 +36160 +35568 +36161 +3601 +36162 +16466 +9543 +16242 +36163 +19 +358 +28441 +36164 +201 +1090 +491 +1508 +36165 +8668 +13807 +2577 +17151 +36166 +24303 +1089 +36167 +36168 +1090 +36169 +15705 +1090 +872 +19 +31668 +1712 +36170 +1688 +36171 +15718 +3435 +36172 +36173 +43 +5904 +1867 +25316 +1157 +36174 +27719 +4002 +36175 +24864 +36176 +1157 +29561 +36177 +35320 +20768 +43 +17136 +36178 +15226 +201 +19618 +98 +2567 +57 +809 +36179 +30224 +36180 +36181 +27954 +9629 +28036 +27538 +13359 +590 +36182 +590 +17151 +36183 +31293 +36184 +9 +1364 +33627 +43 +7053 +36185 +5188 +9 +3546 +13908 +30877 +345 +23103 +36186 +66 +36187 +36188 +26613 +36189 +36190 +36191 +36192 +36193 +34402 +519 +5833 +36194 +317 +25 +9 +14369 +554 +15 +25455 +19618 +28923 +14330 +2882 +36195 +29381 +19 +30877 +15938 +36196 +3484 +197 +36197 +519 +323 +36198 +43 +2406 +17151 +566 +36199 +21746 +137 +36200 +11008 +14947 +36201 +36202 +1429 +36203 +36204 +77 +36205 +25382 +1229 +15 +1870 +36206 +36207 +8249 +36208 +19 +15 +36209 +21947 +21689 +386 +8042 +6595 +43 +19 +597 +58 +29981 +13996 +23190 +1524 +736 +43 +15718 +317 +36210 +36211 +36212 +20510 +33099 +18707 +36213 +17151 +9934 +36214 +36215 +36216 +36217 +3067 +36218 +16560 +14887 +9 +2694 +436 +26357 +795 +18107 +59 +656 +178 +16 +1090 +34402 +36219 +36220 +303 +36221 +9 +36222 +19 +43 +36223 +43 +242 +971 +36224 +990 +1562 +21261 +646 +15718 +36225 +21698 +36226 +464 +17151 +201 +123 +36227 +36228 +2865 +123 +10349 +36229 +36230 +36231 +36232 +20600 +13465 +36233 +20571 +33838 +25097 +36234 +598 +36235 +10156 +36236 +15597 +2865 +36237 +3867 +36238 +25683 +36239 +23103 +15 +34337 +3764 +24864 +3317 +60 +4166 +597 +36240 +36241 +1090 +915 +14369 +1384 +590 +446 +36242 +31293 +36243 +18940 +43 +6214 +36244 +36245 +1870 +27355 +1612 +36246 +34402 +14369 +677 +27069 +31346 +36247 +36248 +9 +34 +43 +33120 +33330 +36249 +36250 +15718 +14 +15718 +27669 +36251 +36252 +25659 +36253 +14102 +15718 +31168 +29204 +4521 +36254 +201 +841 +24303 +2314 +36255 +36256 +1018 +19 +26414 +36257 +36258 +36259 +36260 +89 +19209 +14369 +29483 +21863 +36261 +43 +36262 +36263 +36264 +36265 +36266 +21045 +845 +1112 +32 +43 +36267 +36268 +1842 +30650 +24896 +533 +36269 +115 +12180 +22963 +5780 +36270 +658 +16121 +36271 +14369 +3369 +34650 +1829 +736 +36272 +720 +2694 +25659 +179 +36273 +36274 +32 +36275 +36276 +26209 +18242 +3598 +36277 +536 +36278 +36279 +4502 +36280 +1605 +9 +36281 +22256 +9 +3553 +17382 +887 +3567 +36282 +36283 +24725 +36284 +36285 +36286 +19 +36287 +736 +9 +3081 +35320 +36288 +590 +265 +43 +1885 +36289 +19918 +3484 +339 +14330 +36290 +36291 +4 +13748 +36292 +36293 +17228 +1920 +21947 +34402 +36294 +30224 +25237 +36295 +36296 +36297 +36298 +827 +19 +36299 +30224 +36300 +36301 +24144 +36302 +14001 +18896 +14001 +849 +3978 +36303 +115 +24862 +36304 +9 +36305 +736 +2619 +736 +36306 +554 +36307 +3330 +19 +36308 +9 +36309 +15718 +1901 +36310 +24045 +36311 +32984 +76 +43 +36312 +16826 +57 +36313 +43 +1011 +36314 +15718 +36315 +32 +1454 +14204 +15 +768 +36316 +29716 +36317 +15 +58 +36318 +188 +24144 +43 +2 +35458 +14363 +736 +14 +14342 +17326 +31293 +36319 +7835 +36320 +36321 +14369 +36322 +24864 +15298 +13140 +28317 +36323 +36324 +25943 +36325 +24144 +36326 +5963 +172 +36327 +36328 +31293 +19618 +209 +36329 +36330 +1169 +2260 +9 +22 +140 +8896 +345 +4 +30877 +24725 +36331 +17911 +36332 +345 +25316 +36333 +5539 +14061 +1090 +5117 +36334 +35409 +2728 +34375 +19750 +21947 +21251 +36335 +10505 +1222 +590 +25 +22818 +36336 +2576 +27669 +43 +30051 +33627 +8986 +21689 +36337 +19858 +36338 +36339 +36340 +6519 +36341 +36342 +19 +7601 +36343 +32871 +5253 +30051 +35104 +6263 +29483 +5014 +1716 +36344 +21947 +36345 +36346 +36347 +20745 +19852 +25943 +11966 +32 +1107 +1870 +9 +14477 +14260 +5780 +36348 +18830 +5431 +369 +36349 +36350 +53 +36351 +10791 +4364 +30373 +36352 +4531 +36353 +34402 +18782 +141 +16429 +2733 +4055 +26361 +2314 +342 +3546 +21791 +36354 +36355 +6624 +19 +590 +2406 +57 +36356 +415 +36357 +36358 +179 +33627 +36359 +43 +4055 +201 +36360 +10789 +14330 +286 +915 +29 +27669 +36361 +13721 +36362 +25140 +36363 +14369 +36364 +36365 +15718 +19218 +14814 +36366 +3958 +31098 +36367 +8342 +342 +9 +36368 +36369 +36370 +36371 +36372 +36373 +26559 +28441 +20443 +23588 +1870 +265 +36374 +19 +176 +109 +24864 +25316 +9 +36375 +36376 +137 +3061 +1172 +9 +36377 +36378 +23103 +17698 +12989 +36379 +36380 +10 +36381 +36382 +8896 +1680 +1234 +1514 +34650 +36383 +36384 +671 +36385 +590 +29628 +36386 +15 +13843 +9 +67 +15 +23103 +20187 +178 +14001 +16798 +676 +36387 +14 +36388 +36389 +34850 +36390 +17151 +9 +43 +33627 +36391 +751 +36392 +1116 +2733 +27599 +36393 +5169 +28923 +14363 +25776 +36394 +3050 +1604 +36395 +12480 +9 +845 +36396 +36397 +36398 +32 +21947 +57 +354 +36399 +34402 +15 +36400 +21647 +1716 +36401 +415 +17151 +57 +36402 +36403 +7157 +36404 +43 +104 +12180 +2561 +12343 +15 +17941 +26484 +36405 +2164 +32253 +9481 +15718 +36406 +4528 +9 +6710 +9 +36407 +29381 +36408 +9941 +25140 +36409 +379 +36410 +11469 +936 +736 +36411 +36412 +13943 +36413 +1566 +8110 +14369 +33120 +1310 +3743 +228 +7835 +36414 +36415 +36416 +15437 +36417 +24303 +7053 +4055 +36418 +2936 +36419 +36420 +36421 +415 +9 +30650 +14369 +28502 +36422 +36423 +2694 +36424 +7 +36425 +25584 +36426 +11321 +345 +23103 +586 +29981 +11571 +33627 +36427 +815 +7471 +26125 +3553 +9 +13721 +1090 +36428 +36429 +36430 +7208 +4055 +43 +7107 +34 +26559 +349 +3104 +36431 +345 +36432 +36433 +345 +36434 +12518 +18588 +36435 +31293 +36436 +349 +29381 +104 +2902 +1508 +36437 +1021 +30224 +12987 +3546 +36438 +286 +36439 +5394 +57 +3317 +24864 +36440 +33501 +36441 +24303 +19 +36442 +36443 +16056 +14369 +19 +36444 +36445 +32410 +24207 +14363 +14343 +72 +15 +36446 +8351 +25683 +10910 +491 +27669 +36447 +541 +23176 +2356 +27508 +36448 +36449 +36450 +279 +2197 +43 +21947 +365 +701 +36451 +23921 +4055 +36452 +35352 +36453 +27669 +36454 +36455 +3842 +176 +36456 +36457 +31873 +36458 +2476 +36459 +36460 +399 +36461 +36462 +36463 +36464 +141 +25237 +17602 +43 +17149 +9 +705 +845 +36465 +18787 +27669 +36466 +345 +36467 +33 +31346 +36468 +27669 +36469 +23970 +36470 +20 +36471 +9 +36472 +17150 +6571 +25632 +36473 +19618 +3546 +3236 +16 +36474 +15718 +484 +3059 +6317 +43 +15718 +533 +36475 +14571 +36476 +25237 +1870 +36477 +36478 +31293 +590 +671 +25683 +491 +36479 +36480 +910 +36481 +36482 +30458 +33494 +36483 +21829 +36484 +28549 +36485 +36486 +11273 +15718 +36487 +43 +23322 +36488 +15 +98 +36489 +14604 +7107 +11774 +34264 +33627 +713 +194 +1810 +36490 +36491 +5780 +13566 +17151 +36492 +1384 +36493 +11822 +25943 +491 +4033 +36494 +33650 +14330 +36495 +286 +25316 +25 +3059 +590 +36496 +36497 +36498 +36499 +6829 +1107 +590 +349 +36500 +36501 +8774 +36502 +36503 +34181 +357 +27069 +36504 +36505 +29284 +14369 +317 +17670 +36506 +36507 +12166 +19618 +30224 +36508 +554 +36509 +21280 +590 +15718 +36510 +25053 +36511 +22 +3484 +15718 +19 +36512 +27669 +36513 +27798 +1116 +286 +12987 +15 +36514 +15 +36515 +12299 +89 +4441 +9 +7725 +36516 +33120 +33508 +36517 +7991 +28392 +872 +21947 +1508 +1090 +36518 +1100 +1696 +745 +36519 +36520 +5415 +31041 +21958 +36521 +21947 +566 +36522 +16325 +58 +28402 +34628 +30051 +57 +36424 +36523 +3148 +14679 +9 +3 +36524 +27669 +36525 +36526 +17670 +36527 +3546 +6595 +597 +699 +10123 +9 +36528 +8821 +36529 +34181 +20514 +3196 +484 +12646 +15718 +11321 +36530 +36531 +36532 +4982 +36533 +36534 +9410 +2061 +30877 +36535 +36536 +138 +32 +36537 +19 +3599 +36251 +34402 +33278 +5344 +36538 +27835 +19 +5409 +15718 +89 +27954 +36539 +7154 +36540 +9 +25237 +36541 +16866 +36542 +3994 +11593 +36543 +8096 +1090 +17151 +536 +5791 +915 +15718 +1688 +745 +970 +29483 +861 +1100 +36177 +1465 +32 +19579 +2367 +36544 +36545 +28219 +3553 +36546 +36547 +14369 +15 +14000 +36548 +1720 +4307 +3553 +1547 +36549 +33758 +1920 +12621 +36550 +17911 +13907 +30068 +586 +43 +36551 +6096 +745 +14 +32538 +57 +809 +16121 +36552 +36553 +3546 +31293 +11960 +936 +36554 +3491 +30224 +30224 +36555 +36556 +36557 +36558 +22752 +24 +22963 +14604 +26040 +30877 +36559 +66 +43 +9 +36560 +1524 +2206 +27277 +27684 +36561 +36562 +14616 +35546 +761 +60 +4897 +4468 +36563 +10147 +36564 +1615 +18311 +8146 +23442 +242 +36565 +228 +21188 +4279 +20 +18479 +2561 +6996 +20339 +358 +36566 +33890 +36567 +36568 +6505 +16589 +5316 +36569 +27141 +36570 +736 +36571 +970 +36572 +19655 +1605 +22082 +36573 +36574 +57 +32359 +36575 +16798 +36576 +19 +36577 +36578 +30877 +25140 +3296 +33120 +36579 +1013 +36580 +28961 +9 +36581 +36582 +23103 +590 +2476 +694 +1364 +36583 +4364 +573 +14001 +77 +31441 +36584 +222 +1502 +36585 +6950 +36586 +282 +36587 +36588 +21947 +20798 +27205 +197 +9 +24144 +36589 +2694 +33494 +1464 +36590 +31293 +590 +36591 +4055 +822 +249 +36592 +13452 +26484 +36593 +8668 +3553 +9 +36594 +21947 +20 +1444 +36595 +18077 +36596 +16678 +33278 +36597 +536 +4344 +5313 +36598 +533 +36599 +1384 +3886 +14369 +34402 +349 +1307 +36600 +30650 +14001 +4650 +19903 +541 +36601 +36602 +30177 +17151 +1291 +29844 +36603 +23103 +28317 +1056 +815 +36604 +590 +36605 +36606 +5145 +15647 +24864 +5627 +11966 +36607 +26604 +36608 +46 +36609 +2136 +36610 +36611 +15718 +21027 +474 +36612 +442 +3546 +36613 +33627 +815 +36614 +22922 +19 +26295 +25102 +19 +36615 +36616 +36617 +2926 +7964 +201 +30209 +39 +18045 +30877 +188 +7451 +36618 +27669 +16826 +19 +554 +30877 +36619 +5780 +1559 +36620 +31293 +33650 +36621 +36622 +33494 +13905 +36623 +345 +36624 +915 +36625 +179 +66 +36626 +36627 +9 +1090 +36628 +19 +66 +15718 +14363 +27669 +23603 +4055 +21947 +197 +36629 +36630 +36631 +36177 +25659 +8188 +29381 +21947 +484 +16096 +36632 +25316 +34532 +36633 +33061 +1107 +36634 +36635 +1262 +77 +36636 +15718 +9 +36637 +36638 +36639 +1682 +30458 +36640 +36641 +3546 +21947 +36642 +1082 +36643 +32 +36644 +11762 +19 +10 +36645 +8137 +4116 +19 +30051 +3999 +36646 +27669 +36647 +616 +2040 +36648 +36649 +6054 +613 +36650 +13566 +13721 +14363 +36651 +36652 +36653 +36654 +57 +411 +6116 +7053 +15536 +1920 +43 +1316 +36655 +15 +10356 +24864 +20745 +24303 +34402 +1559 +4055 +28961 +36656 +36657 +822 +27669 +286 +16437 +36658 +339 +185 +9 +5780 +31234 +36659 +827 +36660 +23103 +29381 +36661 +60 +36662 +36663 +33650 +19 +201 +24864 +18553 +140 +142 +36664 +36665 +155 +36666 +745 +21947 +20 +3059 +12 +36667 +36668 +7154 +15718 +5188 +36669 +36670 +201 +29200 +16 +4 +21947 +16290 +1745 +36671 +19 +24303 +4982 +11995 +971 +36672 +286 +24864 +9 +1228 +36673 +1720 +671 +19852 +31293 +36674 +19 +20514 +28961 +415 +250 +25584 +21689 +14330 +7600 +2 +2694 +23103 +36675 +665 +15 +36676 +20 +14751 +17670 +590 +36677 +286 +19 +9999 +2164 +17259 +36678 +11624 +323 +36679 +36680 +36681 +36682 +36683 +338 +20005 +5188 +32 +865 +14856 +36684 +590 +9 +43 +36685 +36686 +36687 +19907 +33061 +36688 +36689 +36690 +36691 +24864 +66 +18951 +1563 +4 +2500 +13323 +36692 +36693 +32449 +9 +21947 +474 +32 +1230 +53 +36694 +2561 +24864 +1090 +1870 +30877 +9 +36695 +77 +36696 +16437 +19 +3546 +3546 +3385 +30877 +17151 +23743 +554 +36697 +5188 +345 +613 +1112 +31293 +554 +415 +22963 +15 +30877 +736 +36698 +36699 +19794 +5966 +11966 +5623 +13323 +36700 +31433 +36701 +57 +23103 +36702 +25943 +36703 +25584 +29381 +36704 +1423 +301 +21226 +36705 +36706 +36707 +30877 +6518 +36708 +1961 +1244 +12124 +36709 +36710 +24725 +33650 +8967 +14947 +2865 +1384 +35427 +201 +12956 +5297 +694 +36711 +4452 +411 +36712 +36713 +197 +590 +21947 +36714 +2015 +35052 +1115 +4055 +18503 +21791 +8392 +36715 +32523 +25 +936 +5188 +14001 +9 +36716 +36717 +28317 +19 +5085 +9 +2694 +16466 +30877 +27117 +1524 +29527 +21947 +36718 +36719 +30877 +36720 +2476 +36721 +12987 +29483 +36722 +7379 +36723 +768 +6010 +8249 +9 +36724 +36725 +33494 +30877 +590 +19797 +590 +936 +586 +36726 +13279 +21266 +36727 +20 +1596 +36728 +1369 +278 +36729 +36730 +2254 +36731 +4441 +43 +7071 +15718 +36732 +43 +20 +27669 +36733 +31293 +16422 +31691 +36734 +16826 +36735 +76 +22 +15914 +21028 +35547 +1716 +1444 +942 +36736 +36737 +19852 +36738 +484 +286 +2655 +677 +36739 +13943 +14 +349 +36740 +586 +21947 +36741 +13260 +3546 +36742 +2330 +7154 +30877 +31139 +36743 +33627 +14369 +36744 +2764 +17151 +36745 +36746 +14477 +590 +25584 +66 +11624 +286 +1961 +36747 +1942 +36748 +36749 +36750 +36751 +1090 +36752 +43 +2460 +36753 +17144 +12987 +16329 +36754 +7399 +29981 +53 +36755 +2694 +33061 +36756 +36757 +15718 +286 +20933 +22 +8554 +861 +286 +114 +36758 +36759 +2314 +36760 +17151 +24303 +9246 +1961 +36761 +4820 +24303 +14 +3601 +36762 +15 +36763 +15 +5188 +1169 +12987 +36764 +36765 +2561 +25364 +16121 +25584 +23103 +590 +6950 +19655 +36766 +861 +4502 +36218 +36767 +2009 +33673 +14369 +5886 +21947 +36768 +14604 +2762 +36769 +5409 +4238 +36770 +36771 +36772 +76 +910 +303 +36773 +26361 +33627 +9 +26744 +3477 +99 +352 +7053 +36774 +36775 +1738 +331 +703 +13721 +1051 +36776 +9573 +5188 +35400 +213 +11341 +495 +2254 +30877 +495 +16466 +57 +3858 +15718 +28317 +178 +15824 +33650 +377 +4002 +31293 +20058 +1244 +9 +14369 +36777 +248 +12055 +36778 +1295 +415 +21947 +28317 +36779 +36780 +3976 +36781 +31225 +19618 +36782 +36783 +1606 +36784 +36785 +36786 +36787 +373 +36788 +36789 +21681 +36790 +15 +36791 +36792 +36793 +337 +19209 +29483 +30650 +4634 +36794 +36795 +1090 +36796 +827 +12 +36797 +27669 +11321 +36798 +36799 +3912 +36800 +36674 +5188 +36801 +28559 +19653 +30877 +36802 +5316 +2064 +36803 +43 +16437 +25316 +25237 +24864 +25140 +751 +36804 +36805 +36806 +15 +554 +20 +1021 +15718 +9 +19 +36807 +36808 +33890 +36809 +248 +23103 +12819 +4055 +14369 +36810 +32642 +248 +3491 +1425 +1300 +7364 +16820 +36811 +31225 +22963 +16443 +43 +4055 +36812 +8208 +7658 +36813 +43 +1531 +34402 +36814 +36815 +13535 +36816 +36817 +36818 +36819 +2356 +36820 +57 +36821 +3553 +19 +43 +36822 +1090 +646 +1502 +43 +36823 +36824 +35389 +491 +27669 +1907 +303 +13904 +36825 +9 +34233 +2581 +1090 +4155 +36826 +36827 +11754 +27669 +36828 +28272 +36829 +514 +3546 +713 +1195 +3353 +36830 +1882 +5773 +32880 +19 +3543 +36831 +36832 +4055 +36833 +15331 +19618 +30051 +36834 +30051 +57 +34264 +3546 +32 +30051 +36835 +36836 +1558 +23103 +1224 +36837 +36735 +24303 +36838 +36839 +31293 +27079 +36840 +283 +33890 +36841 +4055 +36842 +34402 +1090 +36843 +1011 +337 +9 +736 +12987 +24303 +36844 +30224 +23495 +1257 +337 +36845 +7053 +590 +36846 +36847 +19 +36848 +18439 +6051 +1310 +36849 +36850 +36851 +10262 +31160 +36852 +4502 +31691 +2561 +2694 +36424 +27669 +43 +36853 +736 +36854 +36855 +36856 +36857 +28317 +5650 +77 +30224 +33 +57 +36858 +36639 +30747 +27117 +36859 +29200 +1013 +19 +2957 +36860 +1051 +31576 +590 +19 +36861 +3 +25584 +36862 +5582 +1539 +24998 +1208 +26142 +861 +36863 +31168 +36864 +590 +2166 +1107 +13375 +36865 +15 +12194 +57 +27669 +27095 +2694 +533 +736 +5780 +115 +30983 +1091 +36866 +36867 +15718 +736 +4055 +354 +36868 +36869 +36870 +21947 +33280 +36871 +60 +29791 +6840 +36872 +36873 +36874 +53 +31109 +21947 +36875 +36876 +19 +25140 +736 +36877 +5045 +36878 +36879 +398 +1870 +66 +9976 +16466 +36328 +36880 +36881 +16066 +14340 +14369 +36882 +36883 +14947 +1090 +845 +11762 +6627 +26361 +14909 +33650 +12020 +28317 +554 +36884 +7855 +36885 +1349 +32 +36886 +36887 +36888 +25 +4055 +492 +248 +25237 +43 +495 +27669 +36889 +36890 +415 +43 +1090 +19 +36891 +29483 +28441 +665 +9497 +36892 +24725 +4787 +358 +25316 +20514 +43 +36893 +19 +36894 +14330 +1100 +36895 +1018 +27669 +43 +29200 +869 +354 +36896 +36897 +36898 +21947 +19 +36899 +36900 +439 +3546 +19 +36901 +14731 +536 +36902 +36903 +1920 +3842 +31098 +1349 +36904 +36905 +303 +3546 +20329 +15413 +2728 +8146 +36906 +887 +36907 +27117 +210 +17151 +36908 +12987 +15 +3546 +1090 +36909 +36910 +36911 +464 +36912 +36913 +36914 +590 +31225 +1090 +36915 +1100 +646 +3546 +705 +31098 +36916 +14001 +36917 +36918 +21089 +2782 +43 +16375 +36919 +36920 +1090 +36921 +248 +2865 +3484 +6306 +12096 +66 +29628 +1090 +590 +30051 +179 +36922 +3546 +36923 +46 +1011 +1508 +2561 +345 +25395 +16 +4 +958 +36924 +5409 +36925 +22556 +36926 +6785 +590 +2577 +104 +17151 +25281 +36927 +3994 +30051 +2769 +36928 +4236 +2913 +36929 +210 +4806 +648 +1524 +484 +15647 +36930 +495 +272 +20339 +21027 +1967 +36931 +36932 +19111 +32 +13829 +958 +31293 +36933 +29931 +19549 +36934 +34402 +24303 +1855 +10280 +5041 +4055 +720 +20853 +586 +36935 +19 +665 +286 +19618 +16466 +66 +13566 +43 +34602 +36936 +35888 +4028 +36937 +36938 +2 +44 +36939 +2593 +18517 +29483 +2324 +20443 +33650 +11715 +36940 +36941 +9460 +32496 +7666 +36942 +17151 +3353 +36943 +36944 +36945 +6595 +36946 +4055 +2349 +57 +4388 +25584 +16437 +17687 +36947 +4702 +98 +1154 +29204 +36735 +28317 +36948 +36949 +21947 +1245 +18982 +15498 +16 +36950 +36951 +36952 +36953 +514 +274 +7923 +36954 +9 +29483 +23302 +13517 +1716 +57 +9 +9 +36955 +8465 +36956 +36957 +179 +36958 +2274 +36959 +36960 +7053 +36735 +36961 +14001 +14 +43 +36962 +36963 +9 +5287 +36964 +43 +14369 +5849 +730 +36965 +36966 +16024 +36967 +11770 +303 +29381 +528 +19 +36968 +36969 +36970 +16437 +33650 +1082 +89 +14369 +286 +5409 +36971 +349 +1090 +8171 +36972 +36973 +30877 +29628 +36974 +3686 +36975 +2709 +19 +36976 +12005 +2728 +36977 +19 +14369 +36978 +9 +36979 +36980 +57 +2427 +1295 +36981 +21045 +3764 +36982 +19 +2260 +509 +24864 +1090 +36983 +43 +18695 +21781 +36424 +17092 +36984 +21689 +28549 +36985 +19 +30051 +29628 +23322 +26040 +48 +36986 +13113 +720 +35624 +32984 +6439 +36987 +27708 +36988 +36989 +1817 +36990 +36991 +1018 +345 +1090 +36992 +36993 +2197 +31293 +36994 +24765 +6067 +828 +14019 +36995 +16826 +17529 +36996 +19 +248 +29109 +14102 +24864 +36997 +33494 +31293 +18896 +15 +36998 +2314 +36999 +37000 +1765 +31382 +37001 +18345 +43 +590 +36424 +24045 +27669 +761 +33627 +2309 +37002 +37003 +31293 +3599 +43 +16292 +37004 +558 +5582 +491 +19 +4461 +1615 +37005 +37006 +37007 +736 +1870 +33445 +16239 +33615 +37008 +1224 +32 +21947 +15194 +37009 +5188 +2187 +337 +46 +37010 +37011 +12020 +26895 +26599 +14330 +37012 +7987 +9440 +19287 +37013 +22684 +37014 +30230 +29204 +815 +3858 +25829 +2865 +31098 +37015 +37016 +37017 +37018 +23352 +37019 +3546 +37020 +5085 +27069 +683 +337 +416 +37021 +37022 +19618 +28000 +1559 +27875 +37023 +2059 +37024 +34583 +337 +286 +342 +37025 +2325 +2410 +720 +19091 +37026 +31293 +37027 +7053 +37028 +7123 +37029 +671 +4055 +20700 +5780 +238 +37030 +37031 +37032 +11424 +354 +37033 +37034 +1716 +1090 +37035 +89 +1481 +21947 +21947 +34113 +491 +37036 +37037 +37038 +13150 +5313 +37039 +30877 +37040 +958 +2694 +2488 +14 +613 +33650 +29381 +37041 +37042 +284 +37043 +24864 +18448 +278 +30794 +2581 +37044 +33758 +37045 +15 +533 +29204 +3546 +4581 +37046 +37047 +342 +98 +37048 +37049 +1688 +538 +10174 +37050 +665 +36424 +25316 +13566 +37051 +37052 +4055 +37053 +37054 +8967 +2281 +37055 +37056 +28317 +37057 +34342 +20113 +37058 +1090 +37059 +37060 +536 +37061 +37062 +201 +37063 +3543 +936 +37064 +349 +37065 +1559 +3999 +30877 +29204 +37066 +185 +365 +37067 +37068 +37069 +29540 +37070 +37071 +34627 +31293 +17480 +17121 +37072 +2804 +1090 +37073 +37074 +14553 +57 +37075 +24864 +1765 +37076 +9 +37077 +349 +3597 +10356 +6364 +37078 +7619 +823 +625 +24144 +5827 +37079 +12684 +590 +13463 +19 +37080 +1824 +26361 +541 +32 +37081 +37082 +13145 +9 +43 +37083 +37084 +19618 +37085 +17880 +37086 +9210 +33494 +30224 +37087 +1090 +37088 +495 +1562 +37089 +31293 +21947 +30877 +590 +37090 +15718 +13205 +37091 +3406 +37092 +43 +1575 +2537 +7442 +37093 +37094 +24725 +37095 +15718 +22922 +8668 +17911 +36483 +89 +14330 +37096 +26815 +4808 +590 +736 +590 +37097 +37098 +89 +2802 +3875 +33185 +19 +15718 +1169 +28013 +34402 +19 +736 +37099 +5080 +2043 +29561 +16560 +36735 +37100 +1169 +24038 +37101 +37102 +590 +286 +31293 +26040 +37103 +37104 +1097 +37105 +30458 +19 +31293 +27117 +590 +478 +5780 +16879 +25237 +19618 +37106 +590 +37107 +37108 +22114 +12498 +597 +188 +37109 +43 +5371 +37110 +1047 +37111 +77 +1090 +37112 +23290 +1870 +345 +495 +37113 +2006 +1224 +13150 +37114 +4153 +37115 +25237 +377 +37116 +29628 +37117 +237 +14479 +37118 +30224 +1157 +1295 +13961 +14 +30051 +3409 +19 +37119 +37120 +37121 +37122 +892 +6104 +57 +19 +36819 +646 +3546 +1710 +22587 +4055 +10729 +37123 +37124 +9 +37125 +37126 +37127 +10 +464 +28317 +46 +1295 +694 +35427 +37128 +33650 +37129 +37130 +2770 +37131 +37132 +37133 +4766 +20710 +3994 +1090 +1862 +37134 +43 +25237 +842 +4055 +8668 +590 +37135 +37136 +23103 +4699 +19 +37137 +34 +3508 +17698 +36156 +6171 +37138 +15 +265 +37139 +3330 +37140 +28317 +31293 +15718 +11087 +33120 +22337 +19 +19 +37141 +30877 +176 +37142 +19 +26323 +36391 +1410 +37143 +19 +4808 +25943 +37144 +37088 +4245 +37145 +33113 +19 +37146 +5780 +37147 +37148 +43 +37149 +37150 +36424 +2 +33627 +14369 +29483 +142 +1082 +27069 +8668 +20572 +60 +37151 +345 +8338 +3546 +15572 +37152 +14330 +37153 +37154 +11312 +37155 +11822 +37156 +892 +3 +17151 +37025 +17151 +37157 +37158 +19 +3743 +29381 +7553 +37159 +37160 +2841 +37161 +14369 +16798 +37162 +22587 +29204 +37163 +37164 +286 +37165 +915 +28549 +27173 +23487 +1913 +3828 +37166 +37167 +20 +37168 +18951 +1503 +37169 +37170 +5188 +3790 +14553 +349 +2368 +37171 +33211 +8668 +31346 +416 +3484 +12751 +37172 +31293 +29483 +3660 +24864 +12005 +345 +28170 +37173 +18695 +12155 +7276 +37174 +37175 +28339 +37176 +30309 +37177 +37178 +37179 +286 +37180 +37181 +736 +13474 +25021 +37182 +22752 +9649 +4116 +35076 +1716 +30877 +2577 +19 +19 +37183 +1269 +15 +5080 +345 +37184 +37185 +4056 +27719 +16437 +185 +699 +495 +37186 +4463 +60 +37187 +828 +18780 +9 +37188 +37189 +1090 +37190 +20700 +8668 +2310 +37191 +37192 +9 +590 +30650 +2314 +43 +14369 +37193 +22788 +188 +14340 +30458 +736 +11620 +9 +37194 +590 +4055 +26496 +37195 +43 +3546 +104 +37196 +2175 +20 +14001 +1090 +15718 +2243 +25943 +37197 +720 +37198 +9649 +3559 +37199 +37200 +21947 +4302 +5780 +22420 +33916 +37201 +25260 +34402 +8668 +17911 +2919 +13566 +37202 +9560 +15718 +37203 +11754 +33120 +28666 +14369 +37204 +37205 +7015 +28549 +37206 +37207 +2694 +37208 +915 +37209 +37210 +37211 +37212 +37213 +25316 +3406 +37214 +43 +595 +36761 +37215 +26550 +24303 +9738 +37216 +23219 +37217 +37218 +14340 +24864 +37219 +29465 +24864 +34999 +30224 +37220 +43 +20700 +77 +37221 +27669 +37222 +21947 +37223 +43 +27669 +15172 +25316 +1384 +37224 +36527 +386 +37225 +554 +7987 +27669 +9 +37226 +25871 +1251 +37227 +4230 +2308 +399 +37228 +3950 +15446 +37229 +37230 +43 +2356 +37231 +14330 +19825 +18930 +1961 +18695 +37232 +3543 +37233 +16375 +37234 +910 +37235 +22963 +37236 +13493 +21669 +9 +9433 +19 +8100 +37237 +1481 +24864 +35068 +2577 +27669 +4747 +33494 +37238 +19 +9 +36424 +20329 +37239 +37240 +43 +11841 +9 +8668 +25237 +25316 +37241 +37242 +37243 +590 +30877 +8724 +37244 +37245 +415 +37246 +37247 +2410 +7341 +25683 +37248 +34703 +4278 +4461 +37249 +345 +4 +764 +33496 +37250 +37251 +22273 +9560 +33524 +37252 +34402 +37253 +12825 +24678 +22473 +15 +31098 +37254 +9 +29483 +18045 +37255 +27387 +3546 +37256 +43 +915 +3948 +7014 +21149 +11321 +14216 +6877 +37257 +37258 +19655 +15718 +37259 +37260 +57 +1115 +37261 +519 +37262 +37263 +6771 +9560 +37264 +37265 +37266 +28044 +6441 +823 +12590 +5188 +1090 +3978 +13361 +37267 +37268 +33650 +37269 +37270 +37271 +6950 +37272 +299 +16280 +19 +37273 +31098 +8967 +37274 +37275 +24303 +29483 +22922 +33650 +2593 +30224 +37276 +16798 +16102 +19582 +37277 +37278 +345 +37279 +37280 +33457 +37281 +37282 +37283 +37284 +43 +6364 +809 +37285 +37286 +4247 +37287 +37288 +1524 +37289 +16118 +2287 +37290 +29204 +37291 +37292 +3 +27669 +30224 +19 +2197 +27798 +3553 +19 +37293 +37294 +37295 +25902 +2406 +1082 +46 +31293 +36282 +37296 +554 +19655 +22922 +15 +37297 +37298 +43 +37299 +590 +6776 +37300 +349 +37301 +164 +484 +1566 +4463 +21947 +14 +415 +24303 +24919 +3976 +15705 +37302 +33113 +19852 +179 +12845 +13566 +37257 +35883 +2325 +19 +26755 +37303 +26006 +24725 +17911 +14330 +37304 +1870 +37305 +28317 +37306 +22 +37307 +19939 +57 +19 +66 +14369 +37308 +36486 +21947 +26496 +29483 +37309 +14330 +2514 +12987 +37310 +27669 +37311 +34402 +8545 +10244 +37312 +3005 +31293 +590 +35580 +37313 +13760 +1812 +10634 +37314 +8249 +19974 +37315 +37316 +77 +14001 +37317 +495 +176 +37318 +28961 +37319 +37320 +185 +7922 +4055 +3484 +21947 +14477 +14 +15 +36019 +35337 +37321 +590 +29687 +25316 +30073 +6095 +19618 +586 +349 +37322 +28494 +32 +37323 +720 +5088 +15 +37324 +7944 +5169 +37325 +37326 +37327 +37328 +27669 +3 +18045 +23841 +8301 +25316 +19 +37329 +30224 +37330 +37331 +1300 +89 +3553 +3601 +23303 +37332 +1743 +37333 +34779 +12987 +1051 +22963 +37334 +9497 +37335 +270 +671 +19 +740 +1310 +1090 +2260 +37336 +14369 +3829 +37337 +590 +33524 +60 +37338 +37339 +590 +30224 +197 +89 +17151 +43 +15718 +37340 +1961 +9273 +26804 +990 +23406 +46 +2318 +37341 +4530 +37342 +27669 +165 +27669 +37343 +35352 +3598 +5601 +37344 +4461 +9 +3372 +19618 +36157 +357 +37345 +43 +37346 +15718 +37347 +17151 +791 +6439 +8996 +2406 +677 +37348 +37349 +338 +1090 +1716 +37350 +37351 +1090 +37352 +37353 +34944 +37354 +32574 +7835 +37355 +18394 +19 +37356 +1937 +24457 +37357 +19852 +201 +9 +415 +24144 +21947 +9 +37358 +15486 +694 +29628 +1829 +17997 +37359 +98 +37360 +4055 +16422 +25584 +12934 +1428 +354 +19 +178 +28219 +6869 +736 +37361 +37362 +37363 +22963 +37364 +37365 +1109 +37366 +1749 +179 +5387 +28317 +33627 +1090 +37367 +872 +25140 +29 +590 +720 +37368 +663 +19 +37369 +4055 +37370 +37371 +5837 +37372 +179 +18100 +37373 +12005 +2342 +18369 +12 +15928 +3764 +5301 +37374 +37375 +33627 +37376 +37377 +317 +37378 +37379 +37380 +37381 +590 +37382 +37383 +37384 +8297 +2117 +24154 +24303 +37385 +37386 +37387 +196 +32944 +37388 +21947 +19 +5117 +37389 +29381 +677 +30877 +37390 +37391 +12152 +19618 +23103 +27118 +17911 +37392 +1790 +37393 +14369 +11213 +11717 +3546 +176 +1090 +33627 +33758 +16437 +37394 +22014 +37395 +4055 +13905 +37396 +37397 +23103 +736 +8668 +349 +1154 +37398 +436 +21027 +37399 +37400 +36333 +28441 +478 +29381 +4055 +5052 +1090 +2347 +13807 +27669 +37401 +37402 +43 +37403 +37404 +1992 +24324 +37405 +7053 +16437 +6122 +29483 +24864 +37406 +13311 +1090 +37407 +37408 +222 +23103 +9 +536 +37409 +14797 +303 +31293 +11188 +22827 +2015 +37410 +15203 +21686 +4364 +1870 +37411 +1120 +14477 +15718 +37412 +590 +37413 +37414 +1924 +19 +6171 +590 +6935 +5409 +37415 +37416 +26580 +37417 +36424 +24 +37418 +32 +19 +1768 +15718 +590 +17374 +34602 +3601 +1637 +6153 +37419 +37420 +37421 +24303 +29204 +25943 +1508 +21689 +37422 +37423 +764 +28518 +15 +37424 +33494 +15 +37425 +35409 +8668 +37426 +1356 +23103 +554 +14369 +37427 +37428 +11754 +20142 +9 +33650 +24864 +30580 +1090 +1900 +37429 +15718 +37430 +1912 +33758 +37431 +21947 +37432 +37433 +37434 +34 +22986 +3546 +31098 +37435 +1774 +411 +36727 +37436 +1559 +140 +14634 +32646 +17927 +37437 +21947 +5188 +37438 +37439 +37440 +37441 +37442 +15718 +21127 +164 +6004 +36251 +25 +27791 +21689 +15654 +37443 +15491 +37444 +33650 +541 +37223 +37445 +10 +37446 +37446 +1021 +37447 +33890 +89 +37448 +37449 +16466 +1749 +37450 +2577 +29032 +37451 +170 +13855 +36735 +2577 +37452 +24303 +25237 +19 +37453 +33627 +20677 +2009 +822 +2993 +37454 +590 +272 +29204 +250 +15718 +6054 +37455 +20337 +37456 +464 +9567 +29483 +23150 +21947 +37457 +24195 +665 +24972 +2043 +37458 +32275 +9 +28317 +554 +37459 +13150 +37460 +27069 +27669 +37461 +2 +98 +73 +37462 +1012 +5904 +37463 +37464 +4278 +24621 +13566 +43 +15 +37465 +37466 +15718 +30877 +37467 +5601 +37468 +33494 +15018 +30724 +29483 +16732 +37469 +37470 +23218 +1481 +37471 +25140 +12013 +37472 +1107 +29483 +178 +5085 +345 +37473 +1364 +37474 +11749 +19 +37475 +37476 +3204 +27669 +37477 +745 +566 +1230 +16375 +31336 +20700 +37478 +2314 +671 +16866 +15 +286 +15718 +3806 +37479 +37480 +20745 +37481 +37482 +5204 +28069 +21947 +42 +37483 +11341 +37484 +37485 +720 +29483 +37486 +345 +5770 +37487 +37488 +30877 +14 +1508 +2525 +966 +138 +12893 +1559 +37489 +25237 +24 +37490 +209 +1157 +1765 +25683 +32 +34 +5188 +8210 +5027 +1716 +43 +19285 +4124 +6571 +37491 +29204 +971 +27701 +5188 +5119 +37492 +5502 +28441 +32 +1203 +37493 +30877 +37494 +37495 +37496 +37497 +685 +7117 +16440 +29026 +37498 +15643 +30877 +10 +16375 +16327 +37499 +3353 +34402 +37500 +37501 +37502 +677 +27357 +21947 +18597 +31698 +3546 +36127 +37503 +37504 +37505 +30986 +26431 +30844 +37506 +37507 +9 +665 +37508 +248 +533 +26040 +37509 +37510 +21947 +43 +21689 +3546 +33278 +37511 +37512 +37513 +43 +37514 +37515 +5161 +36177 +18283 +37174 +25 +37516 +5912 +37517 +21689 +35265 +37518 +37519 +7835 +57 +8167 +21947 +37520 +21947 +337 +4364 +15 +24864 +37521 +16437 +14001 +11832 +21947 +3421 +14947 +303 +37522 +29483 +21947 +37523 +17911 +3137 +21776 +303 +9 +37524 +5223 +37525 +20315 +37526 +37527 +19618 +37528 +37529 +123 +827 +37530 +19318 +37531 +27669 +30877 +37532 +1226 +2058 +37533 +509 +37534 +25970 +8356 +10965 +21947 +19 +14477 +35296 +140 +9 +14477 +37535 +8685 +284 +37536 +9 +1157 +37537 +37538 +248 +37539 +37540 +28661 +37541 +1090 +10028 +25237 +37542 +37543 +15718 +37544 +6617 +1559 +34630 +13566 +37545 +36424 +170 +25316 +37546 +24725 +377 +11907 +15718 +26804 +15 +286 +36874 +37547 +37548 +9 +17320 +849 +24303 +37549 +1542 +30051 +29855 +9 +3391 +30877 +20 +33494 +37550 +1765 +1090 +15718 +37551 +30051 +29381 +10828 +34641 +1198 +37552 +12522 +37553 +37554 +17920 +33494 +7379 +4055 +28490 +16 +31575 +5218 +377 +30051 +1364 +590 +4055 +1090 +37555 +37556 +2476 +377 +37557 +37558 +37559 +37560 +37561 +14369 +24144 +37562 +11762 +21947 +13508 +36424 +37563 +9 +37564 +36735 +597 +20 +1578 +283 +36736 +155 +1090 +37565 +37566 +32 +37567 +137 +14982 +43 +37568 +9212 +10621 +37569 +4602 +5153 +1520 +8668 +1203 +6183 +37570 +37571 +37572 +15 +37573 +37574 +27415 +11966 +337 +27669 +37575 +27669 +303 +37576 +33650 +6962 +337 +25129 +15998 +2040 +27092 +37577 +303 +37578 +37579 +11537 +213 +3484 +37580 +1090 +18386 +9 +30029 +20700 +37581 +8297 +37582 +37583 +2260 +37584 +284 +37585 +37586 +22236 +7053 +37587 +20916 +13919 +37588 +36218 +1082 +1384 +7053 +176 +33494 +37589 +3546 +3546 +37590 +3944 +37591 +8392 +37592 +37593 +590 +989 +19 +37594 +7053 +338 +38 +33758 +19 +37595 +30650 +17945 +16235 +37596 +37597 +37598 +25683 +29483 +14864 +1533 +15 +37599 +37600 +16437 +37601 +21776 +37602 +29381 +707 +114 +22963 +14477 +2347 +105 +43 +2316 +377 +31293 +483 +4598 +213 +1710 +37603 +37604 +37605 +2769 +37606 +686 +28549 +12474 +1524 +37607 +37608 +14330 +19576 +25316 +16443 +8351 +37609 +37610 +646 +554 +32 +37611 +32449 +14 +32 +18139 +2694 +37612 +37556 +337 +24896 +37613 +2537 +34402 +27388 +197 +13801 +33690 +37614 +554 +32642 +37615 +14 +270 +15702 +18369 +37616 +37617 +18156 +37618 +9402 +1090 +19 +37619 +37620 +37621 +9262 +21698 +36492 +37622 +30224 +25316 +36735 +37623 +2372 +15104 +37624 +30877 +14279 +37625 +5318 +37626 +36735 +37627 +13943 +179 +446 +21947 +3844 +43 +37628 +5188 +5119 +13377 +222 +37629 +123 +15718 +37630 +15718 +1090 +11762 +769 +17151 +590 +303 +590 +37631 +337 +4450 +37632 +14603 +43 +37633 +37634 +32426 +37635 +1710 +536 +18695 +9 +1090 +936 +37636 +590 +2040 +31362 +9 +37637 +2577 +43 +25237 +33445 +31293 +2804 +34 +37638 +176 +21947 +14 +37639 +248 +1605 +28085 +12987 +590 +19 +37640 +23103 +37641 +37642 +20572 +337 +31293 +37643 +37644 +37645 +13714 +1139 +1090 +16437 +37646 +1090 +30877 +2550 +30877 +14369 +22075 +1745 +10853 +37647 +4026 +21003 +1824 +1100 +37648 +31293 +1749 +37649 +12987 +645 +1208 +31098 +18912 +8351 +14369 +37650 +36452 +33120 +25140 +37651 +430 +34957 +37652 +37653 +30224 +665 +568 +354 +140 +1228 +5188 +213 +37654 +14477 +176 +37655 +18079 +33650 +37656 +37657 +37658 +37659 +37660 +179 +669 +37661 +1090 +15498 +792 +33650 +37662 +19655 +18919 +560 +37663 +37664 +1680 +37665 +37666 +4055 +1384 +3546 +37667 +2746 +37668 +536 +37669 +37670 +4055 +9 +14 +17897 +37671 +37672 +37673 +3559 +37674 +11762 +37675 +37676 +12402 +37677 +15683 +37678 +14001 +37556 +37679 +28197 +31293 +37680 +2043 +43 +37681 +1710 +37682 +37683 +37684 +37685 +554 +197 +37686 +37687 +27669 +33120 +21947 +25307 +284 +323 +30877 +15683 +25237 +9 +686 +12546 +37688 +12013 +37689 +303 +37690 +1529 +137 +849 +37691 +37692 +37693 +18109 +115 +9 +37694 +6660 +37695 +19 +37696 +2260 +37697 +484 +25237 +37698 +21947 +37699 +37700 +37701 +37702 +17151 +37703 +23418 +31168 +19 +3976 +37704 +22505 +37705 +33758 +828 +37706 +37707 +213 +15 +22717 +37708 +213 +213 +2325 +37709 +590 +37710 +2832 +37711 +25021 +4285 +37712 +37713 +2308 +37714 +28494 +37715 +27669 +35805 +1090 +29720 +1529 +15718 +3546 +337 +13296 +1295 +19 +11966 +37716 +37717 +1131 +745 +37718 +372 +337 +37719 +60 +3546 +37720 +237 +37556 +284 +178 +1090 +37721 +12302 +12185 +3480 +25316 +37722 +22963 +37723 +25162 +25316 +495 +1574 +31293 +14660 +37724 +337 +37725 +29381 +284 +2314 +37726 +248 +37727 +2581 +19 +37728 +37729 +616 +28361 +11321 +37730 +3546 +37731 +9 +37732 +37733 +28317 +58 +37734 +2618 +15 +337 +1563 +9955 +5409 +37735 +15718 +37736 +37737 +37738 +37739 +37740 +399 +3 +37741 +37742 +590 +9460 +37650 +112 +20083 +37743 +9082 +4055 +37744 +37745 +22 +37746 +37747 +6950 +37748 +16437 +3546 +14363 +37749 +1011 +9 +15096 +740 +213 +37750 +9465 +37751 +19795 +27599 +140 +436 +29032 +25140 +446 +37752 +284 +37753 +37754 +37755 +8367 +1870 +5004 +37756 +9 +284 +37757 +284 +872 +37758 +24303 +1508 +37759 +21947 +37760 +37761 +303 +23867 +37762 +303 +14871 +37763 +35552 +37764 +8668 +4116 +17911 +2865 +37765 +7357 +404 +37766 +188 +33508 +4055 +2561 +57 +349 +25943 +21947 +37767 +25683 +2 +37768 +37769 +34402 +1181 +37770 +37771 +590 +10628 +37772 +24972 +36853 +822 +35695 +34433 +33494 +1247 +20770 +7363 +16437 +25237 +14107 +37773 +37774 +11840 +2325 +37775 +1513 +15718 +2762 +303 +37776 +8668 +15481 +2465 +37777 +14385 +16437 +10933 +37778 +37779 +19655 +37780 +9 +25237 +11211 +29 +37781 +10642 +37782 +28389 +37783 +30224 +31293 +1230 +37556 +21535 +286 +37784 +14770 +17911 +99 +37785 +37786 +1109 +37787 +815 +18695 +24725 +37788 +37789 +5085 +14152 +15718 +37790 +15 +1442 +30877 +37791 +18503 +33192 +15320 +37792 +29129 +34842 +37793 +37794 +15718 +19057 +464 +4032 +60 +37795 +37796 +37797 +30209 +31036 +37798 +37556 +21947 +3755 +26417 +2859 +33650 +37799 +34402 +5619 +2356 +286 +37800 +34902 +37801 +24864 +37802 +20 +1236 +13905 +354 +21689 +7658 +9 +915 +31168 +797 +6950 +1357 +5780 +6110 +18822 +27904 +1503 +25683 +37803 +4055 +37804 +37805 +37806 +30877 +37807 +11762 +25140 +11 +37808 +27283 +1961 +32 +15 +19837 +809 +57 +37809 +887 +14369 +37810 +1090 +37811 +37812 +7053 +37813 +43 +9649 +43 +25965 +37814 +29483 +1710 +37815 +8724 +7855 +6950 +19 +25683 +5110 +35167 +10 +32410 +286 +26585 +15718 +37816 +24045 +32960 +37817 +14330 +155 +21947 +17136 +1357 +37818 +37819 +683 +29621 +37820 +37556 +3546 +1226 +28389 +21947 +37821 +19618 +43 +33494 +16494 +11420 +9 +2356 +37822 +37823 +37824 +1208 +8367 +37825 +43 +37826 +1559 +24864 +30458 +3598 +590 +29483 +16158 +17698 +31168 +284 +590 +17911 +5188 +37827 +33627 +29483 +29381 +30051 +37828 +43 +31293 +37829 +37830 +491 +7330 +37831 +6883 +989 +66 +37832 +2197 +9600 +1812 +37833 +16773 +37834 +57 +7977 +34081 +33316 +586 +14193 +4907 +597 +27178 +37835 +464 +29025 +43 +37836 +37837 +17144 +37838 +440 +1049 +645 +37839 +34402 +1562 +1732 +286 +36884 +37840 +1991 +337 +37841 +37842 +15 +32 +43 +3353 +27669 +37843 +19057 +37844 +37845 +1090 +16443 +14369 +665 +27669 +26186 +21045 +24864 +21947 +14477 +33479 +37846 +31873 +20700 +1090 +37847 +36 +37848 +284 +590 +2289 +2733 +37849 +97 +5188 +37850 +16698 +1867 +37851 +36219 +37852 +1920 +37853 +43 +77 +29977 +377 +3559 +37854 +37855 +2117 +37856 +970 +2152 +5188 +21947 +37857 +17911 +736 +12431 +4055 +1503 +21947 +37858 +720 +37859 +24725 +8716 +5780 +37860 +14007 +1109 +26626 +31098 +197 +25 +9 +43 +16826 +14 +5085 +37861 +19714 +37862 +16413 +37863 +23226 +15 +12955 +14102 +21371 +16480 +27522 +37864 +37865 +21947 +31273 +32382 +323 +36 +28298 +19218 +1090 +21947 +14795 +37866 +20 +1212 +37867 +37868 +37869 +37870 +286 +14369 +4055 +27619 +10791 +29483 +37871 +43 +17151 +57 +37872 +37873 +185 +28199 +27669 +37874 +14369 +44 +37875 +34317 +6028 +37876 +9433 +21387 +37877 +37878 +37879 +37880 +30051 +11762 +20 +13566 +24725 +996 +137 +5780 +369 +24303 +43 +32 +4055 +8316 +1536 +99 +185 +27669 +590 +37881 +37882 +4598 +37883 +14477 +37884 +12573 +4468 +683 +5188 +8301 +2593 +37885 +30877 +1224 +30224 +37886 +36735 +37887 +5188 +3598 +37888 +33061 +33113 +37889 +37890 +37891 +37892 +5085 +37893 +9543 +2919 +37894 +37895 +2591 +37896 +882 +37897 +196 +13150 +4055 +970 +30551 +892 +1112 +34264 +37898 +37899 +37900 +32 +28251 +32 +2159 +36907 +4518 +34 +37901 +27669 +37556 +19 +5007 +37902 +27430 +736 +3 +19 +37903 +4463 +37904 +34402 +5188 +19 +37905 +398 +533 +27669 +37906 +7069 +24774 +8919 +30877 +11483 +37907 +37908 +20700 +7053 +4028 +12987 +5188 +3008 +15592 +317 +6776 +33650 +10598 +28441 +37909 +2121 +286 +37910 +32 +2694 +16437 +2476 +37911 +37912 +15718 +32751 +1082 +13721 +37913 +37556 +37914 +25 +412 +37915 +1090 +3239 +37916 +1503 +501 +37917 +1011 +357 +28317 +104 +11471 +37918 +19655 +22315 +37919 +1234 +37920 +2356 +29483 +37921 +597 +671 +415 +19 +58 +6261 +14369 +3395 +20 +24864 +9 +342 +1012 +2139 +37922 +2733 +1425 +31293 +17 +37923 +7817 +37924 +37925 +19 +37926 +286 +37927 +37928 +1716 +1189 +26361 +37929 +37930 +19974 +3 +21045 +37931 +37932 +37933 +7597 +33627 +13150 +37934 +352 +37935 +822 +37936 +16375 +9 +915 +37937 +37025 +19655 +4293 +31293 +37938 +528 +37556 +25943 +19489 +4730 +554 +29381 +37939 +37940 +21947 +14369 +7226 +33650 +1442 +9 +5197 +37941 +37942 +35214 +770 +1091 +2 +377 +19742 +89 +57 +1082 +37943 +31867 +377 +37944 +14527 +37945 +42 +21947 +20 +14 +9 +19 +6883 +27669 +37946 +19294 +37947 +790 +9118 +35823 +5403 +37948 +37949 +10111 +6251 +29381 +37950 +37951 +37952 +37953 +155 +9 +28490 +21947 +37954 +37955 +12647 +37956 +31225 +5627 +13867 +37957 +2117 +6881 +33758 +37958 +209 +20141 +15354 +29381 +57 +37959 +2308 +37960 +37961 +37962 +27669 +1021 +33650 +37556 +37963 +37964 +4518 +25237 +57 +37965 +29381 +17151 +14814 +17151 +13566 +19381 +19 +10706 +5299 +1578 +14369 +17911 +37966 +16422 +43 +2919 +2449 +31293 +37967 +37968 +37969 +19486 +33950 +14666 +37970 +37971 +377 +7053 +15 +37972 +37973 +37974 +37975 +590 +12296 +16787 +37976 +15718 +514 +25140 +37977 +30917 +202 +37978 +37556 +37979 +25140 +4292 +19849 +590 +3546 +21947 +37980 +37981 +3994 +4461 +19 +37982 +15220 +15 +21947 +1021 +32 +184 +37983 +23544 +19713 +34601 +6248 +28277 +37556 +37984 +15718 +37985 +27669 +4502 +37986 +37987 +342 +28317 +37988 +32449 +14477 +4855 +9 +349 +37989 +11330 +37990 +1745 +20677 +25215 +37991 +613 +16437 +15718 +249 +262 +37992 +19 +37993 +37556 +37994 +1749 +14330 +2410 +37556 +37768 +24864 +15 +3546 +15511 +37995 +33650 +4364 +37996 +15 +1090 +15 +8668 +37997 +37998 +764 +1295 +683 +613 +15395 +16 +37999 +11585 +23150 +38000 +1021 +1100 +37830 +4461 +38001 +12 +38002 +209 +736 +9 +6363 +38003 +104 +19792 +38004 +29381 +1604 +38005 +10840 +1090 +6505 +38006 +1090 +590 +38007 +9183 +38008 +37556 +36218 +16437 +4414 +38009 +29152 +29483 +26060 +23103 +22552 +33061 +21689 +27669 +4055 +28206 +66 +17670 +38010 +34433 +21947 +4472 +14 +533 +38011 +6625 +34650 +38012 +11013 +3599 +38013 +1013 +34985 +2998 +38014 +38015 +3546 +736 +38016 +38017 +491 +38018 +14363 +671 +20573 +12711 +35224 +18045 +38019 +736 +38020 +31293 +34402 +21175 +1967 +38021 +38022 +38023 +17151 +2694 +15705 +38024 +590 +20189 +38025 +38026 +38027 +25140 +15718 +30051 +2 +19 +416 +38028 +6439 +8362 +554 +19 +37556 +6001 +15 +46 +38029 +15 +38030 +1021 +38031 +804 +9 +15 +379 +5908 +38032 +25316 +38033 +38034 +3544 +37530 +659 +201 +38035 +6658 +37556 +8322 +137 +21115 +98 +16375 +38036 +19 +28036 +1244 +4028 +9257 +20 +29381 +7829 +38037 +38038 +179 +38039 +1920 +24864 +19655 +9 +38040 +1870 +29192 +9784 +38041 +1090 +16437 +22922 +10828 +7431 +20113 +6439 +31234 +590 +38042 +38043 +696 +31168 +38044 +2419 +1090 +38045 +38046 +24864 +38047 +37556 +38048 +38049 +15 +38050 +14369 +43 +936 +38051 +1224 +24303 +38052 +21947 +9 +6122 +16466 +736 +37949 +12009 +2064 +1442 +1090 +38053 +29204 +3601 +38054 +9 +37556 +115 +35300 +38055 +38056 +28549 +19 +38057 +20339 +286 +23103 +38058 +21947 +38059 +14279 +1316 +12684 +19852 +38003 +6095 +27669 +37741 +665 +21776 +36888 +38060 +1082 +17911 +197 +27291 +38061 +38062 +354 +19 +43 +33494 +317 +38063 +12907 +2577 +1710 +6877 +5666 +317 +13396 +2865 +21729 +22564 +27669 +38064 +2489 +38065 +33120 +38066 +597 +30877 +286 +339 +3030 +12907 +6187 +38067 +25237 +38068 +38069 +30877 +1612 +38070 +9577 +20113 +2561 +3317 +677 +19 +22922 +38071 +28474 +2136 +6736 +36957 +323 +30166 +43 +20785 +38072 +20005 +38073 +2164 +38074 +43 +7964 +2338 +38075 +1870 +1107 +33650 +38076 +6617 +228 +38077 +43 +671 +31293 +38078 +7419 +12397 +3546 +38079 +38080 +31293 +38081 +38082 +16437 +8668 +19 +38083 +33650 +15718 +21031 +7912 +519 +38084 +3553 +345 +9 +613 +38085 +38086 +971 +2762 +19 +19 +1817 +38087 +38088 +398 +9939 +153 +43 +38089 +14693 +38090 +38091 +38092 +3481 +38093 +38094 +286 +3343 +176 +12696 +38095 +14369 +3546 +554 +9 +1082 +3959 +77 +10574 +38096 +38097 +38098 +17911 +12474 +2668 +38099 +286 +29200 +31098 +38100 +38101 +30794 +38102 +19655 +194 +478 +16323 +33693 +14369 +38103 +1633 +38104 +37185 +38105 +140 +845 +16818 +4055 +11432 +25584 +24045 +21689 +1566 +33352 +38003 +7053 +25 +576 +683 +317 +19618 +24144 +586 +560 +16466 +30742 +38106 +21947 +14420 +21947 +38107 +26040 +3790 +5990 +33758 +1116 +317 +25871 +20 +38108 +28148 +38109 +38110 +1531 +26048 +24864 +37556 +16447 +14363 +1927 +15 +9948 +32805 +38111 +7053 +936 +33496 +9 +38112 +25 +33188 +23150 +77 +20 +38113 +38114 +33627 +17596 +36735 +57 +38115 +38116 +38117 +27669 +38118 +3729 +4055 +38119 +38120 +38121 +3430 +10299 +27178 +8668 +38122 +242 +861 +38123 +33910 +31758 +2733 +38124 +4055 +9497 +15 +15718 +533 +15718 +38125 +590 +38126 +1481 +402 +43 +38127 +4055 +4056 +34306 +1542 +38128 +2 +815 +38129 +38130 +13150 +1524 +15 +38131 +16437 +3055 +11762 +1920 +9 +12120 +33693 +38132 +2308 +3644 +3015 +7406 +21045 +38133 +34 +770 +34999 +38134 +38135 +38136 +15718 +46 +270 +38137 +28206 +15718 +28317 +34433 +398 +43 +38138 +38139 +31381 +17267 +2924 +38140 +20 +38141 +18956 +14369 +20531 +38142 +15824 +38143 +38144 +38145 +38146 +38147 +38148 +21947 +14603 +3343 +38149 +28317 +21689 +1090 +15 +1090 +446 +399 +1765 +3034 +33650 +38150 +38151 +4242 +38152 +25 +19 +8668 +14369 +38085 +36853 +134 +887 +38153 +8367 +38154 +8279 +15 +4907 +36157 +25237 +21947 +25683 +14216 +38155 +43 +38156 +38157 +38158 +20 +38159 +14369 +10028 +38160 +2414 +25 +19 +1112 +33627 +3251 +155 +25914 +2308 +38161 +26496 +38162 +38163 +24864 +20750 +38164 +38165 +33494 +11822 +38166 +38167 +16772 +38168 +38169 +2049 +1011 +38170 +3546 +38171 +34480 +38172 +23102 +38173 +22 +38174 +430 +6263 +140 +38175 +369 +38176 +694 +19941 +46 +89 +25316 +35624 +30401 +38177 +338 +6736 +38178 +412 +38179 +38180 +38181 +29200 +14330 +2274 +5976 +1364 +13317 +4055 +38182 +887 +38183 +28961 +2577 +38184 +2121 +38185 +533 +38186 +38187 +21947 +15718 +201 +38188 +32426 +38189 +38190 +38191 +398 +38192 +38193 +38194 +14477 +140 +38195 +809 +38196 +201 +38197 +38198 +590 +8110 +12661 +9 +938 +13959 +1314 +29597 +19220 +9658 +15718 +2064 +38199 +23640 +15718 +5689 +37556 +30877 +2006 +38200 +9 +38201 +23103 +415 +38202 +38203 +30877 +38204 +34650 +21947 +3252 +33634 +349 +18895 +7815 +38205 +38206 +18120 +3546 +30224 +19 +31293 +33421 +14369 +8188 +9 +11948 +38207 +2356 +27669 +38208 +4634 +30877 +38209 +1364 +32640 +18798 +27719 +23103 +15718 +33278 +38210 +38211 +16184 +38212 +5313 +77 +1051 +38213 +15718 +38214 +210 +33120 +20280 +38215 +2706 +38216 +32 +30917 +23100 +2561 +38217 +16466 +971 +4714 +38218 +38219 +38220 +4055 +38221 +37556 +9 +5561 +22504 +38222 +36219 +38223 +5340 +27766 +38224 +38225 +647 +1743 +1371 +9129 +38226 +38227 +37556 +38228 +38229 +31293 +33650 +38230 +17911 +18695 +22 +415 +736 +3361 +33627 +27150 +38231 +38232 +2960 +1924 +38233 +201 +38234 +415 +9 +43 +38235 +31873 +14 +38236 +19 +31293 +1710 +817 +43 +25683 +30235 +21627 +209 +910 +279 +349 +554 +43 +33650 +57 +910 +38237 +379 +16981 +29204 +14679 +38238 +8110 +21947 +37128 +38239 +6287 +57 +38240 +38241 +6632 +3994 +2197 +9 +892 +38242 +23103 +21669 +9097 +20 +29056 +13814 +28044 +8115 +16826 +8787 +24303 +38243 +38244 +38245 +38246 +38247 +11754 +17151 +24303 +10935 +30080 +34402 +27178 +24864 +9 +38248 +14846 +15718 +38249 +22 +38250 +21419 +34402 +25 +9543 +1090 +1038 +32 +38251 +38 +28500 +31041 +2694 +38252 +3546 +70 +33 +38253 +590 +18045 +38254 +6232 +349 +7658 +415 +28728 +38255 +27260 +38256 +5317 +1245 +22352 +24303 +25237 +38257 +30877 +24725 +38258 +38259 +24864 +865 +1021 +1493 +38260 +38261 +38262 +9 +720 +38263 +4729 +1425 +15 +30857 +5438 +873 +38264 +16443 +815 +10470 +38265 +286 +38266 +37556 +34180 +38267 +1094 +1578 +38268 +38269 +38270 +38271 +57 +19 +38272 +30877 +1116 +38273 +14369 +11966 +1559 +38274 +15718 +389 +38275 +576 +21031 +38276 +21620 +38277 +1090 +38278 +15718 +7610 +20942 +21947 +931 +17972 +19618 +590 +38279 +16698 +1300 +17058 +31674 +17698 +43 +38280 +43 +32915 +15572 +4116 +38281 +10028 +22 +28317 +23853 +15809 +17151 +188 +10274 +36751 +19618 +38282 +8668 +1168 +17151 +20339 +590 +38283 +1615 +1018 +21947 +2231 +28441 +38284 +13476 +15 +931 +38285 +38286 +3601 +10168 +33650 +38287 +1244 +25140 +35318 +38288 +9497 +21031 +36424 +10 +46 +34066 +29483 +38289 +8549 +1559 +38290 +196 +30877 +30877 +647 +33627 +43 +33120 +16437 +38291 +3978 +1529 +286 +15592 +31873 +25316 +14330 +13361 +15 +38292 +3484 +38293 +19618 +24506 +38294 +27719 +5080 +21947 +25140 +31293 +155 +38295 +37556 +38296 +7553 +38297 +24864 +19573 +38298 +38299 +29204 +2061 +19 +9 +5837 +38300 +38301 +541 +1859 +38302 +38303 +272 +20853 +25943 +30877 +38304 +43 +9 +10936 +38305 +9 +38306 +38307 +37391 +1066 +36735 +38308 +46 +604 +38309 +2064 +24864 +38310 +10553 +9 +38311 +14330 +7260 +3655 +37556 +1090 +827 +15 +25140 +38312 +14852 +1056 +11537 +33120 +15 +38313 +140 +38314 +13623 +31293 +3105 +21947 +38315 +301 +38316 +24725 +1415 +19 +15541 +21947 +38317 +38318 +484 +345 +38319 +1090 +1817 +43 +38320 +720 +27084 +5217 +28480 +28923 +36192 +1090 +33650 +862 +37556 +2694 +38321 +89 +24303 +38322 +915 +1617 +14369 +38323 +38324 +8693 +33627 +38325 +38326 +590 +2859 +31293 +25624 +3976 +1090 +30552 +424 +12308 +38327 +104 +12302 +43 +19 +19 +46 +19 +38328 +1082 +21947 +1217 +38329 +5188 +2640 +27719 +19655 +29204 +17670 +38330 +38331 +38332 +910 +15718 +19918 +19 +3232 +38333 +33177 +21261 +14477 +38334 +38335 +331 +34402 +703 +38336 +38337 +38338 +13150 +14369 +9396 +13721 +14 +38339 +2174 +8297 +3408 +36456 +33730 +38340 +3620 +683 +38341 +738 +7053 +38342 +590 +35224 +34402 +14369 +1870 +38343 +38344 +1090 +38345 +34402 +38346 +1578 +38347 +278 +38348 +15597 +38349 +34 +4055 +14 +38350 +14292 +19 +38351 +38352 +1047 +37588 +12497 +38353 +38354 +342 +19655 +446 +43 +37556 +38 +38355 +179 +7053 +9445 +30877 +38356 +38357 +38358 +671 +38359 +2446 +38360 +14 +38361 +38362 +19231 +43 +34402 +3743 +349 +8249 +10774 +21947 +37556 +2117 +38363 +2325 +19 +38364 +17232 +9 +736 +38365 +38366 +43 +4055 +3508 +38367 +12 +16 +43 +104 +1415 +17911 +35633 +24864 +828 +38368 +38369 +35427 +1082 +9 +33650 +21947 +26854 +38370 +38371 +32410 +202 +38372 +13807 +38373 +1920 +554 +35042 +30794 +21031 +38374 +38375 +26361 +7113 +38376 +2 +38377 +38378 +21947 +5085 +29381 +32 +17340 +34641 +6075 +17144 +20941 +33693 +2260 +38379 +57 +57 +25316 +15718 +38380 +22049 +4055 +377 +2463 +20164 +26361 +38381 +845 +43 +38382 +26355 +1720 +27669 +33120 +38383 +38384 +10356 +12005 +38385 +38386 +22815 +13721 +34402 +9 +96 +32332 +38387 +12552 +9 +971 +484 +38388 +37556 +379 +33650 +242 +15491 +18409 +89 +1090 +38389 +38390 +10482 +67 +38391 +317 +16 +323 +38392 +38393 +25237 +38394 +28317 +9 +38395 +38396 +415 +25683 +38397 +1605 +38398 +2728 +16437 +38399 +38400 +1018 +5415 +23103 +745 +2015 +38401 +19 +46 +38402 +25943 +2492 +38403 +478 +14 +1090 +1251 +4028 +11759 +18013 +38404 +29483 +1300 +25140 +38405 +18548 +12987 +17635 +286 +9897 +33552 +38406 +38407 +16763 +46 +38408 +13179 +286 +25659 +349 +19 +14 +590 +18951 +38409 +2764 +2809 +37556 +19618 +38410 +14 +28502 +31293 +38411 +736 +24045 +31293 +3504 +495 +18440 +19 +33120 +38412 +38413 +27669 +1912 +38414 +5803 +38415 +6341 +38416 +16986 +38417 +5956 +38418 +34433 +5601 +14 +38419 +590 +38420 +19838 +1021 +416 +10028 +28441 +38421 +38422 +12 +23103 +33514 +38423 +38424 +38425 +1291 +2 +38426 +33650 +213 +58 +16183 +43 +24862 +38427 +379 +38428 +38429 +1300 +337 +13721 +1513 +185 +38430 +19 +33693 +38431 +14 +9 +38432 +38433 +5082 +38434 +20555 +13721 +38435 +8766 +337 +28176 +179 +38436 +16 +38437 +19 +33693 +284 +533 +284 +38438 +5188 +2643 +38439 +29483 +18139 +4055 +38440 +32 +15251 +213 +586 +196 +348 +15476 +4055 +18242 +3546 +38441 +3764 +1090 +284 +446 +104 +248 +38442 +703 +38443 +43 +576 +25316 +1090 +1295 +77 +19655 +38444 +13746 +38445 +38446 +38447 +284 +38448 +38449 +36735 +37556 +303 +38450 +7117 +31293 +3105 +38451 +6874 +9 +176 +377 +38452 +77 +13835 +248 +38453 +9 +21947 +16437 +213 +1749 +284 +2694 +9 +21947 +38454 +38455 +8849 +26651 +38456 +248 +22788 +19 +38457 +38458 +37920 +38459 +22922 +38460 +213 +38461 +38462 +2942 +5351 +38463 +14216 +25140 +33650 +33494 +2577 +16830 +38464 +337 +278 +1716 +10973 +19143 +37556 +9 +38465 +20600 +19 +272 +872 +201 +1716 +2029 +38466 +30224 +38467 +35832 +15718 +22963 +352 +176 +21947 +9 +2306 +17537 +25316 +38468 +3 +38469 +33120 +38470 +286 +38471 +38472 +13957 +38473 +16064 +31691 +19 +7084 +38474 +31293 +31098 +27669 +38475 +14363 +15 +248 +37556 +43 +38476 +2410 +4908 +38477 +38478 +30877 +38479 +6052 +38480 +8351 +3981 +31514 +7835 +179 +1531 +38481 +3 +5582 +38482 +9 +14604 +337 +38483 +24864 +43 +22398 +38484 +3353 +38485 +5085 +38486 +533 +38487 +379 +284 +14603 +24896 +38488 +4793 +11754 +38489 +2733 +38490 +2029 +28755 +21947 +14369 +248 +1316 +25316 +3999 +6595 +9 +1234 +38491 +1716 +25316 +270 +38492 +38493 +3559 +38494 +38495 +29381 +5865 +12625 +38496 +38497 +16466 +23477 +38498 +3546 +12013 +38499 +2260 +38500 +38501 +98 +38502 +33627 +38503 +38504 +38505 +590 +10946 +28961 +31575 +33445 +31226 +38506 +2243 +38507 +21947 +38508 +32911 +12254 +43 +464 +38509 +9402 +43 +5188 +37556 +38510 +24896 +2287 +38511 +17911 +2 +29200 +3 +38512 +3541 +5336 +37556 +3317 +28603 +24303 +33061 +4055 +38513 +38514 +38515 +43 +38516 +38517 +2195 +25237 +32 +37556 +38518 +38519 +345 +38520 +1222 +2388 +33627 +720 +38521 +358 +284 +358 +27719 +122 +26361 +9 +248 +10369 +66 +39 +16437 +38522 +14523 +57 +38523 +36735 +38524 +1066 +38525 +17207 +38526 +36019 +478 +14 +38527 +38528 +34402 +3964 +25316 +38529 +38530 +38531 +38532 +554 +25140 +38533 +19 +15718 +2197 +379 +143 +30051 +38534 +38535 +3395 +823 +25237 +29628 +33693 +19 +19144 +7053 +38536 +3546 +19 +248 +38537 +38538 +38539 +177 +77 +26161 +2694 +21698 +536 +16846 +2733 +12987 +38540 +5315 +13801 +15718 +1090 +28494 +2764 +283 +906 +170 +29134 +590 +9 +1082 +38541 +2770 +17872 +19618 +32 +38542 +77 +18045 +38543 +519 +14369 +38544 +440 +38545 +20556 +5117 +22302 +38546 +17 +38547 +1090 +17029 +22797 +11073 +9 +19995 +43 +38548 +411 +38549 +66 +1716 +4055 +4411 +19565 +89 +34433 +265 +14604 +38550 +38551 +590 +38552 +38553 +27719 +38554 +8668 +43 +38555 +38556 +38557 +99 +38558 +12013 +4033 +38559 +38560 +910 +25420 +590 +7053 +1090 +38561 +519 +10946 +38562 +30877 +38563 +1605 +10068 +13786 +10946 +38564 +22552 +19 +37556 +38565 +15718 +17467 +38566 +38567 +178 +10946 +3546 +25943 +38568 +22 +7208 +2635 +38569 +38570 +27669 +38571 +345 +5627 +21947 +9 +37556 +37556 +38572 +38573 +38574 +21947 +38575 +1425 +18503 +22986 +9144 +3330 +38576 +694 +14048 +38577 +38578 +10946 +16981 +38579 +25316 +27669 +17151 +38580 +36037 +9 +19 +23103 +38581 +38582 +38583 +1100 +38584 +14477 +66 +38585 +24207 +33061 +9 +20941 +38586 +38587 +24972 +1181 +1042 +179 +38588 +34402 +12684 +2117 +568 +19 +26519 +31041 +398 +38589 +38590 +28317 +15344 +38591 +29381 +38592 +38593 +31634 +13569 +1401 +31168 +38594 +38595 +4367 +4547 +22420 +38596 +35090 +38597 +5119 +8668 +38598 +9 +213 +36639 +38599 +3030 +10946 +38600 +38601 +1090 +671 +7836 +14369 +24375 +213 +1818 +590 +5784 +36735 +57 +11754 +38602 +14404 +25584 +38603 +213 +57 +6121 +349 +15511 +43 +38604 +38605 +15718 +1502 +7516 +38606 +1426 +4461 +23103 +18616 +38607 +25 +19220 +1082 +38608 +38609 +33650 +815 +36070 +38610 +38611 +671 +5578 +21208 +415 +29540 +5316 +38612 +16574 +12466 +38613 +34181 +37556 +736 +25904 +16 +4452 +38614 +37556 +9 +25316 +19 +31541 +4055 +19702 +37556 +3075 +25316 +38615 +22903 +19 +861 +989 +38616 +38617 +19 +38618 +38619 +22464 +19618 +1090 +38620 +36638 +4124 +25316 +10818 +337 +15718 +31293 +43 +15718 +38621 +16096 +720 +14001 +3543 +38622 +38623 +1090 +38624 +10511 +317 +27669 +590 +38625 +38626 +17 +38627 +38628 +60 +16177 +8716 +5816 +1870 +17911 +971 +809 +7511 +38629 +38630 +736 +284 +6943 +28199 +284 +1224 +651 +248 +38631 +3553 +28666 +12044 +26040 +38632 +38633 +2410 +38634 +5085 +209 +2410 +7053 +15718 +38635 +730 +1090 +31168 +14693 +1606 +736 +590 +21947 +13754 +13848 +31098 +4055 +38636 +21947 +38637 +20700 +8392 +19587 +16511 +38638 +3119 +3546 +213 +4061 +23799 +284 +1817 +38639 +38640 +26142 +5318 +303 +213 +19792 +38641 +14477 +2430 +13721 +16466 +7053 +18061 +28441 +415 +37770 +3943 +38642 +38643 +38644 +13361 +8392 +38645 +286 +14330 +4055 +27575 +1847 +38646 +14795 +38478 +27669 +66 +284 +12911 +284 +38647 +19618 +26475 +38648 +971 +33974 +38649 +201 +38650 +38651 +38652 +20 +38653 +33552 +31293 +12063 +4684 +38654 +284 +38655 +671 +10946 +25129 +21947 +57 +33447 +34641 +38656 +887 +38465 +770 +24860 +38657 +4055 +38658 +809 +21947 +30532 +33494 +13721 +18815 +22556 +5188 +31293 +37556 +38659 +38660 +4647 +7154 +57 +38661 +31787 +17448 +20326 +19 +1779 +1356 +15718 +3391 +9 +38662 +1529 +38663 +38664 +38665 +6364 +38666 +38667 +21947 +31293 +337 +16466 +38668 +30877 +38669 +38670 +10 +18159 +2769 +38671 +2043 +26030 +415 +30877 +38672 +38673 +1090 +30464 +38674 +38675 +1689 +38676 +25140 +38677 +77 +12402 +5614 +14 +284 +201 +38678 +32650 +38679 +38680 +3743 +43 +19 +3147 +30097 +38681 +31293 +32349 +38682 +25943 +9 +28549 +38003 +14001 +17229 +205 +1090 +38683 +20514 +19655 +10718 +19 +23103 +43 +26060 +38684 +19 +342 +32402 +38685 +28302 +31150 +19 +38686 +12741 +284 +8668 +38687 +9 +28199 +3353 +38688 +38689 +37556 +38690 +301 +38691 +38692 +38693 +38694 +24862 +38695 +22809 +15083 +89 +38696 +38697 +2465 +18345 +554 +736 +38698 +11762 +27669 +18019 +38699 +38700 +1710 +345 +5582 +11957 +11158 +37289 +30877 +38701 +38702 +38703 +38704 +57 +4055 +590 +38705 +38706 +23404 +38707 +38708 +38709 +1889 +24862 +31168 +38710 +10624 +3369 +809 +38711 +337 +104 +38712 +21947 +399 +21947 +15718 +33650 +38713 +5089 +3978 +9 +736 +7053 +14935 +22 +38714 +38715 +28423 +19 +38716 +38717 +38718 +1066 +38719 +3994 +27669 +38366 +30917 +43 +365 +38720 +38721 +248 +16466 +9 +28036 +365 +38722 +1109 +38723 +23103 +38724 +38725 +18369 +57 +38726 +12095 +38727 +345 +38728 +554 +17136 +38729 +6514 +38730 +37556 +4055 +27669 +14477 +38731 +38732 +1566 +38733 +9 +32 +27566 +1018 +24864 +29483 +16944 +29381 +38734 +38735 +38736 +38737 +1047 +38738 +38739 +37556 +38740 +38741 +19 +38742 +1655 +32856 +32410 +37556 +28036 +38743 +38744 +590 +38745 +16024 +14597 +21947 +11762 +30933 +38746 +24303 +89 +29629 +30224 +492 +38747 +31047 +15683 +492 +22236 +3546 +38748 +38749 +9 +15 +7629 +23150 +38750 +89 +38751 +19 +745 +1082 +38752 +15 +1082 +21947 +2622 +38499 +38753 +38754 +38755 +4488 +1090 +38756 +270 +38757 +38758 +38759 +19 +38760 +38761 +38762 +4414 +38763 +12722 +1100 +2158 +38764 +155 +4116 +37770 +19 +38765 +286 +14616 +32379 +38766 +21947 +37556 +37556 +29381 +17228 +57 +286 +43 +1847 +3599 +15718 +416 +38767 +28317 +38768 +2567 +5340 +10946 +15 +21947 +9 +272 +1090 +21947 +38769 +38770 +201 +11647 +38771 +38772 +21947 +38773 +573 +14477 +18283 +4701 +323 +37976 +18896 +38774 +9 +38775 +136 +38776 +38777 +38778 +20005 +317 +2694 +1090 +6732 +29628 +38779 +38780 +38781 +25584 +1559 +21045 +1091 +5188 +28649 +18695 +38782 +98 +25 +2762 +38783 +6953 +30117 +17602 +536 +38784 +28893 +10172 +1300 +720 +17144 +2260 +22677 +9870 +33650 +38785 +2770 +38786 +8392 +1514 +15 +38787 +19 +15 +38067 +19694 +677 +4166 +18503 +24458 +16 +7123 +828 +30551 +736 +172 +38788 +43 +14185 +21698 +38789 +38790 +38791 +25 +9 +15718 +558 +349 +43 +38792 +38793 +21336 +24896 +38794 +38795 +17911 +1011 +4441 +38796 +16935 +38797 +33222 +38798 +15824 +9628 +2260 +7053 +38799 +18589 +37204 +35969 +18695 +30051 +29204 +57 +16437 +590 +31293 +38800 +38801 +21947 +37881 +38802 +1710 +38803 +38804 +38805 +484 +16886 +1764 +887 +38806 +25668 +32 +17338 +15649 +4441 +27669 +24864 +21681 +43 +25 +2561 +7835 +43 +373 +38807 +31041 +12417 +99 +19355 +38808 +5803 +22607 +38809 +9 +14604 +3546 +17158 +9 +38810 +38811 +38812 +26389 +38813 +14369 +37959 +70 +8318 +19 +38814 +66 +28219 +38815 +8244 +89 +38816 +38817 +32 +1090 +16447 +43 +38818 +38819 +2061 +38820 +31293 +10946 +38821 +15146 +38822 +38823 +20943 +5627 +38824 +38825 +38826 +15718 +4230 +10946 +11966 +38827 +416 +10583 +38828 +13307 +3546 +99 +34999 +38829 +28474 +5700 +8639 +19 +17338 +38033 +10946 +38830 +3999 +2926 +38831 +736 +57 +21694 +20280 +38832 +17151 +25237 +349 +1716 +38833 +9178 +38834 +16121 +8160 +17151 +38835 +25316 +2982 +188 +38836 +38837 +645 +30051 +38838 +38839 +153 +29483 +19 +38840 +15718 +1716 +397 +38841 +38842 +415 +38843 +2038 +18982 +38844 +31293 +4125 +3492 +38845 +25316 +38846 +31401 +38847 +533 +38848 +18695 +1090 +38849 +35318 +57 +14330 +9 +26320 +38850 +590 +38851 +70 +38852 +38853 +38854 +22 +12200 +38855 +399 +38856 +43 +38857 +38858 +2766 +38859 +38860 +38861 +373 +15718 +2259 +38862 +37556 +25237 +38863 +11461 +14660 +38760 +38864 +38760 +164 +38865 +17033 +22 +18895 +38866 +17054 +1310 +38867 +590 +43 +38868 +38869 +38870 +38871 +38872 +4055 +7745 +27669 +30224 +38873 +1090 +38874 +2197 +27369 +1961 +8727 +1384 +38875 +46 +1513 +38876 +25316 +1531 +21947 +1425 +38877 +1316 +7320 +36492 +17449 +38878 +11539 +4024 +201 +21045 +1797 +9 +38879 +16 +32 +38880 +349 +21874 +1090 +38881 +1716 +1434 +15 +16443 +13721 +38882 +1749 +16648 +38883 +38884 +14363 +38885 +2770 +1169 +11754 +38886 +354 +1415 +384 +140 +20515 +18283 +30877 +18951 +12344 +38887 +38888 +31293 +15951 +2733 +38889 +38890 +38891 +1792 +19618 +38892 +38893 +1562 +38894 +38895 +590 +3767 +32245 +6620 +33494 +19 +38896 +38897 +2197 +25237 +1637 +2318 +22099 +33316 +28625 +38898 +38899 +38900 +24457 +76 +745 +23603 +38901 +3989 +28116 +349 +38902 +2827 +1517 +16 +15699 +7835 +25584 +2561 +20952 +38903 +38774 +38904 +19 +15718 +16327 +197 +707 +38905 +3553 +38906 +3994 +38907 +20898 +720 +38908 +38909 +283 +14520 +29992 +38910 +9 +38911 +30877 +228 +38912 +9 +38913 +13570 +38914 +23418 +2769 +38915 +379 +1382 +13696 +38916 +21947 +3964 +44 +114 +38917 +2988 +16436 +38918 +7939 +379 +6264 +15 +1605 +36735 +26048 +9 +38919 +30877 +1011 +38920 +3509 +10946 +38921 +936 +38922 +554 +15871 +11822 +29278 +1300 +38923 +17872 +38924 +1066 +38925 +38926 +24774 +38927 +38928 +38929 +9 +8367 +3546 +1514 +573 +33494 +38930 +19 +736 +8961 +201 +38931 +34402 +8110 +38932 +66 +5244 +16413 +6321 +1779 +43 +15572 +24144 +38933 +38934 +38935 +6067 +586 +590 +38936 +317 +38937 +38938 +24864 +538 +7516 +2314 +736 +11926 +9 +14477 +16466 +1502 +3376 +21947 +11 +38939 +38940 +19 +37556 +38941 +1048 +970 +519 +23103 +14079 +25237 +1415 +25316 +16060 +38942 +38943 +770 +3976 +30224 +43 +19160 +38944 +38945 +155 +27178 +188 +4055 +646 +5188 +33650 +38946 +38947 +4677 +38948 +25316 +176 +38949 +38950 +377 +24303 +30209 +38951 +14909 +31576 +764 +33650 +38952 +8685 +19542 +209 +4055 +915 +25316 +18283 +38953 +21268 +38954 +38955 +14363 +38956 +4547 +20340 +11639 +38957 +27669 +19 +38958 +34438 +1090 +38959 +24896 +38960 +31346 +38961 +38962 +1471 +30056 +590 +38963 +590 +4012 +38964 +7516 +568 +38965 +38966 +9 +38967 +38968 +38969 +2410 +38970 +15718 +568 +30877 +30877 +38971 +1681 +12987 +38972 +14 +38973 +21947 +38974 +38975 +22 +9210 +155 +286 +31234 +19 +34402 +43 +38976 +21947 +16327 +4682 +38977 +37556 +495 +46 +145 +38978 +22091 +21947 +3376 +23874 +15718 +9 +38979 +38980 +1617 +24972 +25 +1437 +38981 +411 +34889 +38982 +38117 +38983 +36328 +19 +25526 +1575 +3251 +33650 +5085 +196 +286 +38984 +24303 +6877 +14369 +1617 +4055 +8297 +38985 +155 +16234 +38986 +30927 +4461 +7721 +19918 +38987 +7743 +1047 +22798 +38988 +37556 +38989 +2577 +38990 +38991 +1051 +7706 +20 +38992 +1090 +38993 +30051 +20 +12584 +7419 +16437 +38994 +2035 +38995 +155 +38996 +765 +43 +590 +3964 +38997 +38998 +2260 +38999 +39000 +39001 +24303 +39002 +24864 +38465 +15722 +39003 +24303 +27260 +39004 +590 +514 +39005 +39006 +32518 +39007 +39008 +33909 +30224 +35357 +1578 +31293 +7516 +39009 +39010 +43 +39011 +38465 +39012 +32856 +39013 +34402 +39014 +2367 +1617 +19 +39015 +536 +9 +39016 +29204 +448 +17144 +3421 +282 +1768 +39017 +8249 +39018 +1224 +730 +15718 +24725 +31225 +30877 +37556 +8982 +21947 +39019 +57 +35496 +13620 +39020 +32 +39021 +1920 +36735 +17151 +7379 +2764 +21268 +33693 +39022 +39023 +39024 +29483 +37920 +39025 +369 +21947 +18951 +2635 +18045 +6997 +39026 +39027 +24302 +1157 +34171 +28441 +30877 +39028 +9 +39029 +39030 +26496 +21947 +140 +665 +20489 +10946 +21689 +39031 +39032 +19 +33650 +35948 +1961 +39033 +38667 +39034 +36268 +39035 +9 +15718 +958 +590 +38465 +39036 +39037 +39038 +349 +39039 +194 +39040 +8668 +39041 +1989 +39042 +3599 +39043 +39044 +31576 +14327 +2593 +37556 +21947 +7053 +39045 +30224 +17217 +10791 +590 +60 +17040 +39046 +39047 +3542 +228 +22464 +39048 +1364 +6439 +14770 +5582 +30877 +6364 +10946 +30051 +36721 +892 +30417 +39049 +36735 +39050 +2457 +2561 +1732 +1246 +39051 +2040 +21031 +10946 +53 +39052 +286 +1364 +554 +201 +15718 +17151 +2919 +16853 +1090 +14650 +34890 +39053 +39054 +283 +39055 +4028 +39056 +39057 +39058 +39059 +15096 +915 +10147 +39060 +39061 +21732 +10946 +33650 +9 +8334 +39062 +15295 +39063 +43 +33650 +27669 +37556 +27669 +17602 +13375 +39064 +39065 +8639 +9 +27669 +5891 +39066 +1563 +39067 +14477 +39068 +39069 +14477 +6001 +43 +7835 +35318 +286 +39070 +12579 +24896 +7835 +19 +21337 +5344 +28036 +153 +590 +29483 +39071 +39072 +16327 +140 +39073 +18627 +15718 +16466 +39074 +317 +39075 +365 +16437 +46 +590 +8668 +2260 +43 +39076 +142 +1508 +7835 +39077 +16437 +39078 +31293 +16437 +1107 +39079 +39080 +590 +39081 +179 +2550 +30224 +39082 +39083 +27669 +25943 +29483 +39084 +21776 +9 +39085 +39086 +9 +25140 +39087 +16919 +9939 +37588 +39088 +8297 +11096 +19618 +57 +15718 +568 +14271 +16466 +345 +1090 +39089 +13323 +39090 +39091 +3546 +164 +39092 +32763 +1688 +2040 +39093 +39094 +430 +10946 +30877 +7053 +9 +500 +39095 +34204 +39096 +9 +1090 +39097 +39098 +39099 +39100 +39101 +39102 +4055 +736 +14369 +39103 +17151 +37764 +39104 +19 +707 +10946 +16160 +39105 +39106 +39107 +14001 +25983 +39108 +238 +33921 +17151 +736 +39109 +5963 +3959 +9118 +37556 +39110 +39111 +14 +39112 +39113 +39114 +11762 +11013 +29082 +39115 +39116 +1540 +39117 +30794 +9 +32 +21947 +24113 +22 +22197 +39118 +4899 +39119 +5188 +5344 +19 +15 +33438 +4055 +554 +590 +16 +17911 +14604 +379 +27521 +21627 +33650 +17232 +39120 +89 +19797 +36638 +39121 +39122 +39123 +10028 +43 +703 +34944 +39124 +554 +19 +590 +29687 +1920 +30224 +39125 +4055 +533 +39126 +39127 +39128 +99 +39129 +19 +7544 +10 +39130 +15539 +2532 +5188 +39131 +39132 +39133 +19 +178 +39134 +43 +39135 +1013 +30224 +14660 +22799 +1563 +39136 +554 +39137 +57 +39138 +19 +4055 +284 +29381 +1082 +7855 +122 +33447 +67 +9595 +39139 +590 +39140 +104 +39141 +39142 +457 +52 +46 +39143 +39144 +32782 +39145 +39146 +25589 +37556 +39147 +14648 +29204 +5209 +31168 +34 +19178 +1688 +284 +14369 +29483 +39148 +39149 +39150 +39151 +349 +140 +5188 +20677 +3546 +8501 +39152 +39153 +39154 +12202 +10946 +1425 +25316 +39155 +209 +12348 +9 +1090 +39156 +39157 +39158 +7583 +39159 +39160 +39161 +39162 +39163 +57 +28316 +9 +4328 +39164 +39165 +15647 +16447 +39166 +39167 +20442 +303 +590 +15 +10501 +35 +2694 +4765 +19 +35284 +590 +39168 +39169 +12 +19 +15311 +971 +39170 +10147 +12987 +34706 +12969 +39171 +590 +4518 +284 +284 +39172 +9 +21947 +37556 +39173 +39174 +5085 +39175 +30568 +48 +6261 +13905 +7276 +39176 +242 +19 +39177 +28441 +18503 +519 +30224 +2314 +2414 +14 +39178 +17151 +39179 +39180 +3546 +39181 +39182 +30877 +39183 +1090 +6701 +915 +16562 +34402 +39184 +703 +677 +27362 +39185 +1912 +20355 +365 +29172 +24180 +5780 +286 +5784 +11762 +248 +39186 +39187 +46 +22963 +39188 +1710 +9 +14 +43 +39189 +2147 +140 +46 +2281 +14001 +39190 +5499 +9 +21947 +39191 +30051 +39192 +39193 +39194 +39195 +415 +29483 +21947 +1107 +887 +89 +15 +25237 +4116 +39196 +39197 +39198 +39199 +38465 +21947 +286 +10946 +39200 +39201 +358 +43 +43 +14947 +20005 +14914 +30051 +39202 +586 +99 +37556 +38465 +6011 +872 +33650 +248 +39203 +14 +39204 +39205 +39206 +39207 +33650 +39208 +19 +12121 +595 +209 +19 +29130 +39209 +39210 +39211 +39212 +12777 +2419 +33293 +19 +736 +590 +349 +17635 +39213 +24988 +2446 +34402 +155 +1011 +27669 +3759 +2 +1604 +4124 +17911 +24864 +29859 +33627 +24303 +15 +14477 +323 +248 +25237 +379 +39214 +18257 +38760 +5188 +721 +8249 +39215 +39216 +14909 +15710 +3242 +2944 +19 +17911 +15718 +1090 +21268 +39217 +43 +5188 +18954 +4055 +5007 +39218 +5650 +39219 +703 +12005 +1559 +30877 +2804 +39220 +39221 +1244 +1503 +303 +39222 +30877 +8208 +2865 +1090 +3546 +77 +37556 +39223 +33494 +18798 +9 +39224 +21689 +19355 +213 +43 +30223 +39225 +23226 +37556 +30877 +495 +31293 +4055 +4195 +887 +399 +248 +39226 +39227 +4055 +12299 +39228 +37556 +39229 +39230 +39231 +30232 +3655 +24862 +35220 +43 +303 +9 +39232 +39233 +1710 +31852 +39234 +37556 +18951 +39235 +39236 +568 +176 +30877 +39237 +19 +39238 +43 +39239 +140 +9 +39240 +33494 +3858 +4055 +11763 +39241 +21947 +12867 +1716 +5649 +337 +14604 +5904 +20700 +28317 +39242 +10946 +39243 +17 +39244 +31234 +43 +39245 +39246 +39247 +1300 +39248 +12267 +286 +3248 +14079 +39249 +2832 +6344 +27069 +1090 +39250 +1571 +37556 +21947 +39251 +25683 +1090 +33627 +39252 +43 +34719 +17215 +14909 +354 +29483 +39253 +4667 +1291 +703 +19 +9 +19 +89 +15718 +1524 +39254 +39255 +39256 +33120 +1018 +30224 +33758 +27719 +39257 +19 +9 +9 +39258 +10094 +222 +8602 +2197 +38893 +284 +2537 +38381 +31293 +590 +36735 +39259 +29483 +39260 +39261 +75 +43 +357 +39262 +39263 +39264 +39265 +2476 +25316 +39266 +39267 +39268 +768 +815 +32 +201 +38933 +1230 +34433 +31098 +39269 +19 +4463 +35792 +39270 +13848 +39271 +30051 +3440 +179 +21200 +39272 +57 +1961 +3858 +24725 +647 +39273 +337 +99 +39274 +39275 +284 +33650 +39276 +39277 +30230 +39278 +39279 +39280 +46 +1961 +242 +39281 +613 +74 +30005 +845 +28441 +439 +39282 +15216 +8171 +39283 +39284 +643 +817 +39285 +2349 +39286 +39287 +7226 +25237 +6161 +39288 +57 +15324 +21089 +345 +9185 +29381 +39289 +11224 +165 +10946 +39290 +138 +39291 +39292 +337 +39293 +19797 +39294 +39295 +31293 +1090 +39296 +9526 +39297 +8367 +39298 +30877 +39299 +1961 +32 +4907 +11822 +15935 +1139 +1291 +12987 +39300 +33693 +39301 +19965 +554 +2 +25140 +39302 +19318 +936 +39303 +27719 +21947 +38003 +2764 +8668 +15819 +39304 +1223 +464 +31453 +39305 +442 +39306 +39307 +39308 +24896 +39309 +720 +39310 +2733 +39311 +39312 +39313 +11073 +14843 +20 +38760 +1107 +33650 +39314 +677 +39315 +8668 +43 +39316 +39317 +19 +17670 +39318 +19009 +15718 +2804 +26320 +14816 +39319 +11321 +27798 +39320 +39321 +713 +35214 +20102 +39322 +39323 +21947 +27433 +30877 +4055 +2187 +39324 +39325 +39326 +39327 +26789 +25 +39328 +12005 +23935 +25140 +39329 +35427 +39330 +24864 +39331 +39332 +14 +5908 +39333 +25943 +927 +14330 +8787 +16773 +39334 +39335 +39336 +39337 +323 +39338 +379 +16466 +39339 +39340 +34641 +24318 +39341 +39342 +4227 +10246 +1385 +286 +6418 +379 +15718 +2406 +39343 +39344 +213 +39345 +36735 +14369 +5188 +3182 +43 +27719 +39346 +20941 +228 +33650 +39347 +9016 +25 +39348 +9410 +4907 +39349 +1300 +590 +155 +770 +39350 +21947 +39351 +77 +3679 +39352 +19618 +19 +39353 +284 +4518 +39354 +1688 +19048 +39355 +4032 +9096 +20555 +39356 +39357 +19 +39358 +248 +39359 +20 +38893 +14888 +39360 +19030 +39361 +34402 +22 +5923 +39362 +37556 +137 +25237 +6533 +286 +34444 +39363 +24864 +284 +11762 +39364 +39365 +1533 +43 +39366 +39367 +20845 +566 +39368 +1536 +15797 +1066 +39369 +30224 +209 +35155 +39370 +2832 +39371 +39372 +43 +1012 +39373 +30551 +379 +39374 +39375 +2577 +31873 +977 +18064 +39376 +31168 +39377 +286 +15370 +39378 +671 +13375 +39379 +5007 +188 +3480 +39380 +736 +25 +514 +39381 +39382 +19 +1817 +32 +865 +33061 +303 +29483 +39383 +586 +27669 +39384 +15541 +15050 +38760 +4452 +1307 +39385 +1637 +27669 +38465 +39386 +39387 +39388 +26040 +39389 +39390 +39391 +5446 +39392 +21947 +8297 +23103 +39393 +590 +39394 +39395 +39396 +12936 +39397 +39398 +19 +34402 +39399 +98 +39400 +31293 +39401 +13168 +39402 +213 +720 +19 +24051 +373 +1230 +29483 +14693 +16539 +30877 +936 +39403 +22 +39404 +770 +39405 +37556 +39406 +39407 +15341 +31370 +39408 +39409 +19 +101 +39410 +39411 +213 +29483 +39412 +30877 +8210 +248 +9 +31098 +39413 +514 +13648 +39414 +337 +29434 +14477 +495 +337 +415 +7923 +303 +39415 +1157 +39416 +33627 +3317 +39417 +284 +29007 +39418 +30224 +39419 +590 +33627 +345 +1169 +43 +22 +19852 +39420 +13361 +2694 +21947 +8380 +22598 +37556 +29711 +39421 +4055 +5188 +39422 +4055 +14369 +6598 +9948 +1172 +323 +39423 +30224 +35922 +2694 +1082 +31293 +9 +13813 +17348 +33650 +39424 +24307 +19 +4230 +14001 +25140 +14369 +4634 +11321 +39425 +26724 +826 +38465 +39426 +39427 +39428 +5351 +4153 +30224 +39429 +36734 +39430 +3759 +13113 +37556 +865 +36146 +38465 +22842 +590 +39431 +39432 +39433 +14330 +33494 +11312 +21947 +4042 +16466 +31234 +39434 +15718 +15 +39435 +440 +155 +19618 +27669 +6238 +39436 +39437 +30494 +25501 +1442 +28490 +248 +14992 +1384 +43 +36515 +3381 +11484 +39438 +4055 +2804 +37556 +22922 +3546 +39439 +11321 +17385 +39440 +586 +694 +21089 +39441 +14330 +1056 +33951 +5085 +39442 +39443 +39444 +39445 +27669 +21947 +39446 +20700 +39447 +39448 +34752 +19 +39449 +13777 +39450 +12454 +15718 +39451 +36208 +720 +39452 +39453 +13905 +24423 +57 +39454 +19 +14369 +2709 +39455 +671 +39456 +39457 +613 +39458 +25943 +915 +39459 +36218 +39460 +34 +19 +303 +115 +19029 +30224 +25943 +37127 +39461 +39462 +24405 +15 +21947 +39463 +32915 +19 +345 +24862 +39464 +39465 +39466 +19489 +1426 +39467 +39468 +2197 +317 +39469 +29483 +8727 +39470 +19 +14604 +12987 +35214 +27043 +30877 +7471 +103 +32 +23727 +1090 +21776 +39471 +1384 +39472 +39473 +39474 +29406 +39475 +25316 +736 +31041 +17412 +39476 +21947 +9 +31168 +39477 +915 +4330 +15906 +1112 +4808 +39059 +595 +39478 +30877 +39479 +590 +10 +33650 +17670 +33120 +29381 +39480 +22815 +39481 +286 +39482 +201 +39483 +39484 +38523 +24332 +24303 +31575 +17691 +16826 +19655 +1090 +822 +39485 +21947 +38008 +2009 +5071 +39486 +30224 +13424 +1090 +39487 +39488 +39489 +25624 +1513 +554 +25140 +33494 +301 +39490 +323 +39491 +4518 +15 +1083 +39492 +39493 +7810 +21187 +8053 +39494 +1164 +30224 +39495 +57 +39496 +31098 +39497 +11593 +39498 +24725 +736 +1710 +39499 +1212 +39500 +39501 +26361 +39502 +39503 +33758 +31346 +33278 +373 +39504 +39505 +38003 +25683 +14477 +39506 +39507 +415 +272 +39508 +1749 +1765 +39509 +39510 +39511 +2314 +1680 +13988 +39512 +8378 +29204 +35591 +17615 +18695 +31873 +39513 +17385 +22986 +484 +1112 +39514 +16826 +16511 +39515 +30309 +57 +39516 +14369 +43 +590 +39517 +39518 +21269 +28036 +39519 +29483 +18904 +39520 +39521 +7027 +57 +176 +10177 +9 +39522 +39523 +29483 +286 +14586 +10500 +1011 +27719 +21947 +8392 +26928 +39524 +568 +22314 +43 +284 +14330 +9 +10946 +440 +19 +39525 +39526 +39527 +39528 +573 +39529 +25140 +19 +53 +2577 +3260 +665 +31881 +36638 +23112 +39530 +36481 +39531 +3637 +39532 +1428 +201 +39533 +8670 +53 +39534 +25904 +14 +7053 +228 +1082 +1153 +35633 +4124 +15249 +39535 +43 +9 +17295 +14001 +39536 +491 +39537 +39538 +14066 +39539 +39323 +39540 +34 +39541 +590 +39542 +25316 +8890 +13721 +1051 +33116 +39543 +39544 +14369 +27069 +24303 +19209 +39545 +39546 +2764 +24144 +6471 +2 +19 +31225 +554 +9 +24725 +39547 +19618 +1090 +39548 +352 +37388 +14369 +39549 +25237 +21947 +31042 +7053 +39550 +34402 +89 +646 +39551 +39552 +286 +15 +39553 +104 +613 +29204 +21627 +17911 +209 +19 +39554 +57 +7053 +39555 +39556 +16782 +15537 +39557 +22800 +14152 +2739 +15 +21742 +10 +30877 +1141 +34317 +19918 +278 +39558 +39559 +39560 +30449 +33627 +39561 +2733 +2975 +14369 +38523 +28549 +19 +39562 +15718 +39563 +1352 +286 +39564 +39565 +16398 +1172 +18695 +317 +4339 +2009 +21947 +28317 +24303 +24862 +15 +193 +1011 +14840 +39566 +25316 +31293 +39567 +39568 +815 +590 +30051 +209 +1870 +24864 +4650 +4055 +39569 +39570 +15718 +21947 +39571 +5327 +39572 +14001 +39573 +98 +39574 +31098 +349 +1181 +411 +7774 +39575 +39576 +39577 +25683 +17077 +34402 +15671 +39578 +11600 +6883 +576 +910 +24864 +2694 +5188 +1090 +39579 +39580 +39581 +8357 +39582 +39583 +19618 +21947 +19724 +36268 +20677 +1090 +11797 +8356 +39584 +37556 +39585 +39586 +30224 +39587 +38595 +28317 +5231 +10846 +43 +31293 +36783 +39588 +39589 +33627 +31293 +37920 +16 +30224 +12067 +15 +39590 +30221 +39591 +19 +1563 +39592 +39593 +590 +37556 +39594 +4352 +39595 +39596 +18345 +2243 +1562 +17396 +70 +32566 +36268 +29153 +44 +39597 +22 +19 +15547 +2919 +29434 +39598 +39599 +358 +39600 +15370 +1157 +349 +11249 +30458 +39601 +34 +39602 +30877 +39603 +1517 +39604 +16437 +1920 +10677 +3598 +39605 +6122 +19 +16 +317 +1571 +33385 +18283 +11429 +14 +39606 +33709 +24036 +39607 +19 +1212 +39608 +39609 +32 +1090 +20496 +39590 +39610 +39611 +39612 +26922 +13721 +39613 +39614 +32 +354 +590 +39615 +1157 +5627 +30877 +265 +33494 +707 +38760 +15718 +2310 +14856 +286 +23741 +2372 +39616 +39617 +12251 +39618 +57 +39619 +6531 +19655 +39620 +26361 +4055 +7661 +39621 +39622 +30877 +25140 +1011 +39623 +39590 +70 +1011 +53 +39624 +1224 +39625 +39626 +4684 +590 +2031 +39627 +39628 +24864 +1090 +39629 +23103 +19 +25048 +11072 +18045 +33627 +9 +39630 +27669 +13179 +21729 +8297 +9 +411 +39631 +27147 +39632 +861 +30877 +345 +1442 +31172 +39633 +34264 +39634 +2865 +14330 +1013 +33650 +3904 +3601 +33650 +30481 +39635 +43 +39636 +28317 +5065 +39637 +39638 +19 +27224 +39639 +39640 +39641 +39642 +25 +865 +31168 +20158 +4056 +39643 +39644 +8668 +11670 +22844 +3546 +39645 +39646 +39647 +990 +29875 +566 +39648 +37525 +37819 +39649 +37556 +30449 +2755 +39650 +39651 +39652 +3182 +14127 +39653 +66 +4002 +27043 +29483 +39654 +34402 +1107 +39655 +46 +39656 +1870 +19 +39657 +39658 +9440 +5085 +39659 +39660 +33627 +39661 +38527 +32581 +20288 +66 +30580 +17151 +11421 +6571 +13721 +39662 +2187 +39663 +1115 +37556 +39664 +140 +39665 +1384 +5409 +39666 +39667 +39668 +9771 +15718 +3743 +39669 +590 +1410 +39670 +16542 +4808 +32022 +1961 +37556 +9 +43 +39671 +15 +39672 +39673 +30650 +63 +28316 +5293 +39674 +22757 +39675 +1531 +38478 +972 +17267 +19 +36218 +39676 +43 +16 +39677 +6531 +14660 +39678 +39679 +19 +668 +39680 +19 +2804 +39681 +37920 +15698 +33553 +39682 +39683 +39684 +38033 +795 +23103 +39685 +8685 +379 +21521 +7835 +13143 +12589 +1051 +21947 +39686 +209 +39687 +645 +10 +25481 +39688 +19283 +39689 +32520 +39690 +33278 +36268 +39609 +11312 +24303 +39691 +554 +39692 +24889 +1470 +225 +39693 +39694 +39695 +16609 +39696 +39697 +31293 +590 +9 +39698 +533 +13399 +14679 +37290 +39699 +39700 +43 +39701 +8437 +39702 +39703 +39704 +23497 +35948 +16121 +15718 +39705 +2195 +3553 +2604 +4055 +39706 +15718 +849 +892 +558 +14340 +21689 +1454 +39707 +19 +39708 +39709 +39710 +590 +19 +4525 +140 +4274 +39711 +39712 +15 +32190 +39713 +137 +39714 +349 +39715 +5204 +38760 +33650 +554 +24896 +1011 +2694 +39716 +12661 +115 +9573 +25237 +14369 +29381 +36755 +99 +23264 +39717 +30877 +39718 +10 +349 +16826 +43 +29381 +39719 +39720 +23103 +3104 +39721 +39722 +29483 +66 +6294 +39723 +2471 +1765 +2300 +845 +39724 +26496 +6766 +31873 +15718 +16331 +14330 +21338 +10 +12555 +415 +39725 +16437 +30877 +31906 +34402 +31293 +22 +1870 +5877 +39726 +39727 +39728 +13943 +137 +21947 +176 +15718 +24332 +3546 +2795 +39729 +323 +1107 +39730 +13721 +39731 +34402 +29483 +1562 +36268 +36638 +6499 +29483 +37556 +39732 +39733 +31098 +6110 +15 +39734 +19178 +39735 +30224 +317 +5679 +39736 +1577 +32332 +4306 +2577 +39737 +39738 +39739 +39740 +21947 +1090 +39741 +1471 +7960 +31139 +349 +19 +39742 +2325 +39743 +586 +39744 +39745 +39746 +36268 +39747 +39748 +32410 +39749 +39709 +39750 +10946 +365 +554 +43 +39751 +2135 +39752 +39753 +29483 +13905 +701 +345 +22949 +39754 +519 +26657 +33295 +39755 +39756 +33627 +590 +43 +3172 +39757 +39758 +21947 +39759 +28186 +703 +1047 +28965 +19655 +648 +3915 +9 +8727 +17151 +39760 +39761 +39762 +736 +15718 +6072 +31293 +4518 +1018 +19 +1442 +38523 +14025 +17 +37556 +1120 +19995 +39763 +39764 +14909 +43 +357 +39765 +955 +188 +18310 +39766 +39767 +39768 +19994 +39769 +4779 +225 +21672 +36268 +19 +13396 +21947 +39770 +37770 +39771 +39772 +7855 +28317 +7053 +25 +1090 +15 +39773 +19 +39211 +39774 +21947 +34433 +590 +19852 +14477 +39775 +37556 +2764 +57 +39776 +39777 +39778 +39779 +39780 +26496 +38465 +4808 +3553 +39781 +39782 +39783 +39784 +39785 +39786 +20058 +2264 +590 +2804 +39787 +23231 +39788 +32275 +15823 +39789 +970 +3491 +1090 +39790 +21947 +39791 +9 +89 +6499 +39792 +14369 +36268 +5314 +349 +39793 +39794 +1090 +179 +39795 +39796 +3100 +1066 +13474 +109 +27669 +13803 +19058 +39797 +39798 +2097 +399 +4124 +14 +39799 +2532 +24725 +39800 +1090 +36394 +39801 +15461 +736 +31293 +26049 +9 +18310 +24864 +21947 +1090 +317 +31293 +39802 +37504 +39803 +1021 +39804 +39805 +19 +4472 +14689 +39806 +3546 +32410 +43 +4055 +17149 +36218 +39807 +17151 +39808 +25140 +31293 +39809 +736 +39810 +28036 +37556 +286 +37556 +736 +19 +21947 +1051 +12185 +2324 +4441 +37556 +39811 +5642 +1531 +39812 +12005 +30877 +541 +34337 +13349 +19 +9 +39813 +720 +533 +24458 +39814 +18418 +1822 +36218 +1090 +32 +6468 +590 +3764 +13448 +37556 +14330 +11762 +39815 +39816 +39817 +36268 +31098 +39818 +19 +29945 +24303 +533 +20514 +20718 +15718 +43 +39819 +30650 +39820 +39821 +39822 +24896 +14477 +3127 +39823 +15 +23103 +1090 +39824 +33627 +14369 +15718 +39825 +14363 +4461 +39826 +38523 +3296 +21947 +9922 +23103 +5780 +12590 +39827 +16466 +2197 +39828 +1090 +18136 +39829 +10791 +15718 +5153 +39830 +39831 +24725 +39832 +6364 +1559 +39833 +1647 +43 +39834 +713 +31293 +590 +286 +25140 +373 +18310 +39835 +9 +17170 +18896 +2567 +25237 +1481 +9 +17571 +35832 +15718 +26210 +30551 +16239 +1425 +9 +14369 +39836 +39837 +10769 +32332 +30580 +39838 +30224 +39839 +1100 +39840 +7835 +24840 +179 +39841 +22912 +26320 +176 +590 +39842 +34537 +3407 +21949 +2581 +39843 +39844 +38595 +7835 +15068 +39845 +39846 +39847 +39848 +39849 +1116 +14369 +39850 +345 +21776 +16612 +5912 +31041 +1018 +7053 +528 +32 +9 +17602 +39851 +39852 +21947 +39853 +827 +39854 +35076 +39855 +39856 +39857 +26496 +31293 +4439 +39858 +31293 +43 +411 +27669 +379 +39859 +26611 +39860 +29204 +21947 +286 +39861 +39862 +19655 +39863 +21738 +9 +484 +16450 +7732 +29798 +39864 +22176 +39865 +39866 +39867 +5314 +12919 +484 +39868 +140 +29381 +43 +138 +39869 +89 +1280 +8214 +24766 +14477 +4056 +14477 +39870 +1224 +15654 +39871 +39872 +39873 +39874 +39875 +4820 +19284 +19 +29204 +39876 +39877 +19 +43 +29200 +1108 +39878 +39879 +39880 +9 +39881 +39882 +590 +17635 +30877 +36483 +11754 +24322 +28961 +14825 +39883 +14330 +39884 +24324 +1169 +4502 +3994 +29204 +31293 +3904 +6718 +39885 +17151 +39536 +39886 +39887 +1606 +2187 +28317 +745 +19 +9 +39888 +39889 +43 +514 +39890 +1011 +533 +7237 +861 +17897 +16437 +8160 +30224 +39891 +2 +31293 +36268 +39892 +20825 +104 +7835 +590 +19 +1090 +39893 +39894 +39895 +12231 +39896 +39897 +17033 +39898 +30877 +39899 +5737 +554 +586 +142 +528 +18695 +39900 +7855 +13409 +2919 +37556 +39901 +39902 +36218 +9 +457 +39903 +39904 +16443 +566 +39905 +39906 +27122 +34204 +43 +39907 +39908 +24864 +1749 +3030 +39909 +39910 +14 +39911 +373 +26361 +238 +19 +39912 +19618 +32 +39913 +39914 +39915 +616 +19 +4916 +39916 +39917 +39918 +14369 +39919 +2953 +39920 +38465 +39921 +39922 +7027 +25683 +39923 +2865 +21947 +14343 +323 +39924 +6833 +286 +14001 +8282 +31512 +39925 +536 +39926 +15320 +39927 +25943 +9 +832 +39928 +39929 +39930 +19 +39931 +31346 +39932 +21947 +30650 +11430 +16925 +14369 +4521 +14161 +39933 +39934 +18774 +37556 +43 +38303 +39935 +14363 +590 +36457 +39936 +39937 +39938 +39939 +30877 +9 +39940 +58 +39941 +31293 +19 +39942 +3406 +39943 +30650 +222 +1992 +11202 +1852 +2694 +39944 +26724 +39945 +29209 +2314 +39946 +8528 +14102 +28339 +39947 +1082 +24864 +14369 +39948 +21198 +509 +5780 +1720 +43 +14079 +57 +15 +7478 +39949 +3406 +39950 +39951 +39952 +478 +4760 +4055 +185 +39953 +13539 +39954 +3790 +1531 +39955 +514 +24303 +15164 +1716 +21947 +1234 +1310 +31936 +27069 +399 +31293 +5409 +17997 +39956 +31381 +32523 +98 +29483 +31098 +15 +31225 +38729 +34402 +16466 +37556 +2872 +25943 +24864 +1696 +39957 +22823 +31293 +39958 +39959 +7159 +39960 +31002 +43 +1456 +29483 +39961 +39962 +39963 +39964 +39965 +25584 +1090 +12934 +115 +39966 +39967 +39968 +39969 +2356 +15497 +17412 +37556 +31293 +39970 +7053 +31293 +39971 +21947 +9 +28036 +6115 +39972 +7904 +39973 +15 +4463 +3839 +35423 +7302 +39974 +29483 +586 +39975 +7471 +286 +39976 +1013 +880 +39977 +39978 +39979 +29483 +10946 +39980 +16826 +21947 +39981 +30535 +9 +13304 +37556 +39982 +9 +19655 +21973 +2591 +39983 +39984 +5431 +2314 +39985 +18120 +4 +528 +736 +595 +39986 +19 +446 +39987 +39988 +39989 +20851 +4441 +10 +15718 +43 +415 +39990 +11321 +39991 +39992 +39993 +39994 +39995 +357 +39996 +39997 +39998 +30877 +35086 +38003 +43 +881 +39999 +2064 +10 +40000 +1090 +1021 +2315 +30877 +40001 +15718 +40002 +40003 +40004 +19 +36268 +30877 +17911 +14363 +40005 +1508 +40006 +40007 +43 +40008 +40009 +40010 +40011 +7835 +17151 +30877 +40012 +14363 +40013 +12307 +33494 +40014 +30224 +9 +19618 +40015 +40016 +40017 +28384 +30877 +40018 +40019 +33508 +2779 +40020 +1115 +533 +40021 +40022 +5949 +31225 +862 +14 +28317 +30877 +15718 +5780 +40023 +38760 +11607 +7658 +40024 +40025 +19 +27669 +27069 +1956 +40026 +40027 +19618 +40028 +40029 +40030 +40031 +4100 +26020 +558 +40032 +10616 +20423 +29047 +40033 +19 +40034 +40035 +14947 +40036 +40037 +40038 +40039 +34957 +40040 +29172 +40041 +20442 +36735 +34602 +34402 +40042 +19632 +1710 +583 +13405 +4 +7260 +18939 +37631 +416 +40043 +40044 +15398 +37511 +1912 +4425 +25 +15 +564 +140 +43 +66 +33120 +37556 +40045 +4055 +915 +19406 +39983 +40046 +9 +15718 +29628 +1415 +736 +7123 +40047 +40048 +29483 +3148 +30650 +1013 +155 +104 +21269 +32410 +40049 +40050 +27794 +40051 +2117 +40052 +40053 +40054 +2 +34402 +40055 +137 +18695 +40056 +2349 +40057 +40058 +25316 +19 +14369 +40059 +40060 +8362 +29109 +4116 +40061 +14363 +40062 +40063 +882 +2865 +43 +286 +274 +40064 +40065 +31293 +720 +14515 +936 +29914 +14477 +28295 +38987 +40066 +31293 +40067 +40068 +5725 +736 +3050 +5659 +788 +40069 +10 +40070 +2260 +40071 +201 +21947 +40072 +40073 +3119 +590 +1090 +40074 +40075 +1513 +40076 +40077 +40078 +40079 +37556 +1021 +28961 +415 +38523 +8076 +4313 +4735 +25316 +3345 +40080 +3546 +28295 +40081 +37684 +80 +22 +40082 +39709 +19 +40083 +15 +14898 +25943 +40084 +349 +40085 +7624 +18695 +33306 +6950 +11106 +40086 +16437 +597 +15178 +31293 +17273 +14947 +40087 +40088 +40089 +11 +15718 +915 +40090 +1529 +2314 +1503 +21947 +250 +2764 +40091 +14909 +40092 +40093 +13026 +713 +24045 +40094 +36735 +9633 +119 +40095 +40096 +40097 +15 +30224 +31873 +40098 +23855 +40099 +15497 +43 +27719 +155 +31882 +9 +3484 +31293 +33494 +665 +31293 +40100 +1090 +1464 +40101 +27776 +40102 +25140 +40103 +4055 +40104 +37576 +11263 +40105 +15 +40106 +10946 +19 +40107 +40108 +5188 +40109 +1961 +40110 +38705 +17848 +491 +40111 +25245 +34 +21689 +40112 +1710 +590 +40113 +28317 +18684 +32317 +4820 +40114 +597 +40115 +9 +25140 +18684 +29483 +33010 +40116 +46 +40117 +32 +25316 +40118 +32642 +28441 +4055 +3546 +21947 +40119 +14007 +345 +14981 +3842 +10946 +40120 +484 +31098 +19 +29483 +40121 +590 +2410 +915 +365 +40122 +40123 +8186 +40124 +21947 +33627 +5188 +2577 +26027 +19918 +57 +22864 +2257 +25140 +24403 +32920 +1716 +40125 +16 +18045 +19 +411 +40126 +590 +27669 +1612 +736 +40127 +14330 +40128 +625 +40129 +40130 +14398 +2769 +1011 +1021 +989 +9 +31293 +36268 +25237 +1444 +7987 +40131 +3546 +40132 +30051 +331 +30224 +590 +14369 +10946 +38523 +25316 +40133 +19 +37556 +40134 +43 +40135 +31293 +37556 +9 +40136 +14604 +32 +25395 +868 +30144 +32532 +286 +40137 +13108 +15718 +1716 +40138 +31225 +40139 +2342 +28034 +40140 +40141 +33758 +36268 +18862 +2476 +9452 +3553 +40142 +484 +20 +40143 +40144 +36735 +4820 +30051 +39158 +40145 +2410 +31293 +11508 +1090 +18045 +40146 +19963 +33957 +533 +533 +40147 +40148 +40149 +14909 +40150 +36268 +23504 +989 +40151 +14562 +495 +9 +8367 +40152 +40153 +40154 +12936 +4055 +89 +24260 +38180 +1112 +29007 +213 +5014 +43 +20161 +40155 +415 +40156 +23103 +40157 +284 +19264 +18364 +16879 +40158 +40159 +11158 +1352 +25683 +40160 +40161 +1502 +14369 +26987 +40162 +40163 +40164 +2318 +40165 +19 +28317 +377 +284 +13663 +40166 +22963 +32 +40167 +40168 +40169 +40170 +8220 +21261 +10946 +40171 +37556 +845 +40172 +40173 +586 +40174 +1615 +1316 +40175 +43 +1208 +1961 +31293 +40176 +40177 +9 +28491 +40178 +33508 +590 +40179 +25316 +5071 +40180 +40181 +613 +14363 +4547 +1870 +248 +40182 +17799 +16327 +1531 +3601 +15598 +583 +21947 +284 +357 +40183 +40184 +30877 +40185 +720 +35551 +2264 +5780 +8029 +40186 +26361 +40187 +40188 +26496 +14369 +337 +40189 +6439 +40190 +40191 +31293 +337 +18354 +6225 +40192 +40193 +16731 +1799 +7516 +40194 +40195 +3546 +19 +14603 +14022 +26040 +31293 +4055 +40196 +19 +4026 +31168 +1951 +38465 +18684 +40197 +40198 +40199 +31293 +37556 +40200 +40201 +248 +379 +40202 +40203 +40204 +2281 +40205 +40206 +30877 +736 +2314 +40207 +43 +19 +40208 +40209 +1961 +40210 +201 +1082 +15718 +26361 +24862 +25140 +31293 +25965 +40211 +40212 +40213 +17698 +492 +33325 +40214 +554 +3421 +40215 +248 +40216 +845 +29209 +284 +28549 +10946 +286 +40217 +16063 +25943 +9 +17872 +282 +40218 +31293 +337 +20442 +822 +40219 +303 +1966 +29381 +40220 +13752 +27669 +5833 +114 +40221 +213 +40222 +40223 +554 +1300 +158 +20386 +40224 +17635 +40225 +40226 +17911 +155 +40227 +7835 +15 +2260 +34402 +34 +40228 +2804 +32 +40229 +40230 +4606 +2065 +12987 +40231 +40232 +36268 +303 +40233 +248 +40234 +40235 +43 +40236 +338 +7835 +19 +40237 +178 +40238 +40239 +40240 +13390 +40241 +40242 +12304 +40243 +3 +24864 +1364 +1889 +40244 +17603 +34584 +30224 +40245 +9573 +213 +9 +23103 +23925 +140 +31293 +40246 +4414 +40247 +40248 +590 +40249 +18300 +29945 +18807 +40250 +35992 +23166 +40251 +242 +15718 +34342 +3950 +40252 +40253 +21689 +4720 +29317 +19 +25943 +18744 +17 +38241 +568 +6364 +9573 +40254 +40255 +39983 +40256 +10318 +32714 +686 +40257 +5217 +1743 +248 +21417 +21947 +345 +36638 +5067 +40258 +40259 +40260 +1018 +165 +14369 +248 +40261 +29483 +1364 +37556 +40262 +484 +40263 +28494 +3553 +7658 +1502 +11762 +43 +40264 +40265 +40266 +9 +1696 +23103 +25683 +14477 +770 +40267 +31168 +40268 +1090 +40269 +19 +33061 +317 +1765 +590 +40270 +20442 +11522 +4 +14001 +13361 +284 +37556 +19 +16181 +31293 +40271 +21947 +40272 +26496 +14102 +8249 +33650 +677 +19 +40273 +25056 +548 +29483 +1542 +37808 +40274 +4827 +40275 +10880 +590 +40276 +25904 +40277 +37556 +15951 +40278 +37556 +1090 +671 +14369 +40279 +19618 +40280 +349 +40281 +1090 +40282 +40283 +40284 +40285 +9 +40286 +40287 +9 +40288 +4702 +40289 +10930 +40290 +16466 +3251 +40291 +6086 +40292 +14369 +14477 +712 +5409 +213 +213 +40293 +40294 +736 +19 +17151 +40295 +15914 +416 +140 +36639 +213 +40296 +38523 +40297 +377 +32332 +34641 +38042 +40298 +19354 +37556 +40086 +40299 +40300 +38523 +5344 +11664 +9 +24324 +705 +40301 +40302 +40303 +34319 +40304 +40305 +17269 +6060 +22922 +378 +21947 +6341 +17911 +40306 +15511 +40307 +176 +33627 +40308 +349 +1889 +13224 +40309 +40310 +40311 +2140 +446 +1090 +40277 +28745 +15880 +40312 +40313 +1090 +40314 +27069 +1382 +40315 +40316 +8501 +3239 +18369 +24207 +573 +40317 +1382 +1157 +21947 +10600 +40318 +21045 +19618 +37556 +40319 +31293 +643 +15718 +40320 +40321 +2314 +40322 +40323 +40324 +4055 +40325 +25140 +27719 +40326 +14369 +25904 +7053 +646 +28317 +28036 +40327 +40328 +40329 +40330 +7703 +24144 +40331 +37556 +209 +10946 +40332 +5409 +25996 +10791 +12287 +40333 +40334 +40335 +13390 +40336 +1870 +31293 +8392 +9 +29483 +3470 +12674 +2775 +16063 +137 +12989 +40337 +21269 +194 +15027 +40338 +19 +9 +15 +40339 +24303 +228 +1824 +40340 +39926 +40341 +37556 +1765 +13721 +31234 +10960 +38760 +3844 +40342 +15 +40343 +40344 +43 +1234 +40345 +40346 +176 +32 +11762 +1090 +16798 +19095 +576 +40347 +36736 +491 +15683 +7458 +12590 +40348 +18750 +39709 +1010 +34 +705 +29427 +27669 +40349 +11762 +9 +8780 +31293 +40350 +40351 +15718 +24421 +303 +29483 +40352 +586 +1563 +12987 +40353 +40354 +590 +15 +2383 +15 +4055 +40355 +40356 +8670 +19 +1444 +26708 +1090 +40357 +115 +40358 +35224 +21947 +40359 +20340 +40360 +12080 +1710 +1364 +19042 +29483 +1870 +40361 +590 +19797 +40362 +140 +40363 +30230 +25996 +40364 +40365 +14369 +9629 +40366 +40367 +40368 +38465 +15718 +40369 +317 +16472 +40370 +40371 +20984 +40372 +4278 +35244 +40373 +736 +3994 +36268 +176 +37556 +345 +3243 +40374 +373 +27669 +815 +11273 +590 +40375 +197 +31293 +37385 +30877 +40376 +39709 +9 +40377 +40378 +4055 +40379 +40380 +5188 +40381 +3 +6075 +40382 +2476 +14369 +14363 +30224 +416 +40383 +222 +40384 +910 +27669 +23103 +36736 +19 +19 +4055 +31168 +14025 +40385 +40386 +10 +40387 +1291 +18717 +21832 +28549 +40388 +20700 +40389 +19500 +14604 +39838 +8386 +40390 +2064 +36268 +28317 +4242 +14369 +5650 +40391 +40392 +7964 +40393 +20223 +40394 +43 +14947 +40395 +14079 +40396 +3055 +30051 +11762 +7516 +31679 +40397 +40398 +349 +15 +40399 +1332 +43 +40400 +37556 +40401 +26744 +28206 +40402 +40403 +21947 +566 +677 +40404 +5188 +38944 +2314 +34402 +19 +22 +40405 +37556 +21947 +2243 +20258 +29483 +9389 +13315 +11483 +40406 +40407 +40408 +40409 +66 +40410 +915 +40411 +16323 +14369 +21689 +5313 +39709 +1502 +30051 +2259 +1090 +21133 +40412 +790 +15 +40413 +4713 +5662 +40414 +2039 +1090 +1700 +40415 +12013 +39709 +12402 +40416 +8297 +5803 +2694 +3353 +1054 +2260 +43 +40417 +24303 +1680 +4 +40418 +1169 +30224 +1808 +40419 +40420 +352 +40421 +31346 +40422 +38523 +26157 +40423 +40424 +40425 +3 +164 +25316 +40426 +40427 +40428 +21947 +10 +40429 +1710 +40430 +77 +6095 +1677 +8249 +40431 +829 +1109 +20600 +40432 +17632 +40433 +30458 +29483 +4752 +40434 +40435 +590 +40436 +373 +30051 +3543 +40437 +40438 +349 +40439 +5188 +40440 +31293 +21947 +40441 +37556 +30224 +286 +590 +3546 +3976 +43 +20 +14369 +21947 +40442 +1090 +40443 +33758 +713 +1021 +30917 +3020 +7817 +9607 +25611 +11551 +40444 +40445 +40446 +46 +40447 +6123 +40448 +1090 +5119 +40449 +34402 +9 +40450 +40451 +34712 +19618 +2 +259 +14 +8867 +40452 +40453 +10004 +40454 +40455 +827 +1100 +40456 +19618 +15 +15718 +40457 +249 +40458 +40459 +40460 +21947 +40461 +89 +37556 +8513 +40462 +2038 +40463 +36735 +40464 +2315 +18045 +40465 +590 +40466 +3417 +3950 +28333 +40467 +1774 +40468 +40469 +40470 +34454 +40471 +40472 +21947 +40473 +40474 +823 +5582 +5085 +2 +4230 +40475 +7053 +30877 +98 +12821 +36761 +31293 +40298 +5773 +7053 +31293 +19 +34433 +40476 +24412 +40477 +40478 +40479 +31293 +1684 +13131 +40480 +1870 +270 +33120 +31718 +33650 +14604 +2043 +26779 +40481 +19 +7908 +40482 +22412 +40483 +822 +36279 +43 +28441 +33490 +21947 +40484 +345 +40485 +16978 +865 +40486 +1991 +40487 +1442 +40488 +40489 +18045 +286 +317 +30877 +40490 +27669 +5075 +11541 +39709 +21796 +40491 +40492 +40493 +24482 +590 +40494 +33138 +2619 +14369 +2593 +29179 +40495 +46 +15 +13874 +7521 +14914 +40496 +40497 +10946 +30081 +354 +40498 +7154 +32 +19 +17093 +27669 +40499 +30209 +5188 +40500 +19 +40501 +40502 +40503 +40504 +1716 +24864 +345 +19 +590 +40505 +40506 +540 +15718 +40507 +1907 +29956 +40508 +1566 +40509 +7095 +40510 +153 +38732 +40511 +29639 +140 +40512 +22990 +40513 +590 +40514 +40515 +40516 +29172 +25316 +32275 +43 +736 +14869 +40517 +14369 +40518 +40519 +40520 +7658 +13390 +40521 +40522 +40523 +36218 +6883 +40524 +28219 +40525 +15 +40526 +40527 +36268 +24896 +14020 +40528 +29483 +40529 +31541 +31168 +43 +21947 +29381 +40530 +5092 +2836 +1508 +24864 +23493 +15595 +26040 +2578 +9 +40531 +46 +40532 +40533 +40534 +12827 +37556 +915 +18982 +36683 +40535 +6123 +40536 +39983 +12479 +16437 +9 +31293 +40537 +40538 +3546 +4634 +89 +21947 +25140 +31041 +20 +40539 +40540 +37920 +40541 +2537 +40542 +40543 +30877 +29483 +33627 +1090 +1870 +1090 +40544 +40545 +31293 +14369 +40546 +4055 +345 +1090 +29483 +18310 +36268 +1385 +40547 +14369 +4634 +2 +4684 +25316 +60 +40548 +19 +20600 +40549 +1090 +40550 +40551 +40552 +4411 +40553 +40554 +40555 +115 +31098 +18394 +9 +40556 +4765 +43 +15476 +4028 +40557 +15451 +40558 +40559 +40560 +34402 +104 +4086 +40561 +5649 +30877 +24864 +1454 +342 +30051 +40562 +11822 +8110 +24144 +14369 +40563 +416 +15718 +29483 +36307 +8171 +9 +40564 +16466 +18695 +155 +155 +40565 +31293 +1013 +40566 +77 +28036 +2243 +20161 +5314 +40567 +40568 +2694 +37556 +15718 +3546 +19 +40569 +1384 +21947 +40570 +89 +30139 +40570 +30877 +15718 +3559 +31293 +533 +6275 +21947 +33061 +43 +40571 +736 +155 +14546 +30224 +536 +11822 +590 +491 +4634 +40572 +40573 +40574 +40575 +2779 +31906 +40576 +40577 +2514 +20 +31293 +4123 +16 +14369 +16375 +15718 +10727 +40578 +15474 +18310 +8249 +40579 +40580 +40581 +40582 +36218 +40583 +40584 +25943 +155 +40585 +40586 +269 +1021 +28549 +39980 +40587 +40588 +40589 +40590 +1517 +40591 +40592 +1090 +179 +17151 +317 +2882 +40593 +37556 +564 +40594 +57 +40595 +40596 +286 +40597 +14604 +40598 +21947 +15718 +22 +40599 +24953 +40600 +40601 +590 +40602 +1612 +40603 +33758 +12987 +14477 +11034 +40604 +4055 +40605 +11964 +1961 +9 +1745 +39927 +40606 +5007 +40607 +11402 +40608 +2577 +402 +14532 +5665 +21947 +14909 +27069 +40609 +9 +8280 +18176 +11315 +40610 +39036 +21947 +40611 +43 +33693 +27669 +37556 +40612 +3061 +36736 +40613 +28549 +40614 +40615 +40616 +40617 +10699 +11906 +40618 +13390 +17749 +40570 +40619 +40620 +31139 +40621 +40622 +1415 +40623 +40624 +14369 +14330 +12800 +40625 +40626 +14666 +19 +40627 +40628 +40629 +17340 +40630 +28036 +4745 +40631 +379 +14330 +2 +2593 +40632 +23401 +286 +115 +35665 +40633 +40634 +40635 +713 +40636 +37556 +19 +40570 +40637 +2158 +26387 +3287 +2260 +40638 +6304 +317 +30224 +15592 +40639 +37411 +566 +40640 +31293 +37556 +6616 +23591 +7830 +6335 +40641 +140 +14330 +11907 +13390 +3343 +7053 +16 +9 +33120 +32449 +21947 +155 +38465 +40642 +32603 +114 +29 +40643 +39998 +32 +8994 +35672 +24303 +40570 +590 +17031 +40644 +770 +317 +5188 +155 +533 +30877 +40645 +872 +40646 +40570 +40647 +40648 +40649 +24129 +40650 +590 +1383 +1072 +40651 +13390 +31225 +40652 +40653 +22537 +345 +7658 +19 +40654 +40655 +14369 +5704 +791 +40570 +2043 +40656 +237 +19 +40657 +17810 +40658 +40659 +40660 +38465 +40570 +40661 +40570 +40662 +25140 +19095 +31293 +1637 +20442 +40663 +14330 +33627 +40664 +40665 +27669 +32041 +13807 +40666 +21947 +28339 +4227 +1090 +1228 +31041 +39709 +21947 +40667 +484 +5791 +1300 +29639 +20442 +4055 +22496 +32253 +40668 +40570 +15096 +1867 +40669 +29204 +19 +40570 +40670 +9 +102 +915 +342 +40671 +14369 +40570 +40672 +31293 +35551 +40673 +232 +3546 +40674 +40675 +9 +12281 +40676 +25683 +13829 +27719 +286 +40677 +377 +354 +15718 +40678 +1513 +4441 +2988 +40679 +9 +491 +1674 +40680 +36683 +8297 +40681 +40570 +590 +40682 +29204 +9210 +40683 +827 +21031 +449 +40684 +21947 +1425 +2721 +28345 +2029 +40685 +5627 +36485 +40686 +10574 +179 +14887 +536 +4544 +2446 +21947 +40570 +2537 +5071 +9 +40687 +40688 +7418 +40689 +155 +915 +416 +40690 +40691 +26496 +40692 +60 +27669 +4634 +4230 +15718 +7553 +31516 +15718 +31364 +3546 +40693 +7904 +6048 +40694 +536 +21031 +39552 +22 +40695 +178 +30877 +21045 +40696 +590 +24421 +38667 +9 +5559 +14225 +33650 +25316 +9 +23103 +40697 +140 +40570 +15718 +4 +18394 +34107 +33120 +170 +40698 +40699 +1090 +60 +43 +22963 +37556 +31293 +19 +40700 +40701 +40702 +29628 +155 +40703 +19 +1090 +25316 +33120 +8668 +30051 +3553 +40704 +15 +15718 +155 +40705 +25316 +4963 +768 +37556 +22898 +29483 +40706 +4055 +40707 +16258 +5188 +9402 +40708 +40570 +40709 +34410 +40710 +586 +15 +19 +43 +43 +14330 +19 +35425 +9 +24303 +1011 +4518 +3406 +40711 +40712 +9 +40570 +40713 +40570 +828 +8244 +35318 +201 +31293 +10946 +12095 +40714 +15 +21031 +3296 +15718 +40715 +40716 +590 +176 +1012 +13390 +24303 +3546 +28316 +32438 +915 +40717 +15 +27069 +19 +19 +40718 +40719 +25237 +1508 +2315 +30224 +40570 +13390 +33650 +1710 +6070 +40720 +590 +13207 +25683 +24200 +40721 +30877 +39746 +31293 +18448 +39709 +20700 +40722 +40723 +43 +40724 +349 +9 +40725 +21947 +1716 +28441 +9 +40726 +155 +1385 +40727 +12397 +40728 +40729 +40730 +40731 +30877 +40732 +40733 +32616 +141 +43 +31098 +1011 +18553 +7208 +7516 +861 +519 +16375 +77 +15718 +2882 +89 +17151 +19 +416 +19 +40734 +15718 +16772 +18951 +40735 +19653 +2680 +15951 +40736 +188 +4055 +39983 +379 +155 +40737 +40738 +25316 +31293 +736 +37556 +3 +6364 +3546 +1047 +40739 +155 +155 +533 +1091 +25 +38117 +2537 +4055 +28317 +9573 +20914 +40740 +40741 +286 +33494 +590 +40570 +872 +40742 +25237 +40743 +37556 +40744 +1604 +21947 +8483 +40745 +16586 +1879 +40746 +15 +25140 +19 +29200 +40747 +725 +25316 +46 +19 +19 +24309 +815 +4055 +189 +36268 +40748 +25315 +40749 +40750 +40751 +28317 +9449 +40752 +40753 +26744 +26779 +1013 +1503 +2318 +1382 +38 +43 +40754 +20162 +39709 +40755 +29483 +40756 +40757 +40758 +12152 +2347 +36442 +29733 +358 +40759 +19 +3546 +21947 +7860 +10583 +15504 +40760 +34433 +40761 +40762 +209 +12832 +809 +14369 +34864 +10946 +155 +40763 +14363 +40764 +43 +1529 +1901 +6468 +14 +10946 +40765 +40766 +15 +24864 +33120 +40143 +9460 +9012 +16 +31293 +40570 +40767 +7379 +671 +14330 +193 +936 +15718 +17911 +40768 +822 +155 +31293 +40769 +32438 +24811 +40770 +40771 +40772 +17385 +40773 +40774 +40775 +5808 +40776 +27669 +31293 +40777 +613 +286 +40778 +20340 +40779 +22141 +40780 +40781 +40570 +40782 +40570 +8813 +10 +33113 +15970 +36268 +1107 +26199 +40783 +15718 +27669 +40784 +43 +15220 +31375 +43 +12434 +155 +28036 +24192 +40785 +1571 +40570 +705 +6732 +14369 +457 +4055 +712 +40570 +155 +40786 +3839 +36638 +3119 +1529 +32 +37476 +8569 +76 +40787 +590 +9 +25943 +958 +7786 +5773 +1604 +7123 +30877 +31293 +37556 +40788 +40789 +21947 +29200 +20757 +736 +40790 +19852 +28441 +40791 +40792 +9 +37556 +34602 +138 +13390 +40793 +40794 +40795 +30877 +40796 +19 +21947 +40797 +40798 +40799 +40800 +40801 +31293 +32 +7564 +40802 +1090 +1382 +29200 +40803 +33445 +14330 +1656 +9894 +40804 +30307 +1508 +40570 +357 +40805 +31852 +7276 +31168 +30877 +40806 +9941 +40807 +14369 +1251 +4055 +14240 +40808 +40570 +16437 +21947 +40809 +21947 +40810 +40811 +7260 +12534 +15384 +2006 +15411 +40812 +3978 +16535 +14369 +40813 +40814 +40815 +19 +18577 +8392 +40816 +19318 +29381 +40817 +970 +30877 +40818 +16437 +16 +40819 +40820 +9 +24303 +31293 +37556 +40570 +43 +40821 +590 +40822 +12800 +9 +40823 +9 +2577 +286 +21796 +31293 +345 +24339 +40824 +40825 +301 +861 +32299 +40570 +40826 +2372 +15718 +5188 +40827 +5629 +155 +40828 +40829 +3976 +40830 +4 +721 +25281 +29 +40417 +1961 +30846 +8967 +1961 +19618 +40591 +40831 +590 +40832 +17 +40833 +40834 +19618 +40835 +40836 +40837 +40838 +40839 +323 +24864 +8846 +17911 +40840 +43 +10662 +40841 +40842 +40843 +21947 +590 +40844 +3351 +40845 +40846 +18811 +35224 +286 +36268 +37920 +317 +5119 +40847 +40848 +19095 +40849 +9934 +4115 +31293 +30877 +14102 +40850 +38944 +40851 +40852 +40853 +40854 +37556 +40855 +18744 +26496 +40856 +43 +40857 +17872 +40858 +7860 +40859 +827 +538 +286 +19 +104 +40860 +595 +155 +89 +155 +40861 +5344 +2540 +25164 +249 +19 +40862 +40863 +35692 +40864 +36483 +352 +2694 +16571 +19 +1272 +40865 +21629 +40866 +40867 +16017 +40868 +9 +40869 +1385 +31293 +155 +1090 +17911 +30877 +25316 +5448 +155 +29639 +17635 +40870 +13390 +40871 +554 +915 +2694 +1710 +40872 +15 +694 +40873 +17385 +31293 +7835 +40874 +3061 +30917 +30877 +14369 +40875 +36858 +40570 +40876 +1090 +33627 +4263 +2561 +1847 +155 +40877 +40878 +15 +40570 +15 +6627 +3601 +19 +40879 +40880 +25871 +40570 +15572 +32896 +165 +40881 +19618 +40882 +2635 +5662 +155 +40883 +40884 +30650 +40885 +2865 +540 +855 +178 +40570 +27669 +40886 +27069 +40887 +1790 +40888 +89 +40889 +40890 +31293 +26744 +19 +1681 +40891 +33061 +30877 +33116 +46 +40892 +872 +9 +40893 +155 +31293 +40894 +40895 +17810 +40896 +14369 +33120 +446 +38465 +892 +8668 +40897 +40898 +197 +27447 +40899 +40900 +28036 +10946 +19 +448 +104 +21657 +40901 +40902 +39563 +40903 +155 +40904 +29483 +25943 +4550 +40339 +40905 +40906 +4075 +2694 +40907 +36928 +40908 +40570 +155 +9 +20514 +1224 +590 +39344 +40909 +40910 +40911 +19618 +40912 +30542 +33469 +28295 +28549 +21027 +35656 +11697 +40913 +40914 +2022 +19 +40915 +53 +40916 +286 +40570 +40917 +15718 +16437 +18473 +5601 +43 +13905 +399 +31995 +13807 +40918 +491 +18300 +2694 +40919 +40920 +9 +40921 +40922 +40923 +12987 +536 +21259 +33627 +20443 +40924 +30051 +17730 +301 +40925 +31225 +13307 +19 +40926 +1536 +27861 +40570 +317 +19 +14369 +820 +2254 +40927 +40928 +40929 +6595 +155 +40930 +40931 +40932 +20560 +736 +1115 +155 +40933 +284 +40934 +40935 +31293 +1907 +2195 +40936 +40937 +337 +40938 +1157 +140 +14001 +8483 +40570 +40939 +40940 +18516 +15718 +22673 +24303 +40941 +31293 +7585 +31293 +40942 +303 +1013 +270 +354 +155 +40943 +27669 +40944 +40945 +40946 +40947 +10841 +40948 +2877 +6505 +2015 +40949 +40950 +284 +40951 +12696 +43 +155 +40952 +40953 +3 +40954 +40955 +40956 +3976 +40957 +8560 +303 +14477 +5700 +14330 +40958 +40959 +15364 +40960 +10847 +40961 +28441 +597 +342 +213 +40962 +1710 +823 +37556 +40963 +6294 +1765 +40964 +201 +40965 +40966 +3601 +9 +40967 +19 +34488 +17 +40968 +14369 +40969 +40970 +40971 +590 +29381 +6095 +40972 +2314 +4414 +37556 +40973 +40974 +1787 +6728 +40975 +822 +10946 +303 +40976 +40977 +40570 +25237 +31293 +19655 +39709 +5399 +40978 +22 +40979 +40980 +33758 +40981 +8297 +5188 +40570 +40982 +40983 +3601 +613 +248 +3171 +25140 +40984 +736 +303 +213 +40985 +103 +6341 +3826 +40986 +736 +19 +23103 +40570 +40987 +40988 +40989 +1082 +40990 +40570 +26452 +12005 +14369 +40991 +9 +40992 +1469 +40993 +40994 +40995 +209 +40996 +40997 +40998 +19 +40570 +6468 +11321 +415 +228 +281 +66 +155 +40999 +17385 +41000 +13474 +39709 +41001 +1090 +6054 +30877 +9988 +33758 +41002 +1090 +41003 +9 +40570 +31873 +21947 +41004 +41005 +41006 +209 +66 +22 +751 +31293 +337 +41007 +2234 +31293 +29483 +41008 +39709 +2372 +30224 +21947 +701 +22963 +57 +345 +25871 +6316 +41009 +33650 +30224 +41010 +41011 +41012 +4317 +345 +21729 +28317 +40570 +34402 +28549 +41013 +21089 +41014 +533 +286 +4055 +41015 +28317 +41016 +41017 +41018 +15 +41019 +41020 +13390 +41021 +2998 +323 +590 +1222 +17151 +3546 +15718 +41022 +554 +41023 +185 +19 +37556 +14477 +137 +41024 +7855 +41025 +1291 +41026 +6054 +958 +21947 +155 +31293 +41027 +31293 +809 +41028 +27669 +225 +140 +8297 +3546 +209 +40570 +41029 +337 +155 +41030 +41031 +3182 +399 +736 +25868 +2471 +9 +41032 +41033 +5188 +249 +41034 +41035 +41036 +41037 +4425 +41038 +24725 +39536 +491 +28629 +8367 +1090 +15718 +14369 +1710 +1013 +10230 +41039 +1867 +5791 +4518 +41040 +41041 +19 +14369 +41042 +26127 +19 +28490 +20442 +24864 +248 +41043 +41044 +41045 +14477 +41046 +36735 +41047 +3546 +16798 +8668 +41048 +2728 +14477 +41049 +40570 +5085 +41050 +41051 +57 +15718 +76 +590 +40570 +904 +40394 +19 +41052 +41053 +38536 +29483 +41054 +41055 +19 +1208 +41056 +41057 +21776 +41058 +40570 +19 +19 +41059 +2686 +41060 +21947 +41061 +590 +19109 +41062 +33627 +1090 +29251 +41063 +41064 +13675 +9 +40570 +155 +41065 +15718 +10946 +8282 +26355 +31168 +24896 +2550 +36483 +1112 +14216 +38003 +12800 +248 +41066 +41067 +41068 +41069 +40570 +41070 +13390 +41071 +43 +3317 +41072 +33650 +15914 +41073 +11522 +40570 +14001 +41074 +15102 +2038 +1090 +30458 +99 +18418 +303 +31293 +41075 +29483 +41076 +5297 +41077 +21947 +590 +41078 +41079 +41080 +694 +6306 +9440 +842 +41081 +33496 +4518 +2830 +31293 +41082 +1047 +2728 +13528 +41083 +41084 +337 +11192 +265 +18569 +284 +31661 +31293 +40570 +32897 +41085 +19 +1090 +33693 +2577 +6006 +4637 +34402 +28317 +39250 +41086 +25382 +41087 +36946 +9 +43 +36268 +213 +15718 +590 +21947 +41088 +669 +1716 +21269 +1090 +648 +248 +112 +15718 +1456 +25316 +17691 +1969 +41089 +104 +18283 +37556 +301 +9 +2064 +1386 +2254 +4502 +40570 +38760 +41090 +10 +41091 +164 +35870 +21131 +41092 +3553 +41093 +30209 +41094 +43 +11 +3417 +39709 +24896 +352 +32856 +40570 +736 +6893 +18631 +19 +31293 +37556 +41095 +7276 +30814 +19 +60 +590 +41096 +41097 +345 +41098 +155 +9 +9 +9 +15 +7658 +41099 +20223 +41100 +8763 +1234 +41101 +29483 +41102 +20413 +213 +12067 +41103 +13143 +2833 +28237 +41104 +41105 +6341 +9713 +6287 +1961 +265 +13390 +41106 +40570 +9 +41107 +32087 +89 +41108 +770 +590 +41109 +41110 +41111 +8772 +77 +41112 +31293 +4463 +41113 +16772 +23103 +31293 +28490 +41114 +38760 +28035 +43 +21669 +8961 +33650 +213 +41115 +213 +41116 +19 +36076 +5410 +13390 +41117 +14369 +15718 +155 +20280 +590 +37556 +41118 +8668 +41119 +14330 +39709 +37556 +41120 +41121 +25584 +40570 +41122 +4055 +495 +41123 +32 +28490 +24864 +41124 +11824 +412 +41125 +33141 +89 +41126 +38687 +33650 +25859 +13721 +41127 +137 +41128 +37556 +33650 +1870 +16826 +2410 +41129 +2314 +24725 +41130 +9 +590 +2917 +43 +17687 +41131 +41132 +9 +41133 +1615 +31293 +1208 +21027 +21947 +137 +7516 +40570 +284 +213 +337 +41134 +41135 +41136 +337 +1716 +41137 +20445 +31293 +19 +33627 +40570 +1514 +21947 +30877 +17602 +301 +491 +41138 +13045 +32871 +17382 +201 +3601 +41139 +31575 +41140 +41141 +30877 +40570 +13721 +303 +20774 +41142 +29483 +21262 +26416 +39709 +32871 +248 +31249 +284 +41143 +41144 +9 +9 +41145 +3546 +19405 +16437 +41146 +43 +41147 +4055 +286 +590 +4116 +15718 +140 +16437 +41148 +1823 +337 +41149 +41150 +34752 +41151 +41152 +337 +213 +1228 +41153 +41154 +9 +40029 +41155 +21729 +41156 +29153 +613 +40472 +41157 +1090 +213 +248 +15655 +5025 +915 +41158 +7516 +36268 +123 +41159 +9 +40570 +15498 +41160 +14330 +31293 +284 +41161 +9 +41162 +41163 +20555 +10946 +41164 +10946 +41165 +38595 +9 +38760 +9 +31703 +15718 +12987 +20 +41166 +17042 +14534 +15718 +22337 +18258 +3790 +590 +31098 +40483 +31383 +38465 +31189 +41167 +40570 +568 +9 +41168 +19 +37556 +6518 +1090 +11801 +41169 +41170 +671 +41171 +41172 +41173 +41174 +112 +41175 +14330 +37556 +10601 +8210 +18145 +36452 +20 +19 +19 +41176 +1531 +37211 +40570 +33278 +1330 +29483 +1224 +41177 +1529 +155 +248 +40570 +27669 +41178 +15718 +38421 +41179 +3030 +14330 +41180 +5415 +37556 +228 +155 +15718 +1766 +41181 +15718 +27619 +29381 +37920 +41182 +30580 +1010 +46 +19 +176 +213 +37556 +40712 +155 +17144 +30877 +8717 +2 +23322 +5204 +40570 +27178 +4055 +31293 +11087 +1186 +8297 +25316 +41183 +25237 +9410 +19095 +1047 +19 +43 +40570 +411 +33863 +41184 +41185 +24864 +17151 +33624 +317 +41186 +41187 +19 +41188 +30877 +9 +27954 +29483 +41189 +77 +5071 +16466 +40570 +41190 +33627 +5409 +29381 +533 +16798 +41191 +41192 +41193 +286 +43 +40570 +43 +30291 +41194 +41195 +39709 +14369 +20 +416 +2410 +31293 +3597 +8210 +317 +57 +30650 +1502 +36268 +155 +40570 +26022 +27669 +24725 +24864 +40570 +37556 +41196 +11010 +1716 +28745 +33650 +24303 +36268 +15718 +17144 +13390 +41197 +155 +6950 +24045 +303 +41198 +41199 +141 +2410 +1870 +1090 +41200 +665 +164 +15718 +2121 +41201 +5080 +16539 +33650 +40570 +41202 +10659 +4026 +1090 +31293 +12800 +36735 +34402 +33061 +41203 +41204 +24300 +41205 +2476 +3978 +345 +41206 +30224 +8668 +7516 +21689 +11620 +14477 +41207 +533 +41208 +2764 +41209 +155 +41210 +41211 +27669 +4627 +14477 +41212 +41213 +35883 +8670 +10356 +39709 +3100 +41214 +31603 +24864 +5169 +31293 +14693 +21947 +30877 +9 +14477 +41215 +21947 +41216 +41217 +736 +554 +32 +41218 +41219 +41220 +41221 +209 +15718 +41222 +40591 +32022 +41223 +1090 +9 +6468 +40570 +26043 +19 +19 +18310 +41224 +33627 +21791 +36268 +19 +19 +284 +23150 +590 +2061 +37556 +40570 +25 +1157 +43 +12788 +1244 +41225 +21791 +36492 +345 +26040 +1559 +41226 +41227 +41228 +142 +440 +41229 +41230 +33445 +21791 +41231 +3732 +31293 +41232 +27669 +398 +33120 +3546 +21968 +41233 +17872 +893 +176 +38760 +590 +6038 +41234 +7324 +41235 +37556 +31293 +14017 +13721 +29172 +41236 +10946 +30224 +41237 +21089 +89 +2493 +19792 +40591 +5577 +349 +41238 +41239 +41240 +41241 +34 +9410 +1295 +31995 +6496 +41242 +41243 +41244 +31293 +1795 +31293 +33758 +37556 +31293 +21698 +12404 +15645 +43 +19 +41245 +25164 +36268 +41246 +5085 +2591 +5188 +41247 +9 +41248 +155 +41249 +38760 +155 +17937 +22 +41250 +32 +38893 +41251 +2 +41252 +15 +42 +17872 +57 +3958 +36268 +9 +41253 +989 +41254 +1090 +41255 +303 +791 +41256 +18045 +4722 +22468 +12582 +2577 +41257 +17911 +25316 +41258 +15718 +41259 +40570 +41260 +12959 +8668 +34242 +3553 +185 +887 +24324 +41261 +155 +41262 +37556 +822 +40570 +41263 +40591 +41264 +5065 +5130 +40861 +43 +41265 +13390 +3375 +41266 +19 +41267 +41268 +24303 +413 +9558 +41269 +25237 +1107 +11026 +3814 +40570 +29483 +1090 +40570 +2264 +20247 +1051 +19109 +201 +21947 +41270 +23103 +41271 +21947 +29381 +41272 +9 +40570 +7053 +39 +28317 +15718 +41273 +7852 +28490 +43 +671 +41274 +29200 +41275 +41276 +41277 +19 +41278 +115 +41279 +33330 +34402 +30650 +40570 +41280 +14510 +155 +478 +2410 +41281 +41282 +41283 +478 +1169 +24864 +345 +18233 +31995 +1224 +46 +41284 +41285 +40570 +1224 +31293 +32410 +41286 +43 +41287 +41288 +43 +41289 +41290 +5071 +25140 +19 +46 +41291 +41292 +17151 +30551 +2136 +13390 +1374 +39 +29620 +6038 +41293 +16258 +13390 +37556 +41294 +41295 +26027 +41296 +19 +41297 +9 +41298 +31691 +41299 +16640 +17174 +15148 +1513 +41300 +21947 +43 +43 +3008 +41301 +179 +41302 +41303 +41304 +209 +19 +323 +40591 +201 +14330 +4053 +19852 +37556 +33818 +21947 +3546 +41305 +41306 +41307 +41308 +5188 +7419 +33038 +32 +14330 +41309 +21947 +41310 +41311 +15 +41312 +41313 +10846 +27522 +27117 +41314 +6115 +25316 +1090 +14330 +41315 +40570 +15797 +6499 +41316 +6935 +6571 +19 +1870 +41317 +41318 +6011 +19 +37202 +36218 +41319 +27669 +1688 +14102 +1863 +41320 +41321 +1251 +38760 +15718 +41322 +30877 +21947 +17508 +57 +165 +155 +16790 +736 +1912 +31873 +614 +41323 +9 +29628 +4028 +14001 +205 +29434 +41324 +1763 +38315 +1013 +40570 +18956 +4441 +41325 +4151 +21947 +20161 +155 +41326 +26361 +1116 +41327 +989 +15810 +10 +30877 +41328 +8424 +19 +9 +345 +15 +41329 +18208 +14369 +39709 +17151 +33650 +541 +2356 +2446 +36683 +22552 +41330 +14001 +2060 +411 +41331 +23150 +32449 +33061 +20785 +1244 +41332 +41333 +41334 +41335 +41336 +41337 +1208 +41338 +41339 +862 +41340 +201 +41341 +915 +19 +18045 +12987 +29381 +31293 +41342 +37556 +7014 +26470 +33120 +41343 +155 +41344 +41345 +3546 +958 +1018 +2121 +10418 +155 +41346 +43 +1529 +41347 +66 +155 +33650 +41348 +41349 +29483 +30794 +8304 +18045 +8845 +514 +25316 +25996 +345 +25528 +40570 +41350 +17911 +31293 +41351 +41352 +33123 +41353 +14962 +19 +10265 +21269 +41354 +10482 +41355 +43 +41356 +3601 +41357 +40570 +41358 +1154 +41359 +5204 +24303 +36054 +18683 +29981 +6441 +41360 +1870 +13721 +13290 +33693 +648 +41361 +33786 +11158 +41362 +9 +24862 +15 +41363 +14477 +37556 +41364 +31293 +583 +23727 +41365 +13390 +16375 +1956 +1090 +41366 +10 +7835 +41367 +31293 +823 +30877 +34283 +41368 +33141 +2287 +2828 +41369 +3067 +13390 +41370 +155 +31293 +41371 +41372 +872 +790 +41373 +4055 +15541 +41374 +41375 +5438 +40570 +41376 +4808 +29815 +1716 +377 +28961 +416 +41377 +41378 +33627 +155 +1520 +21689 +30051 +35339 +349 +10727 +19618 +4053 +29483 +1307 +41379 +2764 +36736 +1502 +155 +495 +41380 +23226 +41381 +41382 +5075 +41383 +22355 +37556 +41384 +41385 +41386 +41387 +41388 +1444 +7835 +15718 +27669 +41389 +3981 +41390 +41391 +41392 +155 +24725 +41393 +21947 +4028 +41394 +155 +7183 +25316 +41395 +41396 +590 +43 +6341 +41397 +5627 +32275 +1090 +41398 +25 +21947 +41399 +40570 +15718 +17911 +30224 +2260 +41400 +5326 +6284 +15718 +15 +31293 +41401 +341 +14369 +30877 +41402 +41403 +41404 +37556 +123 +29483 +17356 +9 +41405 +31422 +41406 +1812 +41407 +595 +2015 +25316 +178 +37556 +554 +4055 +14369 +415 +349 +17982 +861 +41408 +15718 +9 +14604 +41409 +20941 +33650 +30877 +41410 +1224 +37573 +41411 +41412 +40570 +40570 +37556 +30877 +14 +41413 +29200 +720 +33120 +13390 +20329 +19 +41414 +5659 +590 +14330 +41415 +40570 +1536 +19 +2101 +1172 +12800 +345 +270 +41416 +21947 +4028 +41417 +2043 +8188 +14330 +936 +9 +18683 +13390 +17277 +15914 +41418 +590 +41419 +28194 +33436 +7521 +33627 +2197 +1364 +41420 +6728 +41421 +40877 +43 +1160 +15768 +823 +31293 +1668 +41422 +41423 +40570 +707 +24811 +31293 +352 +286 +6341 +7413 +29483 +849 +41424 +554 +41425 +36735 +41426 +20 +19 +9410 +41427 +32386 +41428 +41429 +3598 +25237 +19 +15342 +36268 +41430 +1992 +41431 +5629 +19 +17911 +14000 +41432 +41433 +41434 +41435 +5790 +34517 +345 +41436 +40570 +41437 +43 +915 +3546 +33438 +19 +41438 +19618 +41439 +41440 +2121 +176 +17911 +13390 +40570 +9 +250 +41441 +37990 +41442 +40570 +590 +40570 +2859 +345 +39783 +6627 +41443 +41444 +41445 +643 +201 +27669 +29716 +2694 +43 +41446 +495 +21947 +12479 +43 +18045 +1765 +1228 +41447 +21027 +176 +1870 +1578 +41448 +286 +41449 +29483 +37556 +21947 +137 +514 +13740 +19406 +1905 +43 +842 +41450 +41451 +464 +169 +19 +29483 +397 +41452 +40570 +8772 +10115 +1082 +31293 +5908 +7835 +41117 +37556 +8545 +35788 +3950 +41453 +41454 +41455 +41456 +33693 +28036 +41457 +34165 +41458 +41459 +20700 +41460 +40591 +41461 +41462 +272 +41463 +14660 +21776 +14477 +41464 +41465 +15718 +14330 +41466 +41467 +41468 +41469 +2410 +671 +1051 +41470 +41471 +38275 +416 +41472 +41473 +41474 +41475 +32410 +412 +41476 +11763 +4821 +41477 +25140 +34710 +30051 +31293 +665 +554 +41478 +284 +4293 +43 +29483 +240 +37556 +1765 +41479 +1710 +25316 +41480 +41481 +16437 +41482 +57 +10642 +19634 +41483 +33508 +41484 +37556 +34752 +40570 +1920 +1513 +370 +21947 +115 +41485 +30877 +41486 +41487 +41488 +41489 +89 +4055 +24303 +41490 +40570 +14330 +24864 +37139 +1987 +4461 +41491 +40570 +15 +31019 +41492 +46 +317 +249 +14369 +41493 +41494 +26361 +41495 +10028 +41496 +38374 +14369 +377 +8297 +13905 +5252 +19168 +22507 +14363 +286 +21947 +41497 +11176 +23150 +37556 +41498 +10984 +4824 +24303 +41499 +41500 +41501 +19 +10946 +41502 +41503 +41504 +41505 +12976 +41506 +41507 +11459 +9 +278 +41508 +19 +41509 +40570 +115 +41510 +24725 +1559 +13390 +39593 +41511 +40570 +1090 +19618 +41512 +41513 +155 +317 +1045 +41514 +6571 +9 +590 +41515 +8946 +4631 +41516 +28208 +28755 +77 +27719 +31639 +21947 +36282 +32 +41517 +6294 +40570 +41518 +15718 +40570 +6086 +28317 +3546 +14369 +6214 +590 +5629 +4518 +41519 +14477 +1090 +14477 +25943 +41520 +15439 +26361 +1131 +31293 +41521 +8392 +11754 +41522 +8053 +37556 +6038 +10946 +35107 +1765 +41523 +9 +96 +2859 +286 +26496 +5085 +41524 +827 +7053 +27669 +14 +41525 +19655 +41526 +178 +1369 +11362 +13528 +1300 +41527 +9 +28935 +7697 +30224 +3964 +6015 +34402 +41528 +24144 +21947 +6010 +1090 +41529 +12995 +286 +41530 +41531 +5071 +2649 +8188 +41532 +41533 +12479 +41534 +38760 +1978 +6499 +30051 +2038 +41535 +29483 +38760 +43 +41536 +22901 +41537 +41538 +14369 +31293 +41539 +33128 +36735 +11321 +33650 +16466 +41540 +41541 +13207 +39709 +41542 +2561 +613 +40570 +189 +41543 +41544 +34804 +41545 +2308 +67 +40570 +32332 +23303 +40570 +41546 +29483 +31293 +188 +37556 +4364 +25402 +41547 +32563 +36054 +21947 +4502 +17901 +19618 +36253 +21947 +5923 +4461 +24864 +29275 +41548 +491 +1090 +6869 +9 +35784 +910 +572 +665 +41549 +5085 +1090 +41550 +41551 +41552 +33627 +155 +1425 +32 +41553 +41554 +590 +2577 +41555 +26277 +19 +1604 +40570 +29200 +41556 +201 +28845 +11428 +41557 +41558 +25237 +40570 +36 +36268 +38760 +19318 +9 +2537 +29032 +9 +41559 +1374 +598 +770 +41560 +41561 +41562 +43 +28845 +41563 +2577 +7835 +33650 +41564 +16102 +155 +30051 +971 +41565 +35120 +41566 +415 +14369 +9 +16124 +40570 +13765 +14477 +25683 +38760 +41567 +165 +41568 +13390 +14527 +119 +41569 +5650 +24154 +4364 +41570 +4677 +9 +115 +41571 +19 +832 +4461 +677 +40472 +790 +31293 +22 +2841 +1606 +19 +29204 +209 +41572 +25237 +28845 +41573 +155 +23343 +29244 +30650 +2064 +19 +1875 +12722 +32 +41574 +41575 +27669 +28845 +415 +849 +14330 +958 +1991 +34650 +3330 +5803 +155 +12987 +25237 +41576 +41577 +41578 +41579 +24864 +8351 +15718 +30051 +41580 +39536 +411 +2610 +3553 +18896 +28672 +41581 +24144 +41582 +40570 +27669 +41583 +41584 +1090 +30056 +209 +36268 +21713 +41585 +41586 +18077 +28295 +4760 +7835 +34160 +27615 +20700 +41587 +18815 +41588 +41589 +1364 +4124 +41590 +10 +13721 +41591 +5204 +9 +99 +786 +41592 +5085 +41593 +41594 +31293 +41595 +25140 +41596 +9 +4055 +41597 +41598 +4388 +29967 +17151 +33758 +14420 +40570 +34351 +10 +15 +40570 +41599 +40570 +41600 +2811 +40570 +17345 +41601 +104 +28317 +5791 +317 +40570 +41602 +15718 +41603 +39211 +31257 +713 +28317 +41604 +41605 +196 +33650 +2308 +38653 +21669 +4075 +38465 +15471 +41606 +28036 +26158 +32538 +41607 +41608 +32885 +9543 +495 +29951 +41609 +41610 +8367 +41611 +1018 +41612 +21947 +2314 +41613 +155 +41614 +32 +41615 +155 +41616 +41617 +37411 +36736 +3480 +41618 +37556 +19 +41619 +19 +29483 +7253 +25943 +34047 +41620 +13959 +79 +41621 +16178 +22735 +3842 +2700 +20339 +19618 +41622 +41623 +31824 +41624 +41625 +30551 +24460 +40570 +26142 +19 +377 +9913 +4821 +37556 +41626 +1224 +14369 +41627 +28845 +3509 +15718 +13390 +15989 +41628 +19618 +736 +41629 +41630 +17281 +2832 +30051 +41631 +7516 +13943 +2764 +41632 +1517 +28845 +3842 +31293 +41633 +41634 +41635 +41636 +41637 +41638 +17385 +1562 +41639 +41640 +41641 +19 +20518 +41642 +31603 +28845 +16371 +43 +13578 +41643 +41644 +41645 +24666 +14369 +41646 +13390 +41647 +14369 +5737 +19 +2560 +30191 +10470 +41648 +41649 +26724 +43 +41650 +32019 +40570 +20974 +9 +41651 +41652 +28251 +39111 +38465 +41653 +6595 +30051 +77 +41654 +28317 +1502 +37588 +30589 +40176 +41655 +41656 +41657 +3964 +21947 +41658 +155 +590 +1860 +40570 +43 +41659 +41660 +155 +41661 +43 +17698 +25316 +41662 +586 +2694 +41663 +29483 +40570 +3417 +41664 +1090 +41665 +41666 +32455 +27669 +41667 +24864 +19 +41668 +1688 +16443 +179 +41669 +41670 +12987 +21947 +379 +179 +7977 +2 +41671 +40570 +11702 +484 +2314 +1090 +16102 +5085 +34408 +41672 +41673 +25943 +12907 +33627 +41674 +5803 +41675 +40911 +9 +590 +30051 +4055 +16443 +28845 +286 +21030 +2577 +1863 +41676 +41677 +9400 +41678 +41679 +41680 +8338 +41681 +1172 +19 +41682 +590 +25943 +41683 +15718 +31293 +21947 +31293 +30877 +7835 +590 +2314 +736 +27954 +38419 +16826 +2040 +155 +6928 +415 +155 +37476 +5085 +745 +37808 +25316 +6261 +34402 +1536 +9 +32 +41684 +40570 +13801 +29483 +13283 +4028 +41685 +22815 +3528 +41686 +5075 +30224 +41687 +13390 +9 +40841 +5908 +41688 +155 +27669 +32275 +41689 +43 +40570 +41690 +41691 +41692 +41693 +31293 +828 +31293 +15718 +284 +40570 +317 +41694 +36594 +35497 +37556 +3546 +21947 +38667 +18045 +7658 +26641 +41695 +41696 +7835 +41681 +41697 +41698 +41699 +41700 +7835 +209 +19494 +2254 +19 +31293 +40570 +303 +41701 +16437 +41702 +2971 +6305 +303 +1870 +19 +17670 +41703 +28845 +4803 +40570 +9548 +41704 +43 +29483 +41705 +31293 +43 +491 +37808 +13848 +41706 +9 +248 +38033 +41707 +484 +41708 +41709 +41710 +20700 +41711 +33120 +15718 +40570 +41712 +41713 +337 +41714 +2061 +6952 +16437 +29597 +345 +57 +30974 +41715 +40570 +4 +41716 +9 +1100 +41717 +41718 +41719 +41720 +790 +736 +41721 +41722 +41723 +23487 +9 +4001 +40226 +590 +33709 +41724 +41725 +4055 +1262 +40570 +14604 +23277 +41726 +7379 +41727 +25 +41728 +41729 +915 +32953 +25237 +3546 +41687 +41730 +1765 +41731 +41732 +35613 +2040 +41733 +41734 +250 +4028 +915 +41735 +41736 +1090 +352 +99 +33758 +40067 +22587 +33627 +41737 +41738 +41739 +41740 +8994 +31225 +37556 +41741 +7835 +14477 +15514 +21947 +19 +590 +41742 +2117 +19618 +15906 +19 +41743 +41744 +41745 +4761 +349 +41746 +484 +41747 +17386 +873 +2733 +41748 +14947 +29956 +533 +165 +16102 +41749 +415 +41750 +20 +41751 +41752 +41753 +29628 +15718 +41754 +43 +16798 +6612 +20 +41755 +36686 +6935 +1223 +28929 +11601 +3994 +41756 +5601 +37556 +495 +41757 +12869 +41758 +1112 +1444 +645 +12013 +41759 +41760 +41761 +20442 +41762 +13721 +40570 +41763 +21276 +25129 +303 +41764 +41765 +38760 +41766 +8367 +613 +817 +33726 +43 +24332 +40570 +41767 +1011 +21398 +41695 +40570 +33627 +33758 +19792 +41768 +7123 +41769 +41770 +41771 +5409 +21941 +41772 +41773 +28194 +30051 +41774 +22 +41775 +43 +40570 +765 +1018 +590 +284 +349 +41776 +21669 +41777 +213 +19 +41778 +2029 +4364 +41779 +41780 +14448 +41781 +41782 +41783 +41784 +41785 +24896 +179 +286 +313 +41786 +30650 +6744 +1870 +41787 +41788 +1536 +29591 +12055 +13570 +31041 +24045 +41789 +40570 +41790 +337 +16413 +41791 +38944 +41792 +24864 +41793 +38760 +8110 +34936 +41794 +41795 +19 +437 +37556 +43 +1262 +14330 +155 +15718 +19057 +41796 +616 +31293 +1481 +41797 +11966 +41798 +41799 +412 +18919 +713 +11940 +17412 +16140 +4502 +19237 +323 +4441 +41800 +225 +41801 +3330 +3353 +31073 +41802 +155 +827 +14477 +25237 +8668 +41803 +41804 +533 +41805 +33650 +19618 +8668 +29007 +41806 +282 +41807 +19618 +41808 +18242 +39346 +24864 +40570 +707 +377 +41809 +533 +21947 +1961 +872 +284 +1090 +201 +41810 +41811 +41812 +590 +41813 +15942 +41814 +41815 +41816 +19 +41817 +21947 +41818 +32909 +41819 +41820 +5409 +5916 +31293 +713 +4055 +28845 +34402 +9 +41821 +41822 +1812 +36735 +21947 +41823 +37556 +31293 +32150 +30917 +28845 +29204 +41824 +1090 +13131 +41825 +33141 +155 +23103 +77 +41826 +40570 +37920 +35316 +37556 +41827 +41828 +41829 +24896 +27669 +269 +41830 +736 +155 +40570 +14369 +6275 +34402 +927 +41831 +41832 +41833 +5650 +41834 +28317 +41835 +29483 +40570 +41836 +15320 +4855 +910 +41837 +286 +41838 +2187 +41839 +41840 +28234 +989 +41841 +10736 +41842 +6171 +179 +14330 +13693 +590 +590 +15183 +24045 +41843 +155 +590 +9 +41844 +40570 +27900 +41845 +41846 +18695 +20616 +9925 +8611 +19 +9 +31873 +12987 +1157 +41847 +29483 +41687 +41848 +41849 +41850 +29628 +20 +597 +25 +41851 +15718 +41852 +259 +1090 +21373 +25129 +25 +1749 +41853 +2043 +16413 +24207 +176 +13943 +1310 +16687 +3790 +41854 +2694 +31293 +41855 +24862 +590 +41856 +14369 +1090 +41857 +41858 +41859 +31896 +25241 +15 +41860 +14330 +1208 +590 +19618 +936 +41861 +2944 +26209 +2314 +41862 +41863 +2770 +41864 +2 +1542 +2253 +41865 +31225 +6384 +155 +2694 +13390 +12987 +31225 +284 +37154 +43 +201 +31773 +284 +5780 +3838 +31168 +590 +41866 +41867 +101 +16102 +41868 +40570 +28317 +41869 +41870 +37808 +28923 +41871 +41872 +41873 +41874 +57 +155 +41875 +41876 +248 +41877 +31691 +43 +41878 +12005 +17385 +21669 +41879 +60 +14369 +41880 +31293 +41881 +41882 +18024 +41883 +1764 +15 +41884 +12532 +590 +28317 +41885 +2561 +114 +41886 +19 +9210 +40570 +40570 +27669 +40570 +28490 +28036 +43 +301 +34650 +248 +345 +41887 +32 +16618 +41888 +13039 +41622 +337 +32 +41889 +41890 +284 +694 +22098 +3100 +590 +416 +41891 +13848 +337 +6210 +4820 +284 +41892 +34681 +41893 +29381 +590 +4028 +41894 +249 +286 +33278 +41895 +17083 +31168 +8508 +284 +41896 +41897 +39709 +40570 +13390 +1965 +8864 +41898 +15763 +17228 +4028 +686 +41899 +25140 +41900 +13721 +41901 +17338 +14203 +41902 +15 +3841 +15 +43 +2 +354 +46 +41903 +248 +41904 +590 +514 +33120 +41905 +14 +32 +337 +272 +22 +19 +41906 +41907 +1817 +249 +41908 +41909 +213 +1745 +3330 +41910 +10720 +41911 +41912 +15718 +12916 +1524 +41913 +3 +303 +6341 +41914 +53 +41915 +27719 +8297 +248 +41916 +1513 +41917 +17228 +30224 +248 +590 +1112 +41918 +13905 +16 +41919 +40570 +1090 +28845 +25140 +41695 +41920 +705 +1134 +2593 +21689 +209 +41921 +30224 +16524 +41922 +41923 +872 +14369 +14369 +41924 +15993 +26892 +14604 +19 +41925 +41926 +41927 +3480 +21669 +41928 +41929 +21669 +16437 +25237 +17635 +270 +140 +41930 +41931 +41932 +37881 +41933 +8156 +21947 +34681 +40570 +36932 +13377 +8668 +17911 +201 +5204 +3553 +41595 +41934 +6354 +10355 +13582 +41935 +77 +41936 +41937 +21669 +970 +41938 +31225 +377 +1681 +2410 +40570 +41939 +41940 +41941 +31293 +38465 +41942 +41943 +228 +5438 +41944 +5188 +5409 +663 +41945 +9 +41946 +9 +21200 +41947 +12555 +9 +5780 +25943 +15718 +38760 +41948 +31293 +2834 +77 +41949 +15718 +41950 +29483 +26229 +41951 +5343 +21031 +41952 +41953 +21576 +34944 +41954 +41955 +31293 +16258 +12807 +16375 +30224 +41956 +41957 +19 +7137 +339 +41958 +9 +4179 +36735 +10677 +1369 +178 +21947 +41959 +41960 +41961 +41962 +322 +1090 +248 +40570 +415 +28317 +484 +41963 +41964 +17920 +20 +155 +36483 +41965 +377 +41966 +213 +31168 +41967 +4055 +270 +29639 +4055 +41968 +2388 +24225 +540 +424 +10946 +8036 +14369 +41969 +41970 +33650 +590 +41971 +41972 +19304 +41973 +41974 +140 +17972 +2064 +18128 +33061 +16466 +155 +28845 +41975 +21947 +41976 +31293 +34 +41977 +41978 +40570 +213 +29628 +37556 +41979 +41980 +31293 +1987 +23495 +41981 +41982 +17151 +41983 +2694 +3743 +155 +15 +41984 +21947 +13390 +21947 +41985 +40658 +155 +41986 +5318 +41987 +29483 +41988 +20514 +21947 +40570 +12828 +41989 +3978 +40589 +1765 +38760 +123 +155 +31356 +21947 +19 +43 +41990 +41991 +19 +24683 +1051 +41181 +31873 +2476 +41992 +31293 +30051 +41993 +28845 +36268 +6430 +41994 +41995 +590 +15018 +41996 +40570 +5780 +36212 +41997 +41998 +7743 +19 +9 +29483 +2787 +41999 +42000 +18780 +15476 +42001 +30051 +28845 +40570 +46 +10505 +37556 +892 +19655 +18503 +19 +42002 +26666 +42003 +40893 +1090 +942 +42004 +42005 +24144 +42006 +42007 +337 +15 +42008 +28845 +40570 +19 +155 +42009 +284 +42010 +10274 +42011 +31139 +28845 +42012 +12299 +2274 +2356 +42013 +77 +42014 +19655 +42015 +32402 +9 +42016 +31293 +2015 +2260 +286 +9 +2537 +2427 +26835 +42017 +42018 +590 +42019 +12050 +25316 +370 +70 +14369 +42020 +42021 +176 +42022 +20 +25 +37411 +14666 +15511 +9 +21947 +29850 +651 +40570 +42023 +22 +42024 +141 +57 +1090 +43 +42025 +20700 +42026 +8668 +42027 +34602 +42028 +590 +11321 +827 +155 +24021 +40570 +31293 +42029 +42030 +42031 +42032 +19 +19956 +286 +42033 +42034 +42035 +28490 +42036 +590 +42037 +42038 +24144 +28036 +736 +2029 +40570 +4502 +42039 +42040 +725 +42041 +42042 +27069 +15718 +42043 +15718 +13566 +30051 +40570 +42044 +29483 +42045 +269 +42046 +42047 +42048 +692 +16527 +14502 +42049 +42050 +11925 +1470 +42051 +1870 +27719 +28845 +345 +42 +42052 +16798 +6171 +10960 +42053 +37556 +22 +33729 +27884 +42054 +24864 +6121 +40067 +42055 +42056 +29483 +140 +590 +18707 +38760 +15384 +21947 +42057 +3867 +3866 +41919 +3353 +42058 +9954 +155 +19 +4502 +21947 +42059 +42060 +41695 +42061 +40570 +42062 +42063 +42064 +519 +21947 +42065 +42066 +42067 +42068 +2341 +42069 +29483 +21689 +42070 +872 +42071 +201 +37168 +33914 +42072 +4155 +35967 +41664 +398 +42073 +19 +2005 +4855 +42074 +42075 +8297 +3406 +42076 +42077 +42078 +98 +554 +9389 +18314 +18999 +301 +1991 +15353 +30877 +42079 +33560 +24727 +30877 +42080 +42081 +40570 +42082 +9934 +14909 +831 +33141 +349 +37556 +7053 +39536 +42083 +42084 +42085 +36735 +17911 +28845 +42086 +42087 +28845 +42088 +554 +20161 +5990 +42089 +155 +39489 +27669 +333 +31234 +42090 +42091 +8053 +1310 +2593 +42092 +11312 +1082 +42093 +31293 +36478 +11482 +29483 +42094 +4116 +42095 +42096 +9 +4422 +736 +20340 +24896 +960 +39865 +31270 +33627 +2577 +42097 +1870 +29926 +42098 +3976 +7717 +2728 +42099 +377 +19160 +42100 +42101 +42102 +481 +1090 +471 +165 +5316 +42103 +34181 +42104 +25237 +4055 +21947 +7923 +6877 +42105 +25030 +822 +4 +6660 +27669 +4982 +42106 +42107 +17828 +42108 +42109 +14625 +15683 +18364 +40570 +590 +9 +21669 +42110 +42111 +349 +31293 +12987 +24140 +42112 +28845 +41234 +2040 +42113 +4055 +15 +40143 +20384 +39709 +4155 +21669 +36452 +27069 +13049 +42114 +25237 +37556 +42115 +42116 +15 +31293 +42117 +165 +3038 +42118 +18045 +37556 +42119 +33627 +5409 +12013 +19684 +1090 +4055 +8297 +27669 +41919 +42120 +16019 +42121 +38893 +39709 +15 +29483 +4463 +42122 +42123 +15539 +29483 +20 +2649 +42124 +42125 +1621 +2064 +42126 +27117 +10 +398 +42127 +42128 +42129 +42130 +29483 +155 +42131 +1688 +590 +17 +41919 +42132 +42133 +286 +42134 +2410 +1385 +8297 +5188 +42135 +5188 +4020 +19618 +5627 +7516 +31293 +2465 +42136 +19618 +1912 +9 +9 +31041 +42137 +694 +27843 +42138 +41695 +42139 +40696 +42140 +42141 +42142 +1870 +42143 +42144 +8668 +5627 +590 +42145 +42146 +57 +33650 +966 +42147 +286 +7790 +2 +15 +42148 +26096 +21669 +23103 +28480 +19 +10367 +28845 +24144 +29730 +7835 +42149 +42150 +33226 +42151 +42152 +29483 +14369 +42153 +42154 +42155 +24864 +41396 +42156 +2181 +42157 +7835 +30224 +42158 +42159 +42160 +5409 +11374 +16466 +11660 +19 +24725 +15398 +345 +1273 +35104 +41919 +42161 +42162 +1251 +42163 +42164 +8701 +42165 +42166 +77 +916 +42167 +9144 +42168 +42169 +42170 +42171 +27669 +9 +23931 +2202 +40570 +32401 +42172 +42173 +349 +14520 +42174 +2349 +42175 +4055 +155 +31293 +42176 +5071 +42177 +42178 +9 +89 +1927 +41695 +42179 +26559 +8593 +2410 +12871 +42180 +32 +317 +4531 +14590 +17772 +42181 +43 +42182 +2988 +41881 +662 +42183 +4461 +41567 +41043 +9095 +22270 +42184 +21669 +1808 +301 +42185 +5806 +42186 +872 +42187 +3743 +590 +42188 +15 +42189 +42190 +3072 +42191 +42192 +7253 +8668 +19 +1817 +42193 +42194 +8994 +42195 +3601 +1082 +6260 +9095 +32871 +40570 +19 +42196 +15824 +22 +42197 +42198 +42199 +41919 +21669 +6928 +42200 +7838 +40208 +41904 +42201 +42202 +3104 +19 +98 +28036 +16437 +990 +7987 +1011 +42203 +16865 +155 +713 +42204 +42205 +28696 +15 +24321 +36735 +5119 +41684 +42206 +42207 +31995 +155 +42208 +19 +42209 +849 +5318 +42210 +19 +42211 +43 +42212 +40570 +32965 +37556 +57 +6463 +42064 +590 +40570 +140 +23322 +34602 +32 +29483 +43 +277 +590 +8198 +3999 +36 +42213 +25387 +31293 +23103 +41919 +40570 +36268 +42214 +31326 +42215 +42216 +15 +155 +29483 +338 +42217 +42218 +3030 +21669 +18314 +590 +42219 +590 +1090 +28845 +22898 +178 +536 +42220 +42221 +40570 +42222 +21669 +2043 +42223 +14363 +42224 +42225 +1090 +43 +573 +38893 +42226 +42227 +1716 +286 +1688 +19 +42228 +42229 +34944 +30551 +42230 +28845 +8849 +26081 +8483 +179 +491 +41687 +1896 +42231 +28845 +9 +42232 +35153 +155 +1157 +42233 +31293 +25309 +28317 +41273 +42234 +713 +809 +26161 +25683 +89 +9232 +2049 +41581 +6068 +3601 +26657 +19 +4684 +8867 +42235 +42236 +28845 +411 +2944 +27669 +43 +12063 +5188 +13721 +19111 +14477 +38760 +3406 +2006 +40570 +18045 +41858 +42237 +42238 +38499 +10846 +21947 +42239 +44 +42240 +713 +17698 +13721 +155 +16315 +20679 +42241 +42242 +31873 +736 +37510 +42243 +42244 +42245 +15718 +2039 +915 +15718 +1559 +16375 +19 +595 +42246 +286 +25316 +1047 +38900 +13116 +42247 +31293 +42248 +31423 +42249 +155 +17042 +42250 +20315 +3055 +42251 +42252 +42253 +25 +19655 +33650 +42254 +736 +21689 +42255 +19 +46 +7053 +9 +16 +18683 +42256 +31293 +5085 +42257 +42258 +42259 +31293 +7379 +8367 +590 +42260 +37404 +790 +42261 +31293 +3981 +42262 +42263 +155 +21310 +43 +42264 +29200 +6341 +301 +42265 +21947 +21669 +28845 +14909 +140 +31293 +42266 +1047 +12 +2318 +18045 +42267 +4055 +42268 +42269 +21947 +28845 +16375 +40591 +19 +17353 +40570 +36735 +24725 +34804 +42270 +34402 +209 +42271 +3030 +31293 +155 +23103 +6726 +17670 +42272 +40570 +1234 +42273 +16085 +40570 +33627 +42274 +40570 +27011 +12987 +7065 +155 +89 +42275 +42276 +21669 +42277 +29381 +29483 +42278 +42279 +42280 +22065 +13579 +20487 +36268 +42281 +42282 +19 +30650 +42283 +42284 +40570 +153 +40570 +17151 +42285 +16437 +13390 +19618 +13826 +24725 +21669 +39434 +5297 +1051 +42286 +398 +46 +6508 +42287 +40570 +42288 +15506 +26498 +19 +18589 +42289 +3546 +19797 +29628 +21947 +155 +23121 +19655 +165 +42290 +42291 +29200 +42292 +30458 +13760 +42293 +42294 +42295 +1823 +40570 +736 +9 +13390 +42296 +42297 +24074 +57 +42298 +19 +1090 +42299 +42300 +42301 +33650 +590 +2561 +40570 +42302 +155 +5409 +42303 +28339 +42304 +42305 +12093 +5080 +42306 +869 +29204 +42307 +42308 +21689 +21947 +1169 +23103 +5088 +20 +27669 +38465 +27147 +9 +671 +1090 +2000 +5409 +42309 +42310 +4047 +32332 +42311 +16316 +43 +13615 +345 +10699 +42312 +18045 +42313 +42314 +40570 +20839 +21947 +554 +40570 +43 +40570 +19 +29483 +42205 +42315 +16121 +1244 +42316 +24161 +6582 +19 +12628 +42317 +1169 +42318 +42319 +42320 +28845 +9 +5041 +155 +699 +19223 +42321 +42322 +19 +42323 +2944 +155 +590 +42324 +42325 +30051 +9095 +32 +20442 +42326 +28317 +42327 +42328 +42329 +40570 +12366 +29483 +14856 +1481 +2197 +989 +42330 +28755 +13895 +42331 +42332 +416 +155 +77 +25237 +29483 +31168 +28219 +40707 +42333 +41944 +42334 +42335 +19 +14369 +14330 +20442 +4055 +27669 +1559 +736 +42336 +27798 +586 +15718 +155 +42337 +42338 +25683 +42339 +42340 +18334 +6935 +42341 +42342 +42343 +140 +42344 +671 +34518 +21947 +3601 +42345 +5773 +42346 +209 +6054 +37556 +590 +6627 +42347 +1559 +29434 +915 +25 +29483 +19618 +22476 +18780 +13323 +6441 +42348 +18310 +42349 +28643 +8483 +42350 +42351 +42352 +4245 +42353 +43 +42354 +21947 +57 +42355 +40570 +10117 +42356 +41919 +42357 +43 +29381 +9 +38033 +29483 +42358 +10320 +42359 +24303 +15718 +42360 +286 +30814 +42361 +40570 +37556 +40570 +21689 +15820 +14477 +37154 +28490 +19618 +424 +42362 +8849 +19 +40570 +42363 +931 +46 +10782 +872 +16413 +155 +14604 +42364 +1364 +42365 +43 +42366 +42367 +19795 +9 +27669 +342 +42368 +590 +42369 +42370 +13390 +42371 +42372 +430 +42373 +5925 +29483 +42374 +586 +41695 +19 +41919 +9 +1384 +249 +38760 +38760 +42375 +42376 +590 +42377 +42275 +31293 +205 +4230 +31293 +42378 +554 +41919 +29483 +20507 +11328 +1134 +29628 +42379 +42380 +21947 +7379 +15 +12005 +25237 +15718 +590 +22717 +7276 +42381 +42382 +5022 +28845 +573 +7276 +42383 +42384 +42385 +30224 +3743 +42386 +42387 +34402 +40570 +37790 +31293 +9 +1090 +31293 +4963 +31098 +3546 +27794 +1054 +42388 +1465 +42389 +533 +9 +40570 +24144 +21947 +42390 +2841 +1571 +33650 +23103 +36 +40570 +42391 +42392 +42393 +23103 +24864 +12684 +24303 +1615 +42394 +42395 +42396 +30917 +590 +42397 +10946 +40570 +25260 +42398 +4363 +242 +30877 +16437 +42399 +42400 +29483 +42401 +42402 +42403 +42404 +42405 +1384 +10464 +3944 +27905 +42406 +12500 +3978 +21947 +31293 +1090 +736 +42407 +42408 +32 +958 +31293 +301 +42409 +19852 +1154 +42410 +28317 +590 +34402 +4055 +590 +42411 +42412 +42413 +6839 +19523 +42414 +42415 +42416 +42417 +42418 +42419 +31293 +14369 +42420 +42421 +4028 +42422 +24864 +155 +1384 +42423 +34227 +1524 +2310 +42424 +872 +42425 +33469 +36735 +42228 +1082 +9148 +19030 +42426 +42427 +28845 +22 +39520 +19 +42428 +155 +9384 +42429 +41919 +42430 +18045 +323 +42431 +42432 +42433 +21089 +188 +32410 +42434 +31293 +1090 +42435 +1045 +2604 +22986 +25683 +4502 +42436 +590 +13365 +43 +25943 +14330 +42437 +3528 +1157 +14369 +42438 +42439 +29981 +43 +42440 +42441 +989 +225 +27117 +48 +17653 +42442 +42443 +42444 +27025 +15354 +5231 +590 +14369 +9254 +7617 +1026 +43 +15498 +42445 +16443 +27310 +67 +42446 +40570 +11702 +40570 +42246 +30224 +19287 +42447 +27669 +42448 +42449 +25106 +40570 +1531 +42450 +42451 +42452 +19618 +37556 +1021 +42453 +21947 +42454 +41919 +33650 +15533 +42455 +1404 +21045 +25683 +1169 +10262 +15 +10052 +42456 +42457 +19655 +42458 +42459 +14369 +349 +442 +40570 +27843 +1847 +38465 +4116 +349 +28490 +1870 +17472 +14369 +42460 +19 +164 +42461 +874 +28845 +42462 +155 +4055 +42463 +7855 +590 +21730 +21947 +30705 +42464 +4055 +42465 +18991 +15718 +33061 +46 +9 +28845 +42466 +23150 +42467 +43 +9 +27857 +42468 +33758 +42469 +27069 +42470 +41695 +25140 +5858 +3 +19 +42471 +42472 +13390 +8249 +42473 +176 +42474 +514 +23518 +42475 +42476 +26361 +42477 +25047 +720 +43 +66 +19 +2762 +42478 +42479 +89 +42480 +1203 +29483 +1870 +30051 +1021 +677 +42481 +259 +4528 +5188 +42482 +11273 +18684 +42483 +42484 +21089 +42485 +349 +42486 +32410 +66 +349 +16 +30224 +24864 +42487 +22787 +7362 +28845 +21947 +2009 +31293 +5344 +823 +323 +42488 +42489 +42490 +1090 +31293 +8668 +590 +42491 +25237 +15718 +7698 +7799 +42492 +39434 +15 +42493 +29204 +42494 +1222 +42495 +21689 +7419 +42496 +2727 +41919 +40570 +3452 +16466 +42497 +13390 +19167 +20673 +60 +17151 +42498 +286 +936 +42499 +893 +15718 +42500 +736 +42501 +533 +2260 +42502 +42503 +20514 +8668 +28036 +13390 +42504 +40570 +42505 +92 +42506 +583 +155 +19618 +25316 +720 +114 +736 +8849 +5188 +40570 +42507 +185 +42508 +15718 +42509 +14330 +42510 +31293 +24303 +20175 +42511 +12307 +42512 +35489 +24896 +9 +28317 +415 +14 +42513 +595 +8668 +38465 +31522 +155 +30794 +38760 +42514 +42515 +8787 +14369 +42516 +40570 +42517 +10846 +33650 +42518 +42519 +42520 +9 +27669 +15054 +42521 +40570 +35316 +29483 +5085 +140 +25 +33627 +32 +209 +42522 +2854 +43 +34402 +42523 +42524 +19655 +209 +155 +34944 +13721 +42525 +42526 +196 +42527 +10 +27669 +14363 +23111 +41919 +42528 +24410 +19 +815 +31293 +42529 +27669 +1543 +13390 +7658 +42530 +865 +5085 +42531 +519 +19655 +42532 +8668 +42533 +42534 +14108 +30224 +4598 +9 +28845 +2164 +15914 +14369 +42535 +42536 +38033 +590 +2015 +228 +42537 +29157 +1120 +89 +42538 +31293 +24709 +42539 +31293 +9 +42540 +5188 +590 +39363 +15 +42541 +12987 +42542 +15845 +15720 +1157 +42543 +2476 +11369 +1924 +33627 +29483 +36736 +42544 +42545 +2372 +17385 +4055 +42546 +42547 +41603 +18695 +16466 +46 +40570 +33627 +42548 +9396 +19 +42549 +155 +27669 +34402 +77 +43 +3764 +15398 +42550 +42551 +24303 +915 +8367 +32790 +42552 +42553 +23005 +37556 +42554 +9 +10935 +42555 +1710 +42556 +1378 +22963 +514 +42557 +28036 +22808 +42558 +40570 +42559 +38893 +22986 +42560 +14381 +40097 +7253 +42561 +24144 +40570 +42562 +42563 +37556 +590 +42564 +42565 +41117 +42566 +42567 +25316 +9097 +16440 +42568 +42569 +22898 +42570 +8668 +887 +42571 +38465 +1517 +3875 +42572 +19167 +42573 +11389 +42574 +40570 +1991 +34 +35224 +23547 +36268 +42575 +495 +42576 +5085 +37958 +39713 +25584 +42577 +42578 +27829 +43 +42579 +43 +13824 +30051 +21947 +42483 +42580 +41117 +42581 +38760 +12158 +6004 +42582 +42583 +6335 +42584 +37556 +42585 +32 +42586 +32 +13390 +33650 +28845 +34454 +42587 +42588 +57 +42589 +21669 +1224 +27669 +42590 +21689 +42316 +42591 +42592 +29483 +2064 +15718 +8427 +23103 +23103 +958 +40570 +42593 +597 +323 +42594 +42595 +42596 +41117 +2289 +27104 +15718 +42597 +41687 +4403 +19 +42598 +1562 +18045 +15718 +42599 +13390 +33650 +345 +42600 +15718 +1444 +1234 +19 +5874 +28936 +1090 +17951 +265 +15 +41273 +533 +9 +572 +41941 +42601 +9452 +34402 +14887 +3369 +43 +155 +42602 +817 +42603 +514 +222 +13390 +42604 +26815 +17911 +42605 +32467 +26496 +42606 +554 +42607 +42608 +42609 +11328 +1425 +17911 +42610 +37411 +19167 +24303 +42611 +21521 +745 +155 +27669 +46 +42612 +4116 +35624 +6669 +29483 +42613 +42614 +42615 +38527 +40570 +41919 +42616 +42617 +36436 +155 +694 +42618 +32 +8103 +42619 +19 +42620 +42621 +42622 +21791 +42623 +179 +13721 +671 +21947 +42624 +42625 +3 +13129 +29483 +736 +7276 +42626 +28845 +42627 +17698 +21947 +42628 +42629 +1559 +40570 +751 +32 +40570 +6122 +4124 +42630 +42631 +28845 +19655 +42632 +42633 +9 +21947 +2427 +42634 +1961 +40570 +7944 +36674 +24324 +155 +19618 +42635 +1090 +10946 +42636 +16798 +26496 +11733 +42637 +12013 +42638 +33061 +42639 +41567 +736 +25921 +42640 +28168 +42641 +32642 +560 +17151 +4808 +42642 +14079 +42643 +42644 +849 +42645 +5391 +42646 +10642 +42647 +1566 +155 +7835 +36735 +30209 +1889 +42648 +33627 +31293 +13528 +1531 +42649 +18846 +14668 +42650 +694 +42651 +28845 +28036 +42652 +42653 +42654 +40570 +42655 +32477 +42656 +42657 +42658 +155 +42659 +1082 +42660 +19 +37556 +42661 +42662 +42663 +42664 +5041 +42665 +42666 +13390 +590 +42667 +23103 +9441 +4806 +33330 +42668 +42669 +42670 +24864 +21126 +32190 +10 +2015 +43 +42671 +155 +1961 +42672 +21947 +9688 +34758 +19 +42673 +590 +42674 +43 +2325 +21947 +42675 +42676 +42677 +19 +201 +42678 +38760 +42679 +1090 +1090 +42680 +1224 +26959 +40570 +42681 +40570 +42682 +18695 +28845 +9024 +40570 +36727 +19 +42683 +1335 +342 +155 +2694 +208 +37556 +42684 +17911 +2476 +26157 +42685 +42686 +66 +1502 +42687 +33627 +1444 +42688 +21602 +560 +42689 +317 +42690 +28845 +7053 +40570 +42691 +42692 +26496 +42693 +28845 +33650 +6744 +32449 +2314 +12120 +42694 +1090 +2896 +9 +13905 +286 +736 +11822 +7835 +5601 +24864 +41919 +178 +15802 +11683 +25237 +29424 +16437 +18561 +53 +41919 +28219 +18176 +26389 +19 +791 +40570 +42695 +18553 +42696 +21669 +2314 +10859 +14369 +9 +42697 +491 +42542 +36735 +815 +1090 +448 +415 +29200 +42698 +42699 +2243 +19 +1920 +42700 +15 +14330 +29770 +284 +1112 +9234 +31293 +26705 +42701 +25 +15824 +42702 +17911 +5080 +29483 +42703 +21947 +213 +42704 +590 +10527 +23103 +21175 +35594 +42705 +42706 +42707 +40570 +42708 +2372 +29 +42709 +12203 +8727 +378 +42710 +284 +23821 +1511 +5499 +31098 +6985 +42711 +42712 +713 +29381 +43 +29675 +40570 +284 +42713 +42714 +5409 +17749 +42715 +349 +28317 +1090 +42716 +156 +31293 +21669 +40570 +823 +42717 +29483 +42718 +5780 +248 +19 +36943 +42719 +42720 +42721 +590 +18951 +42722 +40570 +42723 +13390 +155 +28845 +31293 +42724 +42725 +284 +24207 +140 +1090 +42726 +34650 +42727 +21947 +590 +390 +2653 +42728 +42729 +17385 +30224 +284 +38358 +8668 +19167 +42730 +38064 +39053 +213 +42731 +15 +29483 +284 +40591 +42732 +31293 +42733 +32332 +21947 +248 +42734 +27669 +42735 +7053 +791 +31293 +42736 +28845 +5285 +15718 +36639 +34641 +21947 +42737 +42738 +42739 +1168 +24045 +18488 +43 +33302 +40591 +114 +14 +21269 +42740 +42741 +40570 +1090 +3698 +39709 +21689 +42742 +303 +42743 +155 +248 +42744 +5952 +6008 +25140 +36851 +40570 +39926 +43 +1200 +25943 +42745 +41266 +38465 +303 +21669 +6877 +42746 +19 +213 +17894 +31293 +1688 +1091 +3544 +4226 +42012 +14369 +37556 +42747 +9396 +42748 +19655 +7907 +14477 +213 +42749 +484 +14604 +671 +42750 +16693 +19 +42751 +303 +41342 +31293 +12302 +21669 +27669 +248 +41919 +42752 +42753 +21669 +21947 +42754 +42755 +573 +155 +210 +15712 +33650 +822 +590 +37556 +10973 +42756 +41622 +31293 +42757 +248 +13576 +196 +42758 +30816 +42759 +2476 +495 +303 +42760 +1652 +20785 +28845 +42761 +29483 +1224 +349 +42762 +24458 +8668 +42763 +37556 +16121 +42764 +18037 +42765 +28845 +25316 +42766 +21669 +3908 +27669 +42767 +42768 +284 +38465 +554 +29381 +9 +16966 +28845 +28845 +13905 +18503 +41695 +40570 +590 +14947 +213 +31225 +506 +1090 +36322 +1112 +42769 +40570 +42770 +42771 +849 +41880 +42772 +213 +4855 +37556 +42773 +36546 +38234 +155 +21669 +31885 +33650 +590 +42774 +42775 +41919 +25683 +19 +38607 +42776 +42777 +9422 +12118 +179 +42778 +42779 +10475 +42780 +3238 +42781 +57 +42782 +15718 +29483 +28490 +683 +42012 +40570 +42783 +21947 +19 +303 +22962 +648 +46 +24864 +22 +21279 +42784 +19 +42785 +42786 +590 +21398 +99 +541 +41919 +40570 +42787 +99 +42788 +14 +533 +42789 +27895 +46 +20514 +42790 +42791 +28459 +713 +364 +30551 +9 +42792 +42793 +42794 +40570 +30246 +19142 +6439 +19 +32 +25237 +42795 +21598 +1847 +1907 +4765 +42796 +19 +9898 +46 +42797 +42798 +25237 +40570 +201 +915 +42799 +43 +42800 +42801 +42802 +21669 +33714 +31293 +8338 +21669 +31098 +14369 +57 +9112 +13390 +3155 +17754 +41622 +3790 +3950 +377 +28845 +42803 +42804 +42805 +25683 +42806 +31293 +42807 +209 +42808 +42809 +13721 +4226 +1107 +5579 +35272 +28845 +337 +12987 +40570 +12936 +1384 +2649 +17911 +19 +1543 +5499 +39709 +284 +42810 +155 +9 +24081 +42811 +40939 +42812 +42813 +42814 +1559 +4985 +9 +3055 +713 +42815 +104 +4847 +3196 +28845 +23103 +42816 +248 +41397 +3863 +26549 +30209 +495 +20600 +13390 +42817 +40570 +42818 +14192 +436 +42819 +155 +415 +19 +32896 +21947 +14603 +15275 +42820 +15 +42821 +38760 +16 +42822 +42823 +1021 +42824 +16941 +42825 +936 +177 +42826 +21669 +354 +22 +42827 +42828 +42829 +16609 +40570 +554 +31293 +28317 +38003 +42830 +21947 +25943 +28845 +42831 +43 +14330 +3546 +40570 +42832 +42833 +12152 +42834 +155 +12479 +2694 +34327 +35592 +42835 +42836 +39709 +21947 +42837 +398 +345 +31293 +10 +42838 +42839 +36403 +42840 +21947 +42841 +16 +42842 +155 +12020 +42843 +42844 +42845 +34506 +28577 +37770 +250 +42846 +29687 +28799 +21947 +21669 +446 +10298 +42847 +18045 +27719 +30580 +42848 +42849 +2769 +24896 +42850 +37556 +2310 +35085 +12987 +42851 +303 +1169 +42852 +42853 +40570 +16413 +52 +5065 +29483 +42854 +41919 +337 +33937 +42855 +1090 +34103 +42856 +43 +42857 +27455 +42858 +42859 +43 +19218 +2164 +18477 +165 +18683 +7488 +42860 +11808 +21947 +5188 +140 +26496 +9 +35224 +28845 +31603 +42861 +35158 +42862 +16443 +41919 +112 +42863 +42864 +822 +42865 +37556 +38465 +42866 +39593 +31346 +38465 +213 +155 +21791 +19 +2581 +6364 +16826 +936 +42867 +30224 +21947 +18317 +42868 +42869 +17698 +29716 +40570 +42870 +30224 +42871 +42872 +8070 +42873 +40570 +42874 +42875 +43 +19618 +21947 +4699 +554 +42876 +576 +213 +155 +155 +5188 +39709 +19167 +42877 +155 +42878 +5409 +3241 +25140 +24144 +10946 +1090 +656 +42879 +2694 +42880 +42881 +42882 +554 +42883 +590 +40570 +42884 +10946 +42885 +42886 +42887 +22380 +25584 +42888 +249 +42889 +492 +28845 +42890 +9 +554 +42891 +28212 +43 +317 +955 +8867 +41919 +2052 +2514 +2415 +42892 +98 +27819 +736 +19582 +26943 +31293 +8919 +19 +30580 +42893 +14369 +32931 +16828 +12281 +42894 +42895 +15477 +32 +21027 +42896 +16089 +40570 +7385 +2919 +42897 +21947 +42898 +33445 +42899 +1090 +26496 +40570 +3644 +13390 +2488 +43 +19 +42900 +42901 +42902 +616 +37556 +590 +41890 +31293 +42903 +21947 +42904 +23103 +42905 +42906 +416 +248 +19 +2457 +37556 +28317 +18045 +15718 +213 +42907 +42908 +37770 +42909 +42910 +11966 +40570 +24862 +30224 +20700 +6096 +42911 +15718 +33650 +42912 +42913 +42914 +509 +736 +29483 +19 +42915 +21179 +26361 +25683 +42916 +42917 +713 +155 +31873 +1013 +8541 +42918 +42919 +250 +573 +40570 +590 +2692 +178 +213 +155 +34264 +42920 +41687 +14330 +42921 +720 +4908 +345 +42922 +24303 +14871 +40022 +15810 +42923 +42924 +1442 +42925 +9 +590 +31437 +248 +42926 +17911 +43 +6785 +5791 +16375 +788 +42927 +15718 +19618 +42928 +42929 +179 +32920 +42930 +42931 +3252 +9005 +41890 +42932 +337 +40928 +597 +699 +17670 +2260 +25683 +7486 +32920 +42933 +21698 +1051 +2260 +155 +42934 +11321 +1291 +19852 +303 +33650 +14824 +7117 +1774 +303 +337 +4028 +11754 +24458 +21049 +590 +155 +42935 +286 +35624 +40570 +42936 +42937 +4538 +1559 +17228 +284 +34402 +303 +19 +33650 +42938 +42939 +17635 +1012 +25316 +29381 +42940 +26361 +303 +42941 +40570 +4471 +501 +178 +42942 +25316 +317 +46 +26669 +34402 +42943 +590 +42192 +38284 +30580 +24496 +4441 +37556 +33349 +29483 +103 +533 +42944 +5065 +40570 +42945 +2672 +42946 +21947 +12020 +41695 +2672 +40928 +4155 +42947 +37556 +248 +42948 +41919 +9902 +41890 +41890 +15 +31293 +955 +13036 +42949 +590 +18988 +13390 +41687 +6121 +15718 +284 +42950 +294 +42951 +4463 +342 +42952 +57 +42953 +1291 +28845 +5188 +2672 +9 +42954 +12351 +554 +971 +23103 +42955 +15718 +42956 +41919 +34613 +21947 +7451 +1716 +42957 +42958 +42959 +26361 +21947 +42960 +30221 +29381 +42421 +345 +12722 +1465 +41890 +42961 +42962 +42963 +42964 +42965 +41890 +42966 +42967 +33627 +29874 +155 +42968 +30224 +42969 +20443 +42970 +27669 +815 +28845 +42971 +34448 +18740 +9 +42972 +31246 +42973 +4055 +42974 +42975 +77 +24864 +46 +736 +10946 +42976 +46 +8367 +12642 +3599 +248 +25 +24045 +21689 +10932 +16891 +28845 +42977 +14477 +40570 +554 +42978 +42979 +43 +42980 +41890 +3034 +41890 +37556 +41890 +155 +41890 +42981 +29 +42982 +31454 +31964 +42983 +42984 +42985 +42986 +42987 +29483 +4123 +4313 +16 +16443 +4463 +41919 +2287 +19 +345 +16205 +14001 +25142 +14079 +42988 +17911 +33002 +478 +42989 +4055 +41890 +41890 +29484 +317 +1961 +42990 +3318 +155 +41890 +1716 +9194 +303 +34402 +2779 +42991 +42992 +42993 +42994 +42995 +15683 +43 +21089 +41890 +42996 +26040 +1109 +25624 +40570 +42997 +8668 +72 +19091 +42998 +42999 +43000 +43001 +43002 +4264 +43003 +155 +11869 +13390 +3034 +19918 +41890 +43004 +43005 +43006 +36268 +25316 +34613 +40570 +41890 +41890 +29483 +43 +43007 +36483 +24038 +3601 +9 +21947 +43008 +791 +43009 +43010 +29687 +18276 +41890 +43011 +41890 +30051 +43012 +41890 +41890 +41890 +14133 +43013 +43014 +378 +7231 +411 +8807 +8248 +33627 +41890 +15 +43015 +22922 +9 +37077 +917 +43 +19 +41890 +28845 +43016 +861 +77 +19 +3598 +14369 +41890 +41890 +43017 +19 +43018 +30224 +31293 +24144 +5963 +34496 +41890 +39080 +42962 +20514 +25237 +35926 +4288 +2043 +29483 +43019 +43020 +43021 +29381 +554 +43022 +41890 +41890 +2315 +19 +40570 +40570 +21947 +41890 +1157 +43023 +1961 +1774 +43024 +39371 +5065 +7014 +15 +41890 +18746 +3551 +41919 +41890 +19 +24303 +590 +43025 +24303 +28845 +41890 +597 +2121 +104 +41890 +4263 +27669 +26040 +41890 +28597 +43026 +43027 +41890 +43028 +43029 +28845 +155 +1605 +29483 +13390 +40570 +43030 +25683 +40570 +43031 +41890 +41890 +43032 +46 +41890 +20514 +43033 +40570 +7987 +6245 +43034 +43035 +43036 +41890 +25 +1444 +23103 +4518 +43037 +2029 +1543 +43038 +193 +41890 +43039 +28845 +43040 +43 +4808 +37556 +33693 +43041 +43042 +30209 +42421 +43043 +43044 +43045 +57 +590 +33627 +40570 +41890 +40570 +43046 +41890 +23752 +41890 +14869 +27669 +31293 +37556 +15718 +26158 +21947 +20340 +21105 +15 +43047 +43048 +43049 +15718 +21031 +37556 +7912 +41890 +31098 +15193 +558 +43050 +32456 +23271 +43051 +43052 +2577 +15718 +13405 +43053 +22 +21947 +331 +36639 +27669 +2029 +41890 +28845 +155 +29381 +40570 +43054 +1817 +43055 +590 +222 +43056 +4028 +16437 +43 +35769 +43 +155 +25683 +845 +3546 +349 +29707 +41890 +41890 +41890 +155 +43057 +1051 +342 +4603 +43058 +6571 +41890 +43059 +43060 +43061 +16466 +43062 +40570 +2463 +3669 +14962 +7978 +21947 +41890 +40570 +43063 +41890 +41890 +9918 +40570 +41890 +43064 +40570 +1442 +1090 +43065 +30224 +15718 +41890 +339 +43066 +41919 +155 +5409 +43067 +22552 +554 +1870 +43068 +43069 +13721 +28441 +43070 +43071 +43072 +43073 +19918 +33758 +1066 +43074 +24454 +41890 +495 +41890 +43075 +43076 +41890 +41890 +1824 +1090 +41890 +31503 +33444 +3252 +19 +43077 +43078 +40570 +41890 +33650 +41890 +41890 +19655 +43079 +17911 +43080 +29483 +43081 +40570 +2064 +19655 +43082 +9 +41890 +43083 +41890 +2465 +6571 +40062 +33141 +19 +31139 +41890 +25316 +41890 +41890 +415 +41890 +43084 +155 +165 +41890 +155 +155 +43085 +16375 +41890 +720 +41687 +1038 +41890 +43086 +43087 +43088 +13361 +41890 +41890 +43089 +41890 +41890 +43090 +40570 +43091 +736 +9228 +5188 +2733 +12828 +43092 +41890 +43093 +41919 +10482 +60 +34402 +590 +26946 +43094 +41890 +43095 +11315 +1364 +317 +30877 +43096 +43097 +2314 +15718 +646 +19 +43098 +43099 +41919 +41890 +41890 +43100 +21669 +37556 +40570 +43101 +43102 +41890 +28845 +41890 +43103 +32 +41890 +20356 +41890 +41890 +14369 +21261 +43104 +9772 +6086 +43105 +365 +25140 +41890 +41890 +478 +15483 +43106 +43107 +43108 +41890 +43109 +41890 +43110 +41890 +14909 +10745 +43111 +43112 +41890 +43113 +43114 +41890 +33650 +43115 +34264 +179 +41890 +43116 +31293 +41890 +34 +2791 +43117 +33627 +41890 +77 +41890 +209 +19618 +1018 +43118 +41890 +533 +41890 +41890 +43119 +43120 +41890 +41890 +1090 +38465 +4055 +700 +43121 +43122 +3239 +43123 +713 +40264 +41890 +514 +43124 +41890 +41890 +40570 +2197 +43125 +38003 +43126 +43127 +43128 +354 +21669 +15018 +43129 +43130 +43131 +41890 +19655 +41890 +41919 +41890 +19355 +41890 +21669 +27069 +33494 +43132 +323 +41890 +46 +26744 +12479 +43133 +9 +43134 +4441 +3553 +41890 +5188 +42000 +43135 +41890 +41890 +24303 +41890 +17911 +28845 +28845 +41890 +43136 +43 +2872 +19 +19 +41890 +43137 +28845 +43138 +43139 +41890 +41890 +43140 +176 +43141 +25316 +43142 +43143 +43144 +41890 +9 +8833 +26900 +41890 +41890 +155 +46 +43145 +41890 +36823 +4 +43146 +43147 +43148 +41890 +20700 +568 +8668 +40570 +19 +41890 +5780 +41890 +41890 +43149 +43150 +43151 +39709 +112 +43152 +41890 +43153 +19 +43154 +1090 +43155 +1090 +21669 +41890 +19655 +41155 +39536 +887 +40570 +155 +43156 +155 +36735 +1234 +1471 +40570 +3311 +42711 +43157 +43158 +43159 +21669 +41890 +41890 +349 +41890 +41890 +46 +43160 +980 +43161 +11907 +416 +43162 +41890 +910 +31293 +36268 +41890 +41890 +41890 +43163 +3484 +1870 +39709 +26361 +736 +1907 +590 +21947 +43164 +43165 +1384 +1961 +41890 +41890 +41890 +29639 +586 +41890 +9 +43166 +41890 +41890 +41890 +491 +17 +43167 +43168 +43169 +10909 +43170 +43171 +43172 +21089 +41890 +43173 +590 +43174 +36736 +17472 +25 +43175 +155 +41890 +41890 +43176 +41890 +41890 +13390 +1829 +43177 +15216 +41890 +41890 +38789 +2254 +43 +2260 +11757 +36268 +41890 +43178 +43179 +43180 +41890 +15552 +41890 +41890 +9 +41890 +41890 +41890 +15 +14369 +43181 +43182 +19792 +31293 +41890 +29483 +14176 +14077 +41890 +43183 +41890 +41890 +872 +6077 +41890 +41890 +43184 +43185 +2727 +41890 +43186 +590 +43187 +41890 +43188 +29733 +43189 +43190 +43191 +43192 +41890 +43193 +155 +8864 +33765 +43194 +43195 +43196 +41080 +43197 +34488 +3369 +34579 +15718 +43198 +43199 +42259 +5188 +21669 +13528 +2804 +18061 +40570 +41890 +27178 +43200 +457 +6617 +41890 +412 +43201 +41890 +43202 +43203 +43204 +41890 +41890 +809 +5627 +1112 +30877 +31168 +20167 +43205 +357 +13390 +43206 +43207 +43208 +22901 +41890 +25237 +43209 +33916 +43210 +43211 +43212 +40570 +40143 +3994 +1090 +1307 +25237 +41499 +29254 +21669 +9 +78 +7191 +43213 +43214 +41890 +41890 +43215 +21669 +43216 +41890 +43217 +13360 +43218 +861 +43219 +34641 +66 +27291 +43220 +43221 +43222 +41890 +791 +43223 +41890 +112 +40570 +43224 +41890 +20340 +36268 +43225 +165 +8297 +43226 +3559 +1310 +35536 +43227 +24864 +43228 +21947 +1765 +5791 +43 +43229 +43230 +43231 +43232 +43233 +22986 +9 +43234 +9 +671 +41890 +41890 +43235 +14369 +33024 +21669 +22963 +43212 +713 +554 +41890 +20593 +33120 +41890 +41890 +31293 +57 +43236 +25683 +14810 +43237 +1153 +43238 +31293 +43239 +43240 +14467 +1011 +41890 +43241 +590 +41890 +41175 +43242 +19 +33524 +43243 +43244 +30650 +43245 +43246 +29483 +38758 +15718 +30551 +21947 +43247 +43248 +43249 +28295 +18283 +41890 +15718 +155 +41890 +32915 +21669 +41890 +41890 +9573 +12013 +41567 +41890 +43250 +41890 +7631 +15 +43251 +32 +155 +5780 +33650 +1112 +564 +598 +41890 +12231 +43252 +43253 +41890 +41890 +43254 +41890 +41890 +43255 +40591 +6543 +8128 +41890 +8668 +41890 +43256 +21669 +2356 +43257 +41890 +43258 +41890 +41890 +37556 +3553 +5293 +38529 +5188 +4637 +4055 +21732 +42290 +5409 +5860 +43168 +28846 +41890 +13270 +43259 +20078 +28740 +41890 +2314 +41890 +43260 +43261 +43262 +41890 +41890 +7658 +43263 +2859 +43264 +43265 +43266 +24603 +43267 +31293 +43249 +43268 +25848 +43269 +41890 +30109 +21669 +1013 +5764 +15 +43099 +43270 +43271 +36483 +1090 +30650 +540 +32 +43272 +30224 +41890 +43273 +41890 +43274 +41890 +41890 +5582 +7762 +6996 +43275 +5601 +43276 +41890 +39709 +43277 +43278 +41890 +12518 +57 +43279 +25237 +3844 +43280 +19 +43281 +14330 +43282 +41890 +1797 +103 +43283 +43284 +40861 +38465 +4278 +41890 +33627 +1920 +12020 +41890 +21689 +43 +60 +43285 +8668 +41890 +21947 +6086 +2865 +43286 +41890 +13390 +201 +8501 +41890 +24762 +10987 +43 +43287 +1090 +40570 +43288 +41890 +155 +41890 +8160 +43289 +43290 +40570 +36735 +26953 +43291 +12178 +43292 +43293 +23528 +43249 +41890 +43294 +43295 +41890 +43296 +41890 +1172 +43297 +18695 +40570 +10946 +41890 +41890 +43298 +43299 +41890 +16437 +41707 +40067 +21089 +98 +43300 +41890 +41890 +31293 +8896 +43301 +41890 +41890 +41890 +24045 +43302 +283 +41890 +8668 +16798 +43303 +590 +43 +43304 +43305 +43306 +43307 +41890 +33120 +41890 +41890 +43308 +43309 +31139 +29204 +14017 +29836 +43310 +33627 +16466 +19655 +43311 +43312 +41890 +43313 +1186 +12 +29483 +43314 +19655 +21669 +24324 +39709 +41890 +14399 +43315 +31098 +43316 +543 +14604 +43317 +41890 +23479 +43318 +41890 +43319 +43320 +37556 +41890 +4441 +41890 +21947 +31293 +21627 +19618 +43321 +46 +41890 +43322 +317 +40570 +40570 +43323 +13390 +43324 +14947 +14719 +29483 +6505 +41890 +43325 +2427 +590 +265 +43326 +21312 +4196 +19655 +2015 +43327 +43328 +43329 +41890 +43330 +590 +5489 +34402 +26738 +5916 +791 +41890 +43331 +43332 +28000 +43333 +41890 +43334 +18045 +9 +43335 +20876 +43336 +89 +43337 +27798 +43338 +43339 +745 +37768 +31293 +43340 +745 +43341 +41890 +15 +41890 +20700 +416 +43342 +43 +43343 +16437 +2410 +7930 +41890 +40570 +43344 +19 +2236 +41890 +3598 +1533 +43345 +24864 +41890 +43346 +43347 +43348 +41890 +43349 +43350 +41890 +41890 +21669 +41890 +16437 +41890 +46 +41890 +41890 +3994 +15914 +3949 +40591 +13998 +2161 +43351 +34435 +43352 +12254 +1524 +39709 +43353 +43354 +43355 +25144 +43356 +41890 +21669 +41890 +43357 +36143 +43358 +36027 +16966 +43359 +24303 +43360 +43361 +707 +736 +41890 +155 +17151 +4258 +41890 +15718 +23833 +21947 +30224 +41890 +249 +41890 +40570 +40570 +43362 +15718 +43363 +13566 +249 +43364 +15718 +43365 +4245 +41890 +9 +14330 +41890 +11966 +1992 +41890 +41890 +249 +46 +29483 +43366 +299 +41890 +5344 +1559 +140 +41890 +9356 +43367 +43368 +6225 +29434 +7658 +210 +41890 +574 +41890 +43369 +20984 +43347 +40570 +2243 +19 +41890 +155 +554 +41890 +201 +43370 +597 +1688 +286 +43371 +15971 +323 +41890 +31293 +41890 +41890 +518 +41890 +14087 +41890 +2318 +6217 +8668 +33185 +31225 +2410 +16618 +41890 +24864 +43372 +40570 +34435 +41890 +12450 +43373 +15718 +24303 +43374 +5085 +5773 +41890 +41890 +43375 +37556 +17947 +37291 +43376 +43347 +12987 +43377 +41890 +14 +41890 +41890 +41890 +18869 +590 +43378 +41890 +41890 +6364 +41890 +41890 +38381 +16443 +2744 +41890 +41919 +42349 +17698 +34 +37556 +3 +43379 +23103 +43380 +2330 +16375 +41687 +19792 +19 +11855 +1425 +41567 +8357 +1090 +411 +41890 +6441 +43381 +43382 +43383 +564 +19713 +43384 +43385 +32 +1961 +43386 +590 +41890 +43387 +43388 +43389 +5647 +4411 +333 +41890 +41890 +5612 +43390 +43391 +43392 +286 +43393 +18561 +43394 +43395 +6058 +19 +31098 +21131 +44 +5071 +1559 +43396 +43397 +41890 +15718 +21669 +43398 +43399 +46 +43400 +43401 +671 +1013 +590 +43402 +41890 +17911 +43403 +142 +5780 +36665 +43404 +1961 +1524 +41890 +43405 +41890 +43406 +41890 +41890 +17385 +12081 +41890 +43 +40570 +32920 +43407 +43408 +43409 +43410 +43411 +15824 +41890 +19 +21947 +30224 +415 +1615 +14369 +41890 +2577 +42483 +43412 +17894 +19655 +28845 +8668 +41890 +41890 +17523 +43413 +43414 +43415 +9 +349 +41890 +43416 +31293 +31293 +33524 +1021 +43417 +43418 +41890 +30551 +20 +2476 +41890 +41890 +15026 +17119 +21669 +21947 +43419 +20 +573 +155 +40570 +446 +43420 +13361 +43421 +38219 +9 +37881 +4518 +43422 +1090 +464 +41890 +736 +590 +41890 +9245 +9217 +43423 +43424 +16905 +43425 +41890 +43426 +31293 +41919 +37576 +8407 +43427 +43428 +43429 +41890 +22327 +43430 +30481 +43431 +41890 +40570 +43432 +40570 +41890 +29962 +736 +43433 +41890 +43434 +4455 +41890 +43435 +590 +20700 +43436 +43437 +43438 +41890 +41890 +41890 +683 +43439 +23103 +40570 +2694 +32 +41890 +6284 +41890 +29200 +13307 +887 +41890 +41890 +41890 +11449 +1716 +41890 +19 +345 +1495 +43440 +1502 +41890 +9 +3 +43441 +43442 +43443 +2228 +43444 +43445 +43446 +25584 +3415 +155 +42483 +30179 +41890 +41890 +43447 +43448 +41890 +13390 +21669 +26342 +43449 +41890 +43450 +43451 +19 +19852 +358 +9497 +20677 +41890 +41890 +15718 +41890 +19 +41890 +590 +32229 +41567 +43452 +40570 +43453 +19 +43454 +41919 +43455 +43456 +41890 +43457 +41796 +21522 +43458 +3908 +43 +41890 +41890 +155 +43459 +20 +5188 +43 +41419 +43460 +41890 +17571 +43 +27669 +26040 +31293 +43461 +41890 +14369 +41890 +43462 +683 +1112 +2566 +43463 +19 +41890 +31603 +41890 +590 +28923 +1051 +30576 +8160 +41890 +12445 +41890 +43464 +89 +1085 +41639 +25281 +13907 +43465 +43466 +7107 +1090 +36268 +43467 +43468 +27185 +41890 +5188 +590 +23103 +4242 +43469 +41890 +43470 +6874 +989 +43471 +28317 +5409 +43472 +25584 +43473 +736 +43474 +43475 +43476 +590 +27669 +651 +28845 +41890 +41890 +16466 +43477 +1090 +18045 +43478 +27719 +41890 +41890 +19 +41890 +573 +3317 +2434 +34706 +41890 +1021 +20700 +41890 +7553 +9 +43479 +16375 +41890 +942 +43480 +41890 +43481 +24303 +26040 +1090 +41890 +30762 +43482 +29483 +43483 +40570 +16640 +20941 +41890 +58 +41890 +43484 +397 +14330 +43485 +9 +41890 +19 +41890 +43486 +28845 +41890 +43487 +491 +19545 +41890 +43488 +41890 +30805 +41890 +15718 +43489 +1742 +41890 +25943 +40893 +41890 +36366 +1529 +43490 +23975 +43491 +3601 +41890 +39709 +19091 +21947 +41890 +43492 +41890 +43493 +43494 +3 +8670 +41890 +137 +705 +43495 +43496 +43497 +41890 +43498 +10 +34402 +20677 +137 +43499 +43500 +5243 +613 +41890 +43501 +41890 +43502 +43503 +32188 +30051 +41890 +9160 +41890 +43504 +20677 +15718 +41890 +39746 +590 +1049 +41890 +43505 +43506 +140 +41890 +40570 +43507 +43 +43508 +25943 +41890 +14369 +43509 +41890 +43510 +41890 +33442 +41890 +15718 +43511 +20442 +43512 +4 +30580 +16974 +41890 +43513 +43514 +43515 +29483 +43516 +519 +19095 +590 +11572 +41890 +43517 +15700 +13390 +5045 +43518 +40570 +43519 +43520 +464 +29483 +28897 +41890 +1107 +2289 +43521 +7048 +41890 +43522 +5679 +41890 +10360 +33541 +40605 +33510 +1224 +3 +40939 +43249 +28845 +827 +554 +590 +31293 +8919 +1316 +590 +43523 +19618 +43524 +43525 +4055 +43526 +3484 +41890 +43527 +16375 +43528 +38465 +377 +213 +1384 +21947 +29483 +41890 +213 +29381 +590 +43 +213 +13279 +8338 +14369 +43 +34433 +41890 +16 +155 +26229 +41919 +21669 +1566 +29200 +6595 +26496 +2694 +43529 +23805 +18863 +7854 +34641 +43530 +284 +28036 +43531 +41890 +41890 +43532 +43533 +43534 +43 +284 +25237 +43535 +38758 +43536 +155 +590 +23469 +41890 +8668 +5071 +41890 +303 +21947 +43537 +21053 +41890 +15718 +40570 +43538 +41890 +19 +43539 +41890 +1011 +41890 +1870 +2561 +8668 +1112 +41890 +6732 +707 +41890 +41890 +8392 +43540 +19 +248 +43541 +43542 +43543 +41904 +826 +14330 +3323 +43544 +10030 +416 +2040 +303 +43545 +41890 +76 +43546 +99 +5075 +19 +30224 +5650 +736 +4116 +41890 +40570 +43547 +213 +43548 +10869 +43549 +4196 +19 +99 +43550 +13390 +337 +1224 +41890 +213 +9446 +2406 +164 +590 +284 +89 +16707 +303 +140 +43551 +41890 +38 +43552 +43347 +13959 +10176 +16798 +1870 +41890 +10306 +21803 +15718 +9 +317 +19 +41890 +43553 +3 +41890 +24303 +43554 +21947 +464 +43555 +28441 +41890 +41890 +41890 +284 +43556 +250 +19 +213 +41890 +43557 +43486 +43558 +21947 +41890 +43559 +41890 +31293 +29483 +43560 +1812 +31168 +2655 +43561 +43562 +43 +2550 +22 +41890 +9 +27798 +43563 +43 +41890 +30877 +43564 +43565 +41890 +41117 +337 +303 +284 +1648 +284 +40570 +40570 +29483 +1592 +41890 +41890 +43566 +736 +43567 +41890 +15720 +43568 +248 +248 +491 +43108 +38310 +43569 +43570 +46 +15 +41890 +20 +14957 +1517 +337 +43571 +43572 +213 +28845 +25140 +41890 +9 +43573 +41890 +14420 +43574 +43575 +43576 +43577 +15720 +41890 +40570 +41890 +41890 +15831 +7053 +26496 +736 +284 +41890 +213 +27669 +38465 +41890 +43578 +41890 +41890 +225 +41890 +41890 +43256 +27656 +43579 +41890 +37790 +43580 +36218 +41890 +43581 +37961 +14369 +43582 +43583 +17869 +43584 +209 +39709 +213 +213 +29483 +40570 +43585 +43586 +7868 +43587 +36452 +29483 +16466 +41890 +259 +43588 +303 +284 +21947 +41890 +15718 +15718 +43 +1364 +41890 +11273 +9696 +21947 +33650 +10946 +31168 +43589 +43590 +3033 +57 +29204 +43591 +284 +41890 +4414 +140 +41622 +14330 +576 +43580 +7855 +19 +402 +1514 +5409 +43592 +43593 +43594 +213 +13807 +14603 +41890 +43595 +5085 +43596 +43597 +43598 +43599 +188 +43600 +43601 +35351 +40825 +43602 +28845 +29483 +713 +41890 +41890 +25605 +1524 +31293 +14102 +849 +43347 +41890 +43603 +13307 +41890 +3172 +827 +2919 +66 +41890 +43604 +38072 +40570 +42511 +9 +349 +317 +39709 +41890 +19695 +43605 +41890 +24303 +43606 +533 +41890 +1338 +41919 +43607 +5119 +43608 +43609 +41890 +40570 +16437 +18045 +1224 +41890 +40570 +25316 +41890 +6499 +57 +43610 +29483 +43611 +21947 +41890 +15718 +31293 +41919 +827 +43612 +4441 +36639 +13703 +43613 +155 +10389 +43614 +138 +140 +33650 +43615 +37338 +20340 +43 +43616 +4055 +1090 +178 +14693 +42290 +43617 +14603 +3 +3994 +140 +21669 +1991 +2728 +43618 +58 +43619 +30877 +9305 +2988 +43620 +1522 +2471 +43621 +43622 +43623 +1082 +41890 +7716 +29381 +15 +25316 +13150 +43624 +43625 +1018 +2008 +590 +38141 +41890 +21947 +18816 +43626 +8210 +4055 +40570 +34264 +323 +43627 +28549 +14330 +248 +43628 +41890 +43629 +41890 +41890 +41890 +34402 +40570 +1139 +28845 +41890 +43630 +41890 +43574 +2733 +18856 +41890 +41919 +155 +43631 +43632 +24725 +33569 +6441 +28845 +43633 +15 +861 +41890 +25237 +41890 +30209 +24662 +248 +349 +17385 +40570 +43634 +720 +15 +41890 +354 +43 +872 +13390 +41890 +43635 +1107 +6335 +10946 +213 +20087 +43636 +10946 +43637 +2804 +248 +43638 +43639 +22900 +43640 +43641 +13390 +43642 +43643 +2314 +41890 +13721 +10946 +43644 +28845 +2310 +8208 +43645 +11321 +43646 +43647 +5614 +8868 +21947 +1606 +12987 +43648 +43649 +41890 +15 +28845 +40570 +43650 +33650 +9 +43651 +7486 +14477 +43652 +14342 +24045 +43653 +6874 +43654 +4631 +43655 +248 +24864 +41890 +16367 +1584 +650 +14604 +41890 +5409 +27447 +43656 +43657 +3055 +43658 +19 +43 +15572 +27836 +41890 +41890 +8460 +41890 +43659 +14330 +21947 +284 +21669 +25237 +40570 +179 +1042 +33627 +34339 +21089 +41890 +41890 +33024 +43660 +354 +43661 +1870 +40591 +22 +41890 +43662 +43663 +38789 +738 +41919 +1905 +37556 +41890 +14369 +337 +590 +43664 +43665 +43666 +43667 +915 +43668 +9 +18956 +28845 +19046 +4344 +43669 +25 +39709 +43670 +9 +1157 +5780 +41890 +228 +14369 +43671 +25 +2310 +43672 +24908 +41890 +43673 +41890 +590 +5188 +915 +43674 +337 +43675 +41890 +41890 +1090 +43676 +31293 +590 +43 +4055 +33627 +36072 +337 +43677 +43678 +3078 +43679 +15 +43680 +41890 +43681 +337 +41890 +43 +41890 +7912 +40570 +40570 +36218 +29172 +43 +40570 +736 +24144 +4055 +41890 +19740 +590 +7360 +337 +554 +213 +865 +33109 +13390 +43682 +27719 +19 +4658 +9 +43683 +694 +23395 +43684 +14102 +7501 +31293 +43685 +41890 +43686 +10946 +41890 +43687 +4518 +43688 +43689 +41890 +41471 +7881 +43690 +15718 +1090 +43691 +41890 +11822 +14921 +43692 +14369 +11471 +43693 +43694 +43695 +41890 +43696 +337 +43697 +41890 +43698 +43699 +13215 +19 +41890 +41890 +41890 +41890 +41890 +43700 +13390 +43701 +19 +43702 +41890 +278 +1010 +6341 +5392 +213 +16437 +176 +26503 +34402 +24338 +43703 +677 +43704 +43705 +40570 +1765 +19918 +43706 +41890 +43707 +32332 +2415 +43708 +43709 +43108 +43710 +16437 +40570 +416 +43711 +9741 +41890 +43712 +28441 +43713 +43714 +43715 +7914 +41890 +43716 +43717 +4764 +15 +24303 +43718 +43719 +43720 +40570 +19 +12 +9233 +3 +1774 +43721 +41890 +41890 +19 +19 +43722 +5601 +19 +43723 +43724 +40591 +14086 +5119 +43725 +43726 +43727 +41890 +1090 +43728 +1716 +598 +19 +23103 +43729 +29381 +41890 +484 +4055 +41890 +43730 +41890 +2135 +30835 +43731 +533 +14330 +41890 +41890 +41890 +31293 +43732 +43733 +24144 +41890 +29381 +40570 +43734 +25683 +43 +6341 +4684 +14369 +32429 +30479 +194 +7516 +1090 +41890 +41890 +43735 +41890 +43736 +43737 +43738 +3709 +31168 +671 +25316 +958 +31603 +303 +38595 +41890 +43739 +40881 +3601 +20941 +21947 +491 +1524 +43740 +43741 +43742 +8668 +4364 +14266 +43743 +9 +43744 +155 +3858 +14620 +872 +25426 +41890 +590 +21669 +14477 +416 +19167 +15718 +12118 +14330 +30209 +4808 +43745 +24144 +1720 +33469 +22294 +37556 +43746 +43747 +398 +43 +41890 +43748 +19 +3772 +398 +29483 +5877 +8367 +43749 +36177 +43750 +43751 +28549 +15 +21903 +41890 +43752 +28036 +41305 +10946 +30224 +9 +42421 +2764 +41890 +41687 +21947 +41890 +41890 +28199 +20514 +41890 +25140 +43753 +33650 +5188 +1330 +3978 +37556 +29483 +790 +21026 +34402 +29483 +43754 +2085 +36333 +1090 +41890 +21669 +32642 +34402 +32925 +40570 +43755 +21669 +40570 +12 +43756 +43757 +2697 +43758 +286 +155 +35838 +19 +5085 +43759 +43760 +39709 +41890 +9688 +33496 +40570 +3 +4075 +41890 +43761 +43762 +19 +201 +21947 +15 +41890 +1090 +9696 +16443 +25140 +43763 +36328 +21947 +9 +41890 +43120 +21669 +1090 +43764 +103 +29483 +17943 +41890 +41890 +31041 +4764 +41890 +43765 +98 +41890 +8994 +41890 +33650 +1451 +713 +26744 +41890 +5582 +43766 +23518 +43767 +43768 +43769 +43770 +35224 +1172 +28845 +41890 +43771 +43772 +8512 +590 +19618 +43773 +43774 +24678 +352 +155 +26496 +35246 +19 +43775 +41890 +140 +6877 +1090 +5438 +43776 +46 +1615 +14330 +42000 +41890 +43777 +66 +155 +43 +43778 +43779 +43780 +37556 +354 +19472 +39709 +43781 +28845 +20497 +43782 +41890 +16443 +155 +15 +43783 +9460 +43 +43784 +41890 +21947 +43785 +43786 +25627 +10946 +590 +43787 +43788 +43 +43789 +14369 +43790 +24303 +249 +32410 +28845 +43791 +25 +43792 +28441 +43793 +713 +19 +26320 +43794 +30877 +37556 +43795 +28599 +43796 +20600 +43797 +20442 +92 +1905 +43798 +17338 +41890 +3553 +36921 +43799 +1481 +35224 +28441 +8392 +41890 +14604 +43800 +1768 +15718 +43801 +4245 +112 +41890 +11420 +32402 +41890 +43802 +43803 +43804 +30902 +2882 +14102 +43805 +43806 +43807 +32410 +19579 +43808 +155 +43809 +1907 +19 +25683 +14025 +43810 +9 +43811 +40570 +41890 +43812 +43338 +323 +41890 +41890 +43 +28845 +14562 +41890 +9364 +43813 +40570 +12629 +43814 +21251 +43815 +41567 +989 +43816 +19 +4050 +37364 +15718 +43817 +42741 +43818 +25407 +43819 +43820 +43821 +40570 +41890 +40570 +3546 +736 +590 +41890 +43822 +36735 +17911 +43823 +40570 +155 +40591 +34402 +31098 +14330 +33650 +41890 +1961 +826 +2 +259 +18334 +41890 +33278 +43486 +41890 +41890 +43824 +17675 +21669 +345 +43825 +1109 +41890 +43826 +43827 +14961 +43828 +43829 +43830 +31293 +35624 +31833 +43 +17898 +10946 +41890 +21947 +43831 +16618 +43832 +910 +43833 +43834 +9011 +13528 +43835 +345 +43836 +40439 +43837 +303 +34402 +4897 +303 +43838 +43839 +1051 +1853 +36268 +10946 +18045 +43840 +21947 +32 +29126 +41919 +43841 +9696 +43 +43842 +41890 +41890 +36218 +43843 +30224 +43844 +43845 +15 +43846 +27669 +43847 +43 +41890 +43848 +41890 +2971 +43849 +41890 +349 +42000 +41890 +36054 +41890 +41890 +41890 +43850 +1356 +342 +13482 +29483 +43851 +9 +823 +26361 +554 +5188 +43852 +41890 +41919 +41890 +590 +37888 +41890 +40570 +11683 +43853 +43854 +17670 +21947 +41890 +25624 +35025 +34181 +15766 +41890 +43855 +34 +19 +41890 +43856 +41890 +43857 +21027 +5409 +3994 +155 +4144 +43858 +16 +28845 +11754 +43859 +43860 +41890 +40570 +6165 +29483 +6766 +4108 +43861 +349 +43862 +576 +43863 +37556 +41890 +41890 +41890 +41890 +43 +41890 +15718 +43864 +5904 +342 +15158 +43865 +43866 +9 +43867 +33650 +27157 +41890 +155 +14369 +16437 +29381 +1011 +41890 +41890 +22620 +43868 +41890 +29483 +40570 +4055 +43869 +6400 +34402 +373 +41890 +41890 +43870 +27848 +43871 +40570 +43872 +41890 +41890 +155 +1100 +43873 +43874 +41890 +16466 +21669 +43875 +323 +43876 +43 +4683 +41890 +41890 +2164 +41890 +249 +910 +43877 +37790 +40570 +19 +349 +155 +43878 +43879 +26404 +19 +1385 +155 +15718 +43880 +29483 +41890 +5085 +31041 +590 +41890 +43881 +22065 +46 +41890 +43882 +23603 +41890 +43883 +19655 +43884 +4439 +43885 +43886 +43887 +40570 +43888 +41890 +43889 +36131 +43890 +41890 +14240 +1245 +41890 +1051 +43891 +43892 +43893 +417 +20308 +41890 +24896 +41890 +188 +29483 +43894 +43895 +43896 +1870 +3944 +43108 +155 +6439 +29628 +41890 +41890 +38 +21027 +33445 +19618 +155 +43897 +43347 +43898 +554 +23815 +41890 +19 +43899 +41890 +17151 +707 +43900 +43901 +43902 +1502 +18846 +43903 +43904 +28549 +43905 +115 +43906 +98 +3317 +1406 +37556 +40570 +1168 +16205 +43907 +42252 +43908 +41890 +533 +2919 +43909 +590 +13390 +43910 +41890 +41890 +43911 +26361 +41890 +19847 +89 +43912 +17911 +1364 +19 +43913 +43914 +3601 +13390 +46 +43915 +39709 +43916 +41890 +31168 +43917 +43918 +28317 +809 +57 +25943 +43919 +1453 +29381 +1011 +9 +43920 +1847 +354 +41890 +41890 +43921 +41890 +40570 +19206 +140 +2197 +43922 +5045 +16277 +43923 +19 +14962 +43924 +41919 +32646 +43362 +43925 +16413 +822 +4124 +19 +43926 +41890 +19 +1562 +2129 +25088 +41890 +10031 +43927 +2919 +43928 +43929 +41890 +10946 +33650 +41890 +176 +43550 +29204 +41890 +43930 +43931 +43932 +43933 +43934 +19 +41890 +155 +39588 +41890 +43935 +9 +41890 +9 +19582 +15824 +43936 +43937 +43938 +14477 +41890 +43939 +41890 +1502 +13228 +1172 +37556 +43940 +41919 +19 +43941 +43942 +730 +43 +43943 +1382 +20215 +28317 +25237 +6496 +43944 +40570 +43 +43945 +43946 +13721 +43947 +4288 +43948 +43949 +43950 +595 +6096 +41890 +41890 +42624 +43951 +41890 +554 +43952 +28845 +3432 +5188 +43338 +40570 +43953 +34402 +43954 +1090 +590 +958 +43955 +43956 +34903 +43957 +43958 +7658 +41890 +43959 +43960 +43961 +8685 +21973 +14477 +43962 +2787 +43963 +1615 +43964 +8668 +39709 +3601 +40570 +887 +24725 +41890 +3908 +43965 +31293 +4 +43 +315 +28845 +42483 +29381 +528 +15 +9497 +43966 +43967 +14660 +43968 +41890 +46 +43969 +43970 +1082 +4550 +24864 +41890 +554 +24864 +34402 +613 +16991 +41890 +40570 +20 +17151 +43971 +398 +25237 +1112 +40570 +1870 +31293 +590 +43972 +43973 +3491 +25973 +20677 +22804 +34402 +41890 +7522 +11751 +597 +43974 +40903 +2287 +31873 +19 +19655 +7379 +43975 +41890 +19 +14947 +19995 +43976 +5949 +15718 +37556 +40570 +185 +89 +43977 +24303 +43978 +2998 +43 +12553 +736 +23103 +12013 +43979 +42067 +4941 +41890 +20677 +30224 +43980 +1310 +1716 +14330 +43981 +43982 +29977 +31293 +34444 +18804 +29200 +43983 +2136 +41890 +2944 +41890 +736 +40591 +41890 +15718 +30224 +41890 +155 +41890 +41890 +43984 +41890 +21947 +43108 +43985 +736 +41890 +33627 +178 +41890 +5970 +43986 +43987 +15629 +41890 +43988 +540 +29483 +19 +43989 +43 +43990 +16437 +24324 +41890 +41890 +43991 +7053 +30972 +28845 +4301 +14887 +6272 +66 +43550 +43992 +28845 +29483 +43993 +358 +34 +4055 +7407 +41890 +179 +13405 +43994 +41919 +43995 +43996 +25 +43997 +43998 +43999 +31293 +28845 +44000 +377 +40570 +15 +44001 +44002 +2181 +37556 +2591 +4055 +44003 +41890 +24324 +41890 +44004 +13959 +22290 +41890 +41890 +17257 +677 +1680 +44005 +19 +5409 +40498 +1364 +22 +44006 +590 +4413 +44007 +28845 +44008 +29483 +2694 +44009 +20700 +41890 +43 +19 +44010 +28845 +41890 +44011 +44012 +46 +44013 +44014 +2770 +41890 +41687 +14527 +1820 +29387 +155 +41890 +554 +13390 +14504 +15461 +41890 +14869 +44015 +44016 +19579 +41890 +41890 +2728 +1605 +44017 +590 +4055 +40570 +1090 +43 +44018 +2577 +44019 +41919 +823 +44020 +44021 +1090 +2314 +41890 +6121 +21972 +40027 +155 +4174 +4055 +33141 +44022 +44023 +153 +43 +44024 +30224 +32696 +44025 +28772 +44026 +12875 +7379 +6480 +44027 +43550 +398 +44028 +28845 +12560 +14330 +10727 +12588 +44029 +33061 +28845 +44030 +11762 +590 +10614 +44031 +41890 +10946 +44032 +2029 +554 +44033 +24195 +20700 +41890 +44034 +44035 +44036 +44037 +9 +155 +9 +495 +44038 +34264 +30224 +40591 +20105 +3655 +46 +44039 +44040 +21947 +41919 +20304 +44041 +44042 +43442 +44043 +58 +12067 +1745 +104 +44044 +41890 +2804 +21947 +30224 +44045 +41890 +44046 +16 +155 +8357 +19020 +21669 +40570 +41890 +14369 +31150 +827 +44047 +44048 +41890 +44049 +44050 +495 +44051 +1021 +44052 +28845 +6612 +42000 +44053 +41890 +155 +40591 +6058 +44054 +8226 +25 +439 +12987 +41890 +44055 +41890 +228 +25624 +41890 +44056 +4055 +44057 +67 +41890 +7208 +44058 +10961 +43 +44059 +41890 +41890 +13897 +31168 +44060 +44061 +41890 +44062 +41890 +44063 +44064 +43990 +44065 +38033 +25237 +4364 +3844 +38235 +43 +10642 +1384 +44066 +21669 +2762 +44067 +44068 +19 +4426 +28295 +1688 +44069 +279 +751 +44070 +44071 +354 +25237 +5601 +44072 +33650 +38113 +42421 +37556 +140 +41890 +586 +41890 +44073 +24303 +44074 +13570 +5085 +44075 +1870 +44076 +41890 +44077 +1716 +4124 +1961 +44078 +30051 +19 +44079 +44080 +6726 +2577 +197 +41890 +44081 +9 +44082 +44083 +41890 +41890 +18327 +44084 +43 +721 +10147 +44085 +44086 +32 +44087 +13154 +2724 +44088 +10407 +955 +41890 +17143 +19 +41890 +1684 +35498 +44089 +286 +43 +44090 +41890 +590 +18742 +40570 +32 +274 +44091 +19 +44092 +9 +44093 +44094 +44095 +41890 +274 +22 +345 +44096 +590 +41890 +31293 +6728 +44097 +21947 +1011 +286 +40570 +41890 +34402 +44098 +44099 +40570 +42483 +1172 +44100 +44101 +44102 +155 +19 +44103 +35260 +44104 +44105 +9674 +41890 +14404 +30724 +42406 +13721 +40570 +29204 +25237 +2043 +20374 +13539 +41890 +44106 +17 +29381 +21947 +41890 +44107 +9 +28845 +1779 +44108 +44109 +44110 +41687 +41890 +44111 +590 +613 +43 +31293 +41890 +25237 +30580 +44112 +44113 +13390 +20941 +43347 +41890 +13721 +41890 +66 +44114 +20339 +34025 +44115 +37556 +41890 +35832 +39911 +44116 +24864 +41890 +9 +3050 +41890 +25316 +2009 +44117 +44118 +40658 +22512 +104 +15 +41890 +40570 +446 +44119 +34402 +44120 +14369 +44121 +6251 +44122 +3553 +1189 +44123 +34402 +2314 +44124 +915 +39536 +44125 +10946 +4 +44126 +41890 +19398 +43651 +10313 +46 +41890 +15104 +19618 +1817 +44127 +44128 +57 +40570 +21669 +13390 +703 +20 +24324 +44129 +57 +590 +42416 +41890 +15914 +30224 +44130 +44131 +2999 +31852 +44132 +23814 +44133 +590 +349 +9163 +209 +887 +44134 +795 +44135 +3546 +155 +1224 +44136 +44137 +1364 +4547 +317 +399 +14477 +40570 +1090 +5085 +41890 +44138 +44139 +149 +24410 +44140 +2764 +13390 +30224 +44141 +44142 +44143 +14013 +21947 +16 +16413 +14342 +31293 +44144 +9 +44145 +44146 +44147 +15718 +20443 +57 +44148 +43 +2029 +44149 +21947 +9 +44150 +20600 +44151 +44152 +34402 +1508 +29483 +21947 +29381 +44153 +17320 +1011 +590 +23150 +377 +155 +1090 +33650 +44154 +1562 +595 +40570 +44155 +24324 +44156 +590 +24454 +24664 +176 +44157 +665 +44158 +11647 +872 +8721 +1743 +590 +41890 +41890 +736 +44159 +44160 +989 +2253 +19618 +41890 +44161 +44162 +2488 +671 +10 +44163 +16437 +17911 +12214 +590 +4387 +43550 +31293 +60 +44164 +3323 +21947 +155 +41919 +590 +44165 +1508 +44166 +25237 +155 +44167 +44168 +1956 +13390 +44169 +41890 +823 +20 +41890 +44170 +43 +44171 +14 +19576 +770 +44172 +21947 +1716 +44173 +44174 +44175 +32 +44176 +3417 +44177 +6095 +4403 +185 +14369 +590 +41890 +9922 +1648 +44178 +5925 +358 +16024 +552 +41890 +44179 +44180 +352 +28845 +43550 +5990 +2410 +44181 +18982 +349 +44182 +845 +1013 +25140 +41890 +44183 +44184 +4 +21227 +2410 +44185 +15718 +1716 +44186 +44187 +44188 +11263 +44189 +41890 +10482 +44190 +44191 +155 +40591 +27719 +41890 +1710 +44192 +44193 +43 +44194 +41890 +13721 +10946 +14947 +541 +6218 +41728 +20 +44195 +44196 +44197 +416 +44198 +41890 +44199 +25316 +43365 +31873 +4293 +46 +24102 +16437 +44200 +41890 +29628 +142 +44201 +40570 +24058 +44202 +29483 +44203 +14869 +44204 +41890 +44205 +44206 +40996 +590 +44207 +40570 +44208 +41890 +2649 +5662 +155 +46 +140 +44209 +43005 +19451 +43 +44210 +910 +44211 +44212 +2804 +15 +42421 +28845 +9435 +1606 +9 +25316 +44213 +18176 +44214 +28480 +44215 +821 +5865 +9 +44216 +5627 +138 +14477 +21947 +35318 +20823 +363 +37556 +44217 +40570 +9 +707 +3422 +9 +39295 +44218 +66 +44219 +28845 +44220 +22124 +21947 +6847 +19 +44221 +44222 +44223 +1090 +18711 +44224 +155 +40570 +179 +44225 +44226 +12 +15993 +44227 +44228 +590 +22 +4965 +44229 +44230 +44231 +44232 +44233 +590 +5169 +21947 +12000 +44234 +23103 +665 +44235 +44236 +41890 +44237 +29007 +1559 +1051 +6207 +2476 +44238 +1090 +2260 +7553 +12321 +44239 +44240 +41890 +16437 +44241 +18798 +44242 +43550 +3844 +40570 +41075 +283 +7896 +1991 +44243 +9682 +115 +19 +44244 +44245 +2728 +887 +1889 +3484 +44246 +44247 +44248 +44249 +44250 +44251 +15 +44252 +31293 +44253 +11192 +19 +576 +44254 +25943 +44255 +44256 +14477 +44257 +40570 +590 +46 +317 +13150 +44258 +1786 +17635 +30224 +25555 +19794 +44259 +44260 +44261 +44262 +44263 +77 +44264 +9 +2672 +44265 +44266 +38461 +44267 +15997 +44268 +2591 +28549 +44269 +14660 +40012 +3626 +44270 +31098 +40570 +15989 +1090 +40570 +41434 +31293 +915 +44271 +44272 +554 +44273 +155 +19 +3291 +44274 +44275 +43 +44276 +44277 +36736 +44278 +42746 +44279 +8826 +9967 +41660 +44280 +861 +5803 +5601 +44281 +1090 +40570 +357 +30224 +17932 +19 +44282 +41890 +27293 +44283 +7048 +44284 +25237 +11963 +44285 +21669 +590 +44286 +44211 +484 +25237 +44287 +99 +40570 +155 +24725 +1364 +30551 +28031 +17048 +44288 +44289 +44290 +44291 +21669 +44292 +18045 +22850 +31293 +38021 +44293 +40591 +40570 +44294 +38308 +38033 +19 +28845 +155 +25 +590 +44295 +44296 +9 +44297 +27855 +44298 +43290 +44299 +25943 +40570 +27669 +44300 +228 +40570 +1090 +590 +286 +4055 +44301 +4033 +44302 +495 +14477 +44303 +12377 +16437 +42483 +28845 +8548 +345 +36735 +16281 +10960 +40570 +1090 +590 +345 +44304 +32105 +28845 +44305 +12255 +43550 +18627 +25237 +57 +827 +29483 +44306 +44307 +1295 +40570 +1090 +5780 +40570 +44308 +32 +44309 +15718 +44249 +155 +22317 +24144 +13803 +29204 +44310 +25683 +19 +823 +44311 +34602 +14369 +30051 +41890 +19167 +41890 +44312 +44313 +44314 +44315 +1991 +9 +44316 +44317 +44318 +44319 +155 +29424 +19 +3252 +44320 +259 +44321 +41890 +24303 +44322 +41890 +4432 +40570 +25584 +44323 +14852 +155 +44324 +44325 +43848 +29483 +21947 +30877 +4299 +1812 +32 +1316 +155 +22234 +8616 +89 +31400 +34337 +25683 +36218 +15 +38758 +44326 +155 +44327 +44328 +44329 +44330 +4856 +41890 +40893 +770 +155 +36268 +44331 +519 +26744 +590 +27669 +44332 +37556 +15 +44333 +41890 +44334 +1385 +40570 +41890 +44335 +286 +23585 +41890 +46 +32 +44336 +44337 +36735 +2136 +1310 +44338 +873 +2514 +29628 +21669 +44339 +44340 +89 +22065 +44341 +1559 +44342 +44343 +1247 +3343 +15498 +11472 +720 +19 +44344 +44345 +38465 +5780 +2043 +41890 +9 +14330 +8670 +44346 +25683 +22463 +44347 +15 +44348 +44349 +10117 +1514 +2410 +4693 +44350 +20514 +44351 +3484 +11762 +15 +5071 +24207 +44352 +7835 +29956 +1224 +29629 +23853 +44353 +44354 +21947 +5409 +11321 +514 +40570 +28961 +44355 +4684 +1100 +590 +18054 +12722 +44356 +18310 +446 +20781 +44357 +2694 +37556 +3328 +42483 +18310 +44358 +25943 +31293 +40570 +18453 +29628 +44359 +15718 +2865 +33295 +44360 +19 +66 +33380 +44361 +9 +415 +1559 +43 +99 +43550 +40570 +37556 +44362 +44363 +1385 +12987 +41890 +40990 +44364 +44342 +44365 +43 +42746 +46 +44366 +44367 +34402 +21689 +44368 +15 +279 +590 +23593 +18120 +14001 +9 +40570 +12151 +44369 +44370 +28845 +155 +155 +28295 +44371 +41890 +19 +15 +19837 +597 +13361 +58 +705 +44372 +44373 +41890 +34402 +31168 +415 +15718 +590 +936 +44374 +29483 +20280 +17911 +1520 +44375 +8668 +379 +40251 +44376 +34951 +33627 +44377 +9337 +23368 +3638 +33693 +34944 +9900 +16437 +590 +30224 +44378 +29483 +9 +5627 +44379 +41890 +44380 +44381 +2622 +34364 +44382 +2260 +44383 +24864 +44384 +17782 +44385 +3858 +764 +20052 +40073 +24207 +7353 +41890 +14660 +44386 +22570 +2804 +2724 +41919 +44387 +44388 +9095 +32275 +19 +77 +574 +15471 +44389 +7743 +185 +8668 +44390 +44391 +15718 +2865 +44392 +155 +44393 +13390 +31293 +20 +44394 +533 +14276 +44395 +44396 +44397 +12047 +44398 +44399 +44400 +44401 +42390 +15018 +2449 +44402 +1536 +36461 +44403 +15718 +44404 +40570 +44405 +1011 +33141 +44406 +24864 +44407 +30650 +44408 +23103 +44409 +44249 +44410 +22154 +13139 +12191 +44411 +40143 +41890 +44412 +44413 +43939 +41890 +31293 +1330 +44414 +155 +155 +33693 +44415 +44249 +38179 +41890 +2015 +44416 +19 +44417 +2832 +1720 +44418 +5769 +44419 +5409 +9662 +5780 +3317 +44420 +29400 +44421 +41890 +25584 +44422 +44423 +155 +178 +19 +339 +44424 +44425 +155 +6766 +39709 +44426 +44427 +44428 +39 +590 +6364 +37355 +44429 +44430 +40570 +30224 +1961 +44431 +736 +44432 +27798 +89 +1961 +514 +412 +3330 +31293 +5601 +44433 +8005 +44434 +21947 +590 +44435 +17507 +32410 +736 +33627 +44436 +44437 +28845 +44438 +2832 +19 +44439 +44440 +13570 +21947 +14477 +43 +155 +44441 +14017 +16074 +9 +44442 +44443 +25 +44444 +44445 +40570 +44446 +9567 +15384 +44447 +26585 +8668 +19 +44448 +44449 +21045 +42483 +42421 +155 +2601 +17 +44450 +9440 +19 +44451 +831 +40570 +17790 +40570 +16437 +12987 +28845 +44452 +44453 +44454 +495 +39783 +20113 +42962 +37556 +9 +44455 +480 +14369 +44456 +19 +19655 +677 +29483 +2314 +15824 +44457 +736 +44458 +19 +44459 +30224 +44460 +35656 +16466 +4518 +21276 +25829 +4502 +44461 +44462 +6620 +44463 +44464 +44465 +14770 +165 +44466 +19 +736 +142 +23670 +590 +554 +41567 +28845 +41919 +892 +44467 +44468 +34319 +44469 +44470 +9 +2287 +12987 +28212 +140 +40570 +24864 +44471 +44472 +701 +694 +1021 +43998 +35224 +1208 +14369 +23477 +44473 +41265 +44474 +44475 +44476 +38937 +12987 +2287 +41567 +3509 +19618 +41890 +17247 +31293 +19 +31098 +44477 +44478 +9 +4055 +286 +4055 +44479 +4463 +713 +44480 +16839 +44481 +44482 +20 +17 +6217 +10946 +11995 +24303 +44483 +44484 +21947 +1716 +44485 +21947 +1364 +4055 +14102 +790 +736 +44486 +44487 +317 +44488 +9 +17911 +155 +44489 +44490 +1901 +44491 +44492 +44493 +7313 +31293 +25983 +44494 +44495 +21089 +38465 +5085 +1561 +2410 +11621 +31293 +44496 +44497 +3759 +44358 +31168 +44498 +44328 +402 +20 +31293 +44499 +44500 +40472 +23103 +28845 +36737 +44501 +597 +42237 +44502 +44503 +44504 +43280 +4055 +44505 +7522 +40570 +28961 +25237 +349 +317 +7964 +34181 +44506 +44507 +373 +2537 +9543 +17691 +31293 +21947 +39593 +415 +5912 +197 +44508 +554 +40570 +352 +22990 +29200 +25683 +9020 +28317 +14330 +590 +44509 +377 +2009 +3874 +36735 +541 +5963 +18751 +13390 +650 +19655 +38033 +345 +44510 +37232 +1710 +37588 +19 +44511 +3598 +44512 +155 +44513 +44514 +41890 +17911 +28845 +44515 +44516 +44517 +44518 +9060 +24324 +21689 +43 +44519 +18169 +44520 +44521 +2537 +99 +44522 +44523 +703 +44524 +140 +25 +2347 +1442 +14477 +4055 +44525 +22684 +39520 +13390 +44526 +44527 +31293 +1047 +15718 +25620 +19618 +36735 +40570 +37808 +40289 +18919 +2460 +44528 +26081 +40311 +44529 +1157 +29047 +44530 +44531 +1900 +44532 +41919 +66 +14477 +44533 +44534 +15718 +44535 +39410 +345 +19 +14660 +44536 +44537 +38550 +44538 +44539 +19655 +568 +13255 +209 +44540 +1090 +44541 +43 +89 +41919 +17911 +272 +10982 +9 +24896 +44542 +16707 +2314 +9 +44543 +30209 +15718 +43 +43 +23103 +44544 +13848 +14369 +44545 +28845 +44546 +354 +40570 +14477 +31293 +262 +58 +1684 +41919 +14369 +19 +44547 +6130 +3105 +21563 +26544 +7835 +10639 +44548 +44549 +44550 +3514 +40605 +3119 +44551 +18310 +44552 +12548 +25237 +155 +41117 +19 +44553 +44554 +44555 +43 +44556 +43108 +43550 +44557 +44558 +44559 +44560 +3995 +2356 +155 +44249 +18553 +590 +21045 +3732 +43651 +44561 +24896 +24303 +29381 +44562 +44563 +44564 +2476 +26680 +44565 +44566 +43 +9 +574 +12671 +36218 +30224 +44567 +44568 +14660 +34 +14079 +44569 +284 +303 +34032 +44570 +7516 +736 +37556 +1090 +20533 +751 +44571 +44572 +40570 +44573 +38596 +40570 +44574 +9460 +19618 +284 +25316 +44575 +40570 +3353 +5660 +44576 +24303 +44176 +28036 +7455 +40570 +213 +43 +46 +44577 +44578 +44579 +284 +3759 +5188 +28845 +34703 +44580 +44581 +44582 +30041 +44583 +44584 +28845 +89 +27669 +44585 +32644 +7053 +303 +44586 +44587 +20110 +43 +32 +28845 +25237 +595 +225 +5601 +337 +41919 +286 +27754 +1011 +7516 +823 +20458 +616 +6877 +28036 +213 +19 +213 +44588 +1912 +11286 +23528 +41868 +33650 +58 +43347 +2591 +44589 +12402 +44590 +213 +284 +248 +349 +44591 +201 +213 +44592 +19 +248 +31293 +303 +337 +286 +893 +18310 +14174 +15718 +694 +29483 +379 +303 +44593 +40570 +44594 +28845 +44595 +337 +284 +44596 +44597 +29757 +44598 +411 +44599 +19947 +44600 +18045 +44601 +4002 +44602 +44603 +8683 +44604 +337 +18951 +25237 +89 +284 +30230 +33650 +44605 +44606 +44607 +44608 +248 +44609 +44610 +18934 +16798 +14216 +955 +44611 +44612 +13576 +43550 +17872 +44613 +40570 +303 +44614 +11754 +2 +29483 +337 +44249 +713 +14660 +44615 +31650 +13543 +44616 +2356 +415 +44617 +25316 +19 +213 +12397 +44618 +9367 +31293 +44619 +6595 +23103 +9 +21947 +44620 +44621 +8362 +2762 +5085 +37556 +155 +44622 +20401 +21947 +27719 +43 +142 +44623 +28845 +44624 +1443 +1090 +16166 +36019 +19 +26452 +669 +44625 +44626 +736 +44627 +1021 +17810 +25316 +44537 +44628 +1247 +9217 +25935 +44629 +317 +77 +43 +22922 +259 +44630 +248 +15718 +7835 +44631 +30224 +44632 +44633 +43 +44634 +19 +16826 +44635 +44636 +44637 +31293 +2117 +736 +43 +37556 +40570 +40570 +44638 +303 +44639 +44640 +44641 +2577 +14363 +8849 +44642 +44643 +44644 +44645 +44646 +24864 +1481 +317 +14342 +736 +8732 +44647 +44648 +44649 +44650 +105 +44651 +41890 +397 +28845 +40570 +44652 +9 +155 +154