Add files using upload-large-folder tool

.gitattributes

@@ -1268,3 +1268,4 @@ local-test-commons-compress-delta-03/afc-commons-compress/src/test/resources/COM
 local-test-commons-compress-delta-03/afc-commons-compress/src/test/resources/COMPRESS-477/split_zip_created_by_zip/split_zip_created_by_zip_zip64.z02 filter=lfs diff=lfs merge=lfs -text
 local-test-commons-compress-delta-03/afc-commons-compress/src/test/resources/COMPRESS-477/split_zip_created_by_zip/split_zip_created_by_zip.z01 filter=lfs diff=lfs merge=lfs -text
 local-test-zookeeper-delta-02/fuzz-tooling/infra/cifuzz/test_data/timeout_fuzzer filter=lfs diff=lfs merge=lfs -text
+local-test-tika-delta-03/afc-tika/tika-parsers/tika-parsers-standard/tika-parsers-standard-modules/tika-parser-microsoft-module/src/test/resources/test-documents/testsolidworksAssembly2014SP0.SLDASM filter=lfs diff=lfs merge=lfs -text

local-test-commons-compress-full-01-vuln_1/afc-commons-compress/src/test/resources/META-INF/services/org.apache.commons.compress.compressors.CompressorStreamProvider

@@ -0,0 +1 @@
+org.apache.commons.compress.compressors.TestCompressorStreamProvider

local-test-commons-compress-full-01-vuln_1/afc-commons-compress/src/test/resources/org/apache/commons/compress/ar/number_parsing/bad_modified-fail.ar

@@ -0,0 +1,8 @@
+!<arch>
+//                                              68        `
+this_is_a_long_file_name.txt/
+this_is_a_long_file_name_as_well.txt/
+/0              9e99999999  1000  1000  100664  14        `
+Hello, world!
+/30             1454694016  1000  1000  100664  4         `
+Bye

local-test-commons-compress-full-01-vuln_1/fuzz-tooling/docs/_sass/color_schemes/wider.scss

@@ -0,0 +1,2 @@
+@import "./color_schemes/light";
+$content-width: 70rem;

local-test-commons-compress-full-01-vuln_1/fuzz-tooling/docs/assets/css/just-the-docs-wider.scss

@@ -0,0 +1,3 @@
+---
+---
+{% include css/just-the-docs.scss.liquid color_scheme="wider" %}

local-test-commons-compress-full-01-vuln_1/fuzz-tooling/docs/further-reading/further_reading.md

@@ -0,0 +1,9 @@
+---
+layout: default
+title: Further reading
+has_children: true
+nav_order: 4
+permalink: /further-reading/
+---
+
+# Further reading

local-test-commons-compress-full-01-vuln_1/fuzz-tooling/docs/further-reading/fuzzer_environment.md

@@ -0,0 +1,77 @@
+---
+layout: default
+title: Fuzzer environment
+parent: Further reading
+nav_order: 2
+permalink: /further-reading/fuzzer-environment/
+---
+
+# Fuzzer environment on ClusterFuzz
+
+Your fuzz targets will be run on a
+[Google Compute Engine](https://cloud.google.com/compute/) VM (Linux).
+
+- TOC
+{:toc}
+---
+
+## Runtime Dependencies
+
+You should not make any assumptions on the availability of dependent packages 
+in the execution environment. Packages that are installed via
+[Dockerfile]({{ site.baseurl }}/getting-started/new-project-guide/#dockerfile)
+or built as part of 
+[build.sh]({{ site.baseurl }}/getting-started/new-project-guide/#buildsh)
+are not available on the bot runtime environment (where the fuzz targets run).
+
+If you need these dependencies in the runtime environment, you can either:
+- Install the packages via Dockerfile
+([example](https://github.com/google/oss-fuzz/blob/2d5e2ef84f281e6ab789055aa735606d3122fda9/projects/tor/Dockerfile#L19))
+and then link statically against them
+([example](https://github.com/google/oss-fuzz/blob/2d5e2ef84f281e6ab789055aa735606d3122fda9/projects/tor/build.sh#L40)).
+- Or build the dependencies statically in
+[build.sh]({{ site.baseurl }}/getting-started/new-project-guide/#buildsh)
+([example](https://github.com/google/oss-fuzz/blob/64f8b6593da141b97c98c7bc6f07df92c42ee010/projects/ffmpeg/build.sh#L26)).
+
+All build artifacts needed during fuzz target execution should be inside the
+`$OUT` directory. Only those artifacts are archived and used on the bots.
+Everything else is ignored (e.g. artifacts in `$WORK`, `$SRC`, etc) and hence
+is not available in the execution environment.
+
+We strongly recommend static linking because it just works. 
+However dynamic linking can work if shared objects are included in the `$OUT` directory and are loaded relative
+to `'$ORIGIN'`, the path of the binary (see the discussion of `'$ORIGIN'` [here](http://man7.org/linux/man-pages/man8/ld.so.8.html)).
+A fuzzer can be instructed to load libraries relative to `'$ORIGIN'` during compilation (i.e. `-Wl,-rpath,'$ORIGIN/lib'` )
+or afterwards using `chrpath -r '$ORIGIN/lib' $OUT/$fuzzerName` ([example](https://github.com/google/oss-fuzz/blob/09aa9ac556f97bd4e31928747eca0c8fed42509f/projects/php/build.sh#L40)). Note that `'$ORIGIN'` should be surrounded
+by single quotes because it is not an environment variable like `$OUT` that can be retrieved during execution of `build.sh`.
+Its value is retrieved during execution of the binary. You can verify that you did this correctly using `ldd <fuzz_target_name>` and the `check_build` command in `infra/helper.py`.
+
+You should ensure that the fuzz target works correctly by using `run_fuzzer`
+command (see instructions
+[here]({{ site.baseurl }}/getting-started/new-project-guide/#testing-locally)).
+This command uses a clean base-runner docker container and not the base-builder
+docker container created during build-time.
+
+## argv[0]
+
+You must not modify `argv[0]`. It is required for certain things to work
+correctly.
+
+## Current working directory
+
+You should not make any assumptions about the current working directory of your
+fuzz target. If you need to load data files, please use `argv[0]` to get the
+directory where your fuzz target executable is located.
+
+## File system
+
+Everything except `/tmp` is read-only, including the directory that your fuzz
+target executable lives in.
+
+`/dev` is also unavailable.
+
+## Hardware
+
+Your project should not be compiled with `-march=native` or `-mtune=native`
+flags, as the build infrastructure and fuzzing machines may have different CPUs
+as well as other hardware differences. You may however use `-mtune=generic`.

local-test-commons-compress-full-01-vuln_1/fuzz-tooling/docs/getting-started/new-project-guide/go_lang.md

@@ -0,0 +1,125 @@
+---
+layout: default
+title: Integrating a Go project
+parent: Setting up a new project
+grand_parent: Getting started
+nav_order: 1
+permalink: /getting-started/new-project-guide/go-lang/
+---
+
+# Integrating a Go project
+{: .no_toc}
+
+- TOC
+{:toc}
+---
+
+The process of integrating a project written in Go with OSS-Fuzz is very similar
+to the general
+[Setting up a new project]({{ site.baseurl }}/getting-started/new-project-guide/)
+process. The key specifics of integrating a Go project are outlined below.
+
+## Go-fuzz support
+
+OSS-Fuzz supports **go-fuzz** in the
+[libFuzzer compatible mode](https://github.com/mdempsky/go114-fuzz-build)
+only. In that mode, fuzz targets for Go use the libFuzzer engine with native Go
+coverage instrumentation. Binaries compiled in this mode provide the same
+libFuzzer command line interface as non-Go fuzz targets.
+
+## Native Go Fuzzing support
+
+OSS-fuzz supports [fuzzers written for the native Go 1.18 engine](https://go.dev/doc/fuzz/). These fuzzers are built as libFuzzer binaries in a similar fashion as fuzzers written for the go-fuzz engine. Because of that, dictionaries and seed corpora should be handled in accordance with [the OSS-fuzz documentation](https://google.github.io/oss-fuzz/getting-started/new-project-guide/#seed-corpus).
+Unlike libFuzzer/go-fuzz targets which must accept one data buffer, fuzz targets written for the Native Go engine can accept any number of arguments of any type. Here is an example of a valid fuzzer with multiple arguments:
+
+```go
+package demofuzzing
+
+import (
+    "fmt"
+    "testing"
+)
+
+func FuzzDemo(f *testing.F) {
+    f.Fuzz(func(t *testing.T, data1 string, data2 uint32, data3 float64) {
+        fmt.Println(data1)
+        fmt.Println(data2)
+        fmt.Println(data3)
+    })
+}
+```
+
+Some requirements for native Go 1.18 fuzzers are:
+* The only `testing.F` method supported is currently `F.Fuzz()`.
+* `F.Add()` will not add seeds when fuzzing. To provide OSS-fuzz with a seed corpus, follow the documentation [here](https://google.github.io/oss-fuzz/getting-started/new-project-guide/#seed-corpus).
+
+## Project files
+
+First, you need to write a Go fuzz target. This fuzz target should reside in your project
+repository
+([example](https://github.com/golang/go/blob/4ad13555184eb0697c2e92c64c1b0bdb287ccc10/src/html/fuzz.go#L13)).
+
+The structure of the project directory in OSS-Fuzz repository doesn't differ for
+projects written in Go. The project files have the following Go specific
+aspects.
+
+### project.yaml
+
+The `language` attribute must be specified.
+
+```yaml
+language: go
+```
+
+The only supported fuzzing engine and sanitizer are `libfuzzer` and `address`,
+respectively.
+[Example](https://github.com/google/oss-fuzz/blob/356f2b947670b7eb33a1f535c71bc5c87a60b0d1/projects/syzkaller/project.yaml#L7):
+
+```yaml
+fuzzing_engines:
+  - libfuzzer
+sanitizers:
+  - address
+```
+
+### Dockerfile
+
+The Dockerfile should start by `FROM gcr.io/oss-fuzz-base/base-builder-go`
+
+The OSS-Fuzz builder image has the latest stable release of Golang installed. In
+order to install dependencies of your project, add `RUN git clone ...` command to
+your Dockerfile.
+[Example](https://github.com/google/oss-fuzz/blob/356f2b947670b7eb33a1f535c71bc5c87a60b0d1/projects/syzkaller/Dockerfile#L23):
+
+```dockerfile
+# Dependency for one of the fuzz targets.
+RUN git clone --depth 1 https://github.com/ianlancetaylor/demangle
+```
+
+go-fuzz will then automatically download the dependencies based on the go.mod file
+
+### build.sh
+
+In order to build a Go fuzz target, you need to call `go-fuzz`
+command first, and then link the resulting `.a` file against
+`$LIB_FUZZING_ENGINE` using the `$CXX $CXXFLAGS ...` command.
+
+For go-fuzz fuzzers, the best way to do this is by using the [`compile_go_fuzzer` script](https://github.com/google/oss-fuzz/blob/master/infra/base-images/base-builder/compile_go_fuzzer), and for native Go 1.18 fuzzers it is recommended to use the [`compile_native_go_fuzzer` script](https://github.com/google/oss-fuzz/blob/master/infra/base-images/base-builder/compile_native_go_fuzzer). Both of these also support coverage builds.
+
+`compile_native_go_fuzzer` requires two dependencies which can be installed with:
+```bash
+go install github.com/AdamKorcz/go-118-fuzz-build@latest
+go get github.com/AdamKorcz/go-118-fuzz-build/testing
+```
+
+A usage example from go-dns project is
+
+```sh
+compile_go_fuzzer github.com/miekg/dns FuzzNewRR fuzz_newrr fuzz
+```
+
+Arguments are :
+* path of the package with the fuzz target
+* name of the fuzz function
+* name of the fuzzer to be built
+* optional tag to be used by `go build` and such

local-test-commons-compress-full-01-vuln_1/fuzz-tooling/docs/getting-started/new-project-guide/javascript_lang.md

@@ -0,0 +1,140 @@
+---
+layout: default
+title: Integrating a JavaScript project
+parent: Setting up a new project
+grand_parent: Getting started
+nav_order: 4
+permalink: /getting-started/new-project-guide/javascript-lang/
+---
+
+# Integrating a JavaScript project
+{: .no_toc}
+
+- TOC
+{:toc}
+---
+
+The process of integrating a project written in JavaScript for Node.js 
+with OSS-Fuzz is very similar to the general
+[Setting up a new project]({{ site.baseurl }}/getting-started/new-project-guide/)
+process. The key specifics of integrating a JavaScript project are outlined below.
+
+## Jazzer.js
+
+JavaScript fuzzing in OSS-Fuzz is powered by
+[Jazzer.js](https://github.com/CodeIntelligenceTesting/jazzer.js), which is
+installed during the build step. As Jazzer.js operates directly on the JavaScript
+source code level, it can be applied to any project written in a language that 
+can be transpiled into JavaScript such as TypeScript. More information on how Jazzer.js
+fuzz targets look like can be found in its
+[README's Usage section](https://github.com/CodeIntelligenceTesting/jazzer.js#usage).
+
+## Project files
+
+### Example project
+
+We recommend viewing
+[javascript-example](https://github.com/google/oss-fuzz/tree/master/projects/javascript-example)
+as an example of a simple JavaScript fuzzing project. We also recommend having a look at
+[typescript-example](https://github.com/google/oss-fuzz/tree/master/projects/typescript-example)
+as an example of how to fuzz TypeScript projects. This example also demonstrates how to use 
+Jazzer.js fuzzed data provider.
+
+### project.yaml
+
+The `language` attribute must be specified as follows:
+
+```yaml
+language: javascript
+```
+
+The only supported fuzzing engine is libFuzzer (`libfuzzer`). So far, native sanitizers such as 
+AddressSanitizer (`address`) and UndefinedBehaviorSanitizer (`undefined`) are not supported. 
+They would only be needed for projects that have native addons, which is a rather infrequent
+use case for JavaScript projects. If you have a project where you need ASan or UBSan, please 
+create open an issue on [Jazzer.js GitHub repo](https://github.com/CodeIntelligenceTesting/jazzer.js). None (`none`) is the default sanitizer for 
+JavaScript projects, so setting it up in `project.yaml` is optional.
+
+```yaml
+fuzzing_engines:
+  - libfuzzer
+sanitizers:
+  - none
+```
+
+### Dockerfile
+
+The Dockerfile should start by `FROM gcr.io/oss-fuzz-base/base-builder-javascript`
+
+The OSS-Fuzz base Docker images already come with Node.js 19 and `npm` pre-installed.
+Apart from that, you should usually not need to do more than to clone the
+project, set a `WORKDIR`, and copy any necessary files, or install any
+project-specific dependencies here as you normally would.
+
+### Fuzzers
+
+In the simplest case, every fuzzer consists of a single JavaScript file that exports
+a function named `fuzz` taking a single argument of type [Buffer](https://nodejs.org/api/buffer.html). 
+An example fuzz target could thus be a file `fuzz_string_compare.js` with contents:
+
+```javascript
+/**
+ * @param { Buffer } data
+ */
+module.exports.fuzz = function (data) {
+    const s = data.toString();
+    if (s.length !== 16) {
+        return;
+    }
+    if (
+        s.slice(0, 8) === "Awesome " &&
+        s.slice(8, 15) === "Fuzzing" &&
+        s[15] === "!"
+    ) {
+        throw Error("Welcome to Awesome Fuzzing!");
+    }
+};
+```
+
+### build.sh
+
+The OSS-Fuzz base docker image for JavaScript comes with the [`compile_javascript_fuzzer` script](https://github.com/google/oss-fuzz/blob/master/infra/base-images/base-builder/compile_javascript_fuzzer) preinstalled. In `build.sh`, you should install dependencies for your project, and if necessary compile the code into JavaScript. Then, you can use the script to build the fuzzers. The script ensures that [@Jazzer.js/core](https://www.npmjs.com/package/@jazzer.js/core) is installed so that its CLI can be used to execute your fuzz tests. It also generates a wrapper script that can be used as a drop-in replacement for libFuzzer. This means that the generated script accepts the same command line flags for libFuzzer. Under the hood these flags are simply forwarded to the libFuzzer native addon used by Jazzer.js.
+
+A usage example from the javascript-example project is
+
+```shell
+compile_javascript_fuzzer example fuzz_string_compare.js --sync
+```
+
+Arguments are:
+* relative path of the project in the $SRC directory
+* relative path to the fuzz test inside the project
+* remaining arguments are forwarded to the [Jazzer.js CLI](https://github.com/CodeIntelligenceTesting/jazzer.js/blob/main/docs/fuzz-targets.md#running-the-fuzz-target)
+
+The [javascript-example](https://github.com/google/oss-fuzz/blob/master/projects/javascript-example/build.sh)
+project contains an example of a `build.sh` for JavaScript projects.
+
+## FuzzedDataProvider
+
+Jazzer.js provides a `FuzzedDataProvider` that can simplify the task of creating a
+fuzz target by translating the raw input bytes received from the fuzzer into
+useful primitive JavaScript types. Its functionality is similar to
+`FuzzedDataProviders` available in other languages, such as
+[Java](https://codeintelligencetesting.github.io/jazzer-docs/jazzer-api/com/code_intelligence/jazzer/api/FuzzedDataProvider.html) and
+[C++](https://github.com/google/fuzzing/blob/master/docs/split-inputs.md).
+
+A fuzz target using the `FuzzedDataProvider` would look as follows:
+
+```javascript
+const { FuzzedDataProvider } = require("@jazzer.js/core");
+
+/**
+ * @param { Buffer } fuzzerInputData
+ */
+module.exports.fuzz = function (fuzzerInputData) {
+    const data = new FuzzedDataProvider(fuzzerInputData);
+    const i = data.consumeIntegral(4);
+    const s = data.consumeRemainingAsString();
+    exploreMe(i, s);
+};
+```

local-test-commons-compress-full-01-vuln_1/fuzz-tooling/docs/getting-started/new-project-guide/jvm_lang.md

@@ -0,0 +1,185 @@
+---
+layout: default
+title: Integrating a Java/JVM project
+parent: Setting up a new project
+grand_parent: Getting started
+nav_order: 4
+permalink: /getting-started/new-project-guide/jvm-lang/
+---
+
+# Integrating a Java/JVM project
+{: .no_toc}
+
+- TOC
+{:toc}
+---
+
+The process of integrating a project written in Java or any other language
+running on the Java Virtual Machine (JVM) with OSS-Fuzz is very similar to the
+general
+[Setting up a new project]({{ site.baseurl }}/getting-started/new-project-guide/)
+process. The key specifics of integrating a JVM project are outlined below.
+
+## Jazzer
+
+Java fuzzing in OSS-Fuzz depends on
+[Jazzer](https://github.com/CodeIntelligenceTesting/jazzer), which is
+pre-installed on the OSS-Fuzz base docker images. As Jazzer operates directly
+on the bytecode level, it can be applied to any project written in a JVM-based
+language. More information on how Jazzer fuzz targets look like can be found in
+its
+[README's Usage section](https://github.com/CodeIntelligenceTesting/jazzer#usage).
+
+## Project files
+
+### Example project
+
+We recommend viewing
+[json-sanitizer](https://github.com/google/oss-fuzz/tree/master/projects/json-sanitizer)
+as an example of a simple Java-only fuzzing project. Additional examples,
+including one for a Java project with native dependencies, are part of the
+[java-example](https://github.com/google/oss-fuzz/tree/master/projects/java-example)
+project.
+
+### project.yaml
+
+The `language` attribute must be specified as follows:
+
+```yaml
+language: jvm
+```
+
+The only supported fuzzing engine is libFuzzer (`libfuzzer`). So far the only
+supported sanitizers are AddressSanitizer (`address`) and
+UndefinedBehaviorSanitizer (`undefined`). For pure Java projects, specify
+just `address`:
+
+```yaml
+fuzzing_engines:
+  - libfuzzer
+sanitizers:
+  - address
+```
+
+### Dockerfile
+
+The Dockerfile should start by `FROM gcr.io/oss-fuzz-base/base-builder-jvm`
+
+The OSS-Fuzz base Docker images already come with OpenJDK 15 pre-installed. If
+you need Maven to build your project, you can install it by adding the following
+line to your Dockerfile:
+
+```docker
+RUN apt-get update && apt-get install -y maven
+```
+
+Apart from this, you should usually not need to do more than to clone the
+project, set a `WORKDIR`, and copy any necessary files, or install any
+project-specific dependencies here as you normally would.
+
+### Fuzzers
+
+In the simplest case, every fuzzer consists of a single Java file with a
+filename matching `*Fuzzer.java` and no `package` directive. An example fuzz
+target could thus be a file `ExampleFuzzer.java` with contents:
+
+```java
+public class ExampleFuzzer {
+    public static void fuzzerTestOneInput(byte[] input) {
+        ...
+        // Call a function of the project under test with arguments derived from
+        // input and throw an exception if something unwanted happens.
+        ...
+    }
+}
+```
+
+### build.sh
+
+For JVM projects, `build.sh` does need some more significant modifications
+over C/C++ projects. Below is an annotated example build script for a
+Java-only project with single-file fuzz targets as described above:
+
+```sh
+# Step 1: Build the project
+
+# Build the project .jar as usual, e.g. using Maven.
+mvn package
+# In this example, the project is built with Maven, which typically includes the
+# project version into the name of the packaged .jar file. The version can be
+# obtained as follows:
+CURRENT_VERSION=$(mvn org.apache.maven.plugins:maven-help-plugin:3.2.0:evaluate \
+-Dexpression=project.version -q -DforceStdout)
+# Copy the project .jar into $OUT under a fixed name.
+cp "target/sample-project-$CURRENT_VERSION.jar" $OUT/sample-project.jar
+
+# Specify the projects .jar file(s), separated by spaces if there are multiple.
+PROJECT_JARS="sample-project.jar"
+
+# Step 2: Build the fuzzers (should not require any changes)
+
+# The classpath at build-time includes the project jars in $OUT as well as the
+# Jazzer API.
+BUILD_CLASSPATH=$(echo $PROJECT_JARS | xargs printf -- "$OUT/%s:"):$JAZZER_API_PATH
+
+# All .jar and .class files lie in the same directory as the fuzzer at runtime.
+RUNTIME_CLASSPATH=$(echo $PROJECT_JARS | xargs printf -- "\$this_dir/%s:"):\$this_dir
+
+for fuzzer in $(find $SRC -name '*Fuzzer.java'); do
+  fuzzer_basename=$(basename -s .java $fuzzer)
+  javac -cp $BUILD_CLASSPATH $fuzzer
+  cp $SRC/$fuzzer_basename.class $OUT/
+
+  # Create an execution wrapper that executes Jazzer with the correct arguments.
+  echo "#!/bin/bash
+# LLVMFuzzerTestOneInput for fuzzer detection.
+this_dir=\$(dirname \"\$0\")
+if [[ \"\$@\" =~ (^| )-runs=[0-9]+($| ) ]]; then
+  mem_settings='-Xmx1900m:-Xss900k'
+else
+  mem_settings='-Xmx2048m:-Xss1024k'
+fi
+LD_LIBRARY_PATH=\"$JVM_LD_LIBRARY_PATH\":\$this_dir \
+\$this_dir/jazzer_driver --agent_path=\$this_dir/jazzer_agent_deploy.jar \
+--cp=$RUNTIME_CLASSPATH \
+--target_class=$fuzzer_basename \
+--jvm_args=\"\$mem_settings:-Djava.awt.headless=true\" \
+\$@" > $OUT/$fuzzer_basename
+  chmod +x $OUT/$fuzzer_basename
+done
+```
+
+The [java-example](https://github.com/google/oss-fuzz/blob/master/projects/java-example/build.sh)
+project contains an example of a `build.sh` for Java projects with native
+libraries.
+
+## FuzzedDataProvider
+
+Jazzer provides a `FuzzedDataProvider` that can simplify the task of creating a
+fuzz target by translating the raw input bytes received from the fuzzer into
+useful primitive Java types. Its functionality is similar to
+`FuzzedDataProviders` available in other languages, such as
+[Python](https://github.com/google/atheris#fuzzeddataprovider) and
+[C++](https://github.com/google/fuzzing/blob/master/docs/split-inputs.md).
+
+On OSS-Fuzz, the required library is available in the base docker images under
+the path `$JAZZER_API_PATH`, which is added to the classpath by the example
+build script shown above. Locally, the library can be obtained from
+[Maven Central](https://search.maven.org/search?q=g:com.code-intelligence%20a:jazzer-api).
+
+A fuzz target using the `FuzzedDataProvider` would look as follows:
+
+```java
+import com.code_intelligence.jazzer.api.FuzzedDataProvider;
+
+public class ExampleFuzzer {
+    public static void fuzzerTestOneInput(FuzzedDataProvider data) {
+        int number = data.consumeInt();
+        String string = data.consumeRemainingAsString();
+        // ...
+    }
+}
+```
+
+For a list of convenience methods offered by `FuzzedDataProvider`, consult its
+[javadocs](https://codeintelligencetesting.github.io/jazzer-docs/jazzer-api/com/code_intelligence/jazzer/api/FuzzedDataProvider.html).

local-test-commons-compress-full-01-vuln_1/fuzz-tooling/docs/getting-started/new-project-guide/python_lang.md

@@ -0,0 +1,137 @@
+---
+layout: default
+title: Integrating a Python project
+parent: Setting up a new project
+grand_parent: Getting started
+nav_order: 3
+permalink: /getting-started/new-project-guide/python-lang/
+---
+
+# Integrating a Python project
+{: .no_toc}
+
+- TOC
+{:toc}
+---
+
+
+The process of integrating a project written in Python with OSS-Fuzz is very
+similar to the general
+[Setting up a new project]({{ site.baseurl }}/getting-started/new-project-guide/)
+process. The key specifics of integrating a Python project are outlined below.
+
+## Atheris
+
+Python fuzzing in OSS-Fuzz depends on
+[Atheris](https://github.com/google/atheris). Fuzzers will depend on the
+`atheris` package, and dependencies are pre-installed on the OSS-Fuzz base
+docker images.
+
+## Project files
+
+### Example project
+
+We recommend viewing [ujson](https://github.com/google/oss-fuzz/tree/master/projects/ujson) as an
+example of a simple Python fuzzing project, with both plain-Atheris and
+Atheris + Hypothesis harnesses.
+
+### project.yaml
+
+The `language` attribute must be specified.
+
+```yaml
+language: python
+```
+
+The only supported fuzzing engine is libFuzzer (`libfuzzer`). The supported
+sanitizers are AddressSanitizer (`address`) and
+UndefinedBehaviorSanitizer (`undefined`). These must be explicitly specified.
+
+```yaml
+fuzzing_engines:
+  - libfuzzer
+sanitizers:
+  - address
+  - undefined
+```
+
+### Dockerfile
+
+The Dockerfile should start by `FROM gcr.io/oss-fuzz-base/base-builder-python`
+
+Because most dependencies are already pre-installed on the images, no
+significant changes are needed in the Dockerfile for Python fuzzing projects.
+You should simply clone the project, set a `WORKDIR`, and copy any necessary
+files, or install any project-specific dependencies here as you normally would.
+
+### build.sh
+
+For Python projects, `build.sh` does need some more significant modifications
+over normal projects. The following is an annotated example build script,
+explaining why each step is necessary and when they can be omitted.
+
+```sh
+# Build and install project (using current CFLAGS, CXXFLAGS). This is required
+# for projects with C extensions so that they're built with the proper flags.
+pip3 install .
+
+# Build fuzzers into $OUT. These could be detected in other ways.
+for fuzzer in $(find $SRC -name '*_fuzzer.py'); do
+  fuzzer_basename=$(basename -s .py $fuzzer)
+  fuzzer_package=${fuzzer_basename}.pkg
+
+  # To avoid issues with Python version conflicts, or changes in environment
+  # over time on the OSS-Fuzz bots, we use pyinstaller to create a standalone
+  # package. Though not necessarily required for reproducing issues, this is
+  # required to keep fuzzers working properly in OSS-Fuzz.
+  pyinstaller --distpath $OUT --onefile --name $fuzzer_package $fuzzer
+
+  # Create execution wrapper. Atheris requires that certain libraries are
+  # preloaded, so this is also done here to ensure compatibility and simplify
+  # test case reproduction. Since this helper script is what OSS-Fuzz will
+  # actually execute, it is also always required.
+  # NOTE: If you are fuzzing python-only code and do not have native C/C++
+  # extensions, then remove the LD_PRELOAD line below as preloading sanitizer
+  # library is not required and can lead to unexpected startup crashes.
+  echo "#!/bin/sh
+# LLVMFuzzerTestOneInput for fuzzer detection.
+this_dir=\$(dirname \"\$0\")
+LD_PRELOAD=\$this_dir/sanitizer_with_fuzzer.so \
+ASAN_OPTIONS=\$ASAN_OPTIONS:symbolize=1:external_symbolizer_path=\$this_dir/llvm-symbolizer:detect_leaks=0 \
+\$this_dir/$fuzzer_package \$@" > $OUT/$fuzzer_basename
+  chmod +x $OUT/$fuzzer_basename
+done
+```
+
+## Hypothesis
+
+Using [Hypothesis](https://hypothesis.readthedocs.io/), the Python library for
+[property-based testing](https://hypothesis.works/articles/what-is-property-based-testing/),
+makes it really easy to generate complex inputs - whether in traditional test suites
+or [by using test functions as fuzz harnesses](https://hypothesis.readthedocs.io/en/latest/details.html#use-with-external-fuzzers).
+
+> Property based testing is the construction of tests such that, when these tests are fuzzed,
+  failures in the test reveal problems with the system under test that could not have been
+  revealed by direct fuzzing of that system.
+
+We recommend using the [`hypothesis write`](https://hypothesis.readthedocs.io/en/latest/ghostwriter.html)
+command to generate a starter fuzz harness.  This "ghostwritten" code may be usable as-is,
+or provide a useful template for writing more specific tests.
+
+See [here for the core "strategies"](https://hypothesis.readthedocs.io/en/latest/data.html),
+for arbitrary data, [here for Numpy + Pandas support](https://hypothesis.readthedocs.io/en/latest/numpy.html),
+or [here for a variety of third-party extensions](https://hypothesis.readthedocs.io/en/latest/strategies.html)
+supporting everything from protobufs, to jsonschemas, to networkx graphs or geojson
+or valid Python source code.
+Hypothesis' integrated test-case reduction also makes it trivial to report a canonical minimal
+example for each distinct failure discovered while fuzzing - just run the test function!
+
+To use Hypothesis in OSS-Fuzz, install it in your Dockerfile with
+
+```shell
+RUN pip3 install hypothesis
+```
+
+See [the `ujson` structured fuzzer](https://github.com/google/oss-fuzz/blob/master/projects/ujson/hypothesis_structured_fuzzer.py)
+for an example "polyglot" which can either be run with `pytest` as a standard test function,
+or run with OSS-Fuzz as a fuzz harness.

local-test-commons-compress-full-01-vuln_1/fuzz-tooling/docs/getting-started/new-project-guide/rust_lang.md

@@ -0,0 +1,148 @@
+---
+layout: default
+title: Integrating a Rust project
+parent: Setting up a new project
+grand_parent: Getting started
+nav_order: 2
+permalink: /getting-started/new-project-guide/rust-lang/
+---
+
+# Integrating a Rust project
+{: .no_toc}
+
+- TOC
+{:toc}
+---
+
+The process of integrating a project written in Rust with OSS-Fuzz is very
+similar to the general [Setting up a new project]({{ site.baseurl
+}}/getting-started/new-project-guide/) process. The key specifics of integrating
+a Rust project are outlined below.
+
+## cargo-fuzz support
+
+Rust integration with OSS-Fuzz is expected to use [`cargo
+fuzz`](https://github.com/rust-fuzz/cargo-fuzz) to build fuzzers. The `cargo
+fuzz` tool will build code with required compiler flags as well as link to the
+correct libFuzzer on OSS-Fuzz itself. Note that using `cargo fuzz` also makes it
+quite easy to run the fuzzers locally yourself if you get a failing test case!
+
+## Project files
+
+First you'll want to follow the [setup instructions for `cargo fuzz`
+itself](https://rust-fuzz.github.io/book/). Afterwards your project should have:
+
+* A top-level `fuzz` directory.
+* A `fuzz/Cargo.toml` manifest which pulls in necessary dependencies to fuzz.
+* Some `fuzz/fuzz_targets/*.rs` files which are the fuzz targets that will be
+  compiled and run on OSS-Fuzz.
+
+Note that you can customize this layout as well, but you'll need to edit some
+the scripts below to integrate into OSS-Fuzz.
+
+### project.yaml
+
+The `language` attribute must be specified.
+
+```yaml
+language: rust
+```
+
+The only supported fuzzing engine and sanitizer are `libfuzzer` and `address`,
+respectively.
+[Example](https://github.com/google/oss-fuzz/blob/12ef3654b3e9adfd20b5a6afdde54819ba71493d/projects/serde_json/project.yaml#L3-L6)
+
+```yaml
+sanitizers:
+  - address
+fuzzing_engines:
+  - libfuzzer
+```
+
+### Dockerfile
+
+The Dockerfile should start by `FROM gcr.io/oss-fuzz-base/base-builder-rust`
+
+The OSS-Fuzz builder image has the latest nightly release of Rust as well as
+`cargo fuzz` pre-installed and in `PATH`. In the `Dockerfile` for your project
+all you'll need to do is fetch the latest copy of your code and install any
+system dependencies necessary to build your project.
+[Example](https://github.com/google/oss-fuzz/blob/12ef3654b3e9adfd20b5a6afdde54819ba71493d/projects/serde_json/Dockerfile#L18-L20)
+
+```dockerfile
+RUN git clone --depth 1 https://github.com/serde-rs/json json
+```
+
+### build.sh
+
+Here it's expected that you'll build the fuzz targets for your project and then
+copy the final binaries into the output directory.
+[Example](https://github.com/google/oss-fuzz/blob/12ef3654b3e9adfd20b5a6afdde54819ba71493d/projects/serde_json/build.sh#L20):
+
+```sh
+cd $SRC/json
+cargo fuzz build -O
+cp fuzz/target/x86_64-unknown-linux-gnu/release/from_slice $OUT/
+```
+
+Note that you likely want to pass the `-O` flag to `cargo fuzz build` which
+builds fuzzers in release mode. You may also want to pass the
+`--debug-assertions` flag to enable more checks while fuzzing. In this example
+the `from_slice` binary is the fuzz target.
+
+With some bash-fu you can also automatically copy over all fuzz targets into
+the output directory so when you add a fuzz target to your project it's
+automatically integrated into OSS-Fuzz:
+
+```sh
+FUZZ_TARGET_OUTPUT_DIR=target/x86_64-unknown-linux-gnu/release
+for f in fuzz/fuzz_targets/*.rs
+do
+    FUZZ_TARGET_NAME=$(basename ${f%.*})
+    cp $FUZZ_TARGET_OUTPUT_DIR/$FUZZ_TARGET_NAME $OUT/
+done
+```
+
+## Writing fuzzers using a test-style strategy
+
+In Rust you will often have tests written in a way so they are only 
+compiled into the final binary when build in test-mode. This is, achieved by
+wrapping your test code in `cfg(test)`, e.g.
+```rust
+#[cfg(test)]
+mod tests {
+    use super::*;
+    
+    ...
+```
+
+Cargo-fuzz automatically enables the `fuzzing` feature, which means you can
+follow a similar strategy to writing fuzzers as you do when writing tests.
+Specifically, you can create modules wrapped in the `fuzzing` feature:
+```rust
+#[cfg(fuzzing)]
+pub mod fuzz_logic {
+    use super::*;
+
+    ...
+```
+and then call the logic within `fuzz_logic` from your fuzzer. 
+
+Furthermore, within your `.toml` files, you can then specify fuzzing-specific
+dependencies by wrapping them as follows:
+```
+[target.'cfg(fuzzing)'.dependencies]
+```
+similar to how you wrap test-dependencies as follows:
+```
+[dev-dependencies]
+```
+
+Finally, you can also combine the testing logic you have and the fuzz logic. This
+can be achieved simply by using 
+```rust
+#[cfg(any(test, fuzzing))]
+```
+
+A project that follows this structure is Linkerd2-proxy and the project files can be
+seen [here](https://github.com/google/oss-fuzz/tree/master/projects/linkerd2-proxy).

local-test-commons-compress-full-01-vuln_1/fuzz-tooling/docs/getting-started/new-project-guide/swift_lang.md

@@ -0,0 +1,78 @@
+---
+layout: default
+title: Integrating a Swift project
+parent: Setting up a new project
+grand_parent: Getting started
+nav_order: 1
+permalink: /getting-started/new-project-guide/swift-lang/
+---
+
+# Integrating a Swift project
+{: .no_toc}
+
+- TOC
+{:toc}
+---
+
+The process of integrating a project written in Swift with OSS-Fuzz is very similar
+to the general
+[Setting up a new project]({{ site.baseurl }}/getting-started/new-project-guide/)
+process. The key specifics of integrating a Swift project are outlined below.
+
+## Project files
+
+First, you need to write a Swift fuzz target that accepts a stream of bytes and
+calls the program API with that. This fuzz target should reside in your project
+repository.
+
+The structure of the project directory in OSS-Fuzz repository doesn't differ for
+projects written in Swift. The project files have the following Swift specific
+aspects.
+
+### project.yaml
+
+The `language` attribute must be specified.
+
+```yaml
+language: swift
+```
+
+The only supported fuzzing engine is `libfuzzer`
+
+The supported sanitizers are and `address`, `thread`
+
+[Example](https://github.com/google/oss-fuzz/blob/2a15c3c88b21f4f1be2a7ff115f72bd7a08e34ac/projects/swift-nio/project.yaml#L9):
+
+```yaml
+fuzzing_engines:
+  - libfuzzer
+sanitizers:
+  - address
+  - thread
+```
+
+### Dockerfile
+
+The Dockerfile should start by `FROM gcr.io/oss-fuzz-base/base-builder-swift`
+instead of using the simple base-builder
+
+### build.sh
+
+A `precompile_swift` generates an environment variable `SWIFTFLAGS`
+This can then be used in the building command such as `swift build -c release $SWIFTFLAGS`
+
+
+A usage example from swift-protobuf project is
+
+```sh
+. precompile_swift
+# build project
+cd FuzzTesting
+swift build -c debug $SWIFTFLAGS
+
+(
+cd .build/debug/
+find . -maxdepth 1 -type f -name "*Fuzzer" -executable | while read i; do cp $i $OUT/"$i"-debug; done
+)
+
+```

local-test-commons-compress-full-01-vuln_1/fuzz-tooling/tools/vscode-extension/.eslintignore

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

local-test-commons-compress-full-01-vuln_1/fuzz-tooling/tools/vscode-extension/.vscodeignore

@@ -0,0 +1,10 @@
+.vscode/**
+.vscode-test/**
+src/**
+.gitignore
+.yarnrc
+vsc-extension-quickstart.md
+**/tsconfig.json
+**/.eslintrc.json
+**/*.map
+**/*.ts

local-test-commons-compress-full-01-vuln_1/fuzz-tooling/tools/vscode-extension/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright {yyyy} {name of copyright owner}
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

local-test-commons-compress-full-01-vuln_1/fuzz-tooling/tools/vscode-extension/README.md

@@ -0,0 +1,17 @@
+# OSS-Fuzz VSCode extension
+
+[OSS-Fuzz](https://github.com/google/oss-fuzz) is a fuzzing toolkit and service for fuzzing open source projects. This VSCode extension provides features and capabilities for interacting with the OSS-Fuzz toolkit and also to compare local changes to the OSS-Fuzz cloud database by way of [Open source fuzz introspection](https://introspector.oss-fuzz.com).
+
+## Features
+
+The VSCode extension is largely driven by commands at this point. The featues of these commands includes:
+
+- Easily setting up OSS-Fuzz
+- Templates for easily setting up a new OSS-Fuzz project
+- Building arbitrary projects from OSS-Fuzz
+- Modify a project from VSCode and test changes in OSS-Fuzz
+- Easily extract code coverage of fuzzers, including local-only fuzzers
+- Compare local code coverage to what is currently achieved by OSS-Fuzz
+- Auto-generation of fuzzer templates
+
+For a full list of commands and their features, please check the commands page.

local-test-tika-delta-03/afc-tika/tika-parsers/tika-parsers-standard/tika-parsers-standard-modules/tika-parser-microsoft-module/src/test/resources/test-documents/testsolidworksAssembly2014SP0.SLDASM

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7548a39fc1f1320664138a5124fb8ff9783005f664257c6b42bad4f75b4721c4
+size 238080