react-native-quick-crypto 1.0.19 → 1.1.0

package/deps/simdutf/scripts/compile_many_variations.sh

@@ -0,0 +1,64 @@
+#!/bin/sh
+#
+# this script can be used by developers to compile for multiple
+# variations efficiently without exhausting the machine for ram or
+# cpu. it uses GNU make and it's builtin jobserver support, so might
+# not work on other platforms than linux.
+#
+# stand in the git root and execute the script.
+# then build with:
+#   make -j$(nproc) -C build/multibuild/ all
+# test with:
+# make -j$(nproc) -C build/multibuild/ testall
+
+set -eu
+
+builddirbase=build/multibuild
+mkdir -p $builddirbase
+
+makefile=$builddirbase/Makefile
+echo "#autogenerated by $0 at $(date --rfc-3339=s), do not edit" >$makefile
+echo ".PHONY: all">>$makefile
+
+echo ".PHONY: testall">>$makefile
+echo "testall:">>$makefile
+
+compilers="g++-12 g++-13 g++-14 clang++-19"
+standards="11 14 17 20 23"
+buildtypes="Release Debug"
+
+for compiler in $compilers; do
+    if ! which $compiler >/dev/null; then
+	continue
+    fi
+    compilerbin=/usr/lib/ccache/$compiler
+    if [ ! -x $compilerbin ]; then
+	compilerbin=$compiler
+    fi
+    for buildtype in $buildtypes; do
+	for standard in $standards; do
+	    relbuilddir=$compiler-c++$standard-$buildtype
+	    builddir=$builddirbase/$relbuilddir
+	    if [ ! -d $builddir ]; then
+		cmake -B $builddir -S . \
+		      -DCMAKE_CXX_COMPILER=$compilerbin \
+		      -DSIMDUTF_CXX_STANDARD=$standard \
+		      -DCMAKE_BUILD_TYPE=$buildtype \
+		      -DCMAKE_COMPILE_WARNING_AS_ERROR=On \
+		      -DCMAKE_EXPORT_COMPILE_COMMANDS=On \
+		      -DSIMDUTF_FAST_TESTS=On \
+		      -DBUILD_SHARED_LIBS=On
+	    fi
+	    
+	    echo "all: $relbuilddir/done" >> $makefile
+	    echo ".PHONY: $relbuilddir/done" >> $makefile
+	    echo "$relbuilddir/done:" >>  $makefile
+	    echo "\t\$(MAKE) -C $relbuilddir && touch $relbuilddir/done" >> $makefile
+
+	    echo "testall: $relbuilddir/tested" >> $makefile
+	    echo ".PHONY: $relbuilddir/tested" >> $makefile
+	    echo "$relbuilddir/tested:" >>  $makefile
+	    echo "\t\$(MAKE) -C $relbuilddir test && touch $relbuilddir/tested" >> $makefile
+	done
+    done
+done

package/deps/simdutf/scripts/create_latex_table.py

@@ -0,0 +1,62 @@
+#!/usr/bin/env python3
+import sys
+import re
+import argparse
+
+# Construct an argument parser
+all_args = argparse.ArgumentParser()
+
+# Add arguments to the parser
+all_args.add_argument("-f", "--file", required=True,
+   help="file name")
+args = vars(all_args.parse_args())
+
+filename = args['file']
+with open(filename) as f:
+    content = f.readlines()
+table = []
+currentrow = {}
+
+datasets = set()
+codecs = set()
+
+for line in content:
+
+    if line.startswith("convert"):
+        m = re.search(r"\+(\w+)",line)
+        if m is not None:
+            codec = m.group(1)
+            currentrow["codec"] = codec
+            codecs.add(codec)
+        m = re.search(r"/(\w+)[\.-]",line)
+        if m is not None:
+            rfile = m.group(1)
+            currentrow["dataset"] = rfile
+            datasets.add(rfile)
+    m = re.search(r"\s([\.0-9]+) Gc/s",line)
+    if m:
+        v = float(m.group(1))
+        currentrow["result"] = '{:#.2g}'.format(v)
+        table.append(currentrow)
+        currentrow = {}
+
+favorite_kernels = ["icu", "llvm", "hoehrmann",  "cppcon2018", "u8u16", "utf8sse4", "utf8lut", "haswell", "arm64"]
+kernels = []
+s = "  "
+for k in favorite_kernels:
+    if k in codecs:
+        kernels.append(k)
+        s += " & " + k
+s += " \\\\"
+print(s)
+def get(d, k):
+    for x in table:
+        if(x['codec'] == k) and (x['dataset'] == d):
+            return x["result"]
+datasetsorted=sorted(datasets)
+for dataset in datasetsorted:
+    s = dataset
+    for k in kernels:
+      s +=  " & " + get(dataset, k)
+    s += " \\\\"
+    print(s)

package/deps/simdutf/scripts/docker/Dockerfile

@@ -0,0 +1,14 @@
+FROM ubuntu:24.04
+ARG CLANGVERSION=18
+COPY llvm.gpg /etc/apt/trusted.gpg.d/llvm.gpg
+RUN apt-get update && \
+    apt-get dist-upgrade -y && \
+    apt-get install -y --no-install-recommends ca-certificates && \
+    echo "deb [signed-by=/etc/apt/trusted.gpg.d/llvm.gpg] https://apt.llvm.org/noble/ llvm-toolchain-noble-"${CLANGVERSION}" main" \
+    > /etc/apt/sources.list.d/llvm${CLANGVERSION}.list && \
+    apt-get update && \
+    apt-get install -y --no-install-recommends clang-format-$CLANGVERSION && \
+    apt-get install -y --no-install-recommends git && \
+    apt-get -q clean -y && \
+    rm -rf /var/lib/apt/lists/* && \
+    rm -f /var/cache/apt/*.bin

package/deps/simdutf/scripts/docker/Makefile

@@ -0,0 +1,9 @@
+# ideally I would like to upload this to the simdutf package registry but
+# I think my privs need to be higher for that to work.
+
+# clang format 18
+.PHONY: build-18 publish-18
+build-18:
+	docker build --build-arg CLANGVERSION=18 --tag ghcr.io/pauldreik/clang-format-18:latest .
+publish-18: build-18
+	docker push ghcr.io/pauldreik/clang-format-18:latest

package/deps/simdutf/scripts/docker/README.md

@@ -0,0 +1,30 @@
+# Formatting
+
+This directory contains a dockerfile to build an image
+suitable for clang format.
+
+These are the instructions for building and publishing the image.
+
+## Get an access token
+Follow the instructions on https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/managing-your-personal-access-tokens
+
+The end result is a string with the token, which you use in the next step.
+
+## Build the docker image
+
+In this example, the docker image will be uploaded to namespace "pauldreik".
+
+    docker build --build-arg CLANGVERSION=18 --tag ghcr.io/pauldreik/clang-format-18:latest .
+
+## Publish the docker image
+
+In this example, the docker image will be uploaded to namespace "pauldreik" by user "pauldreik".
+
+    export CR_PAT=xxxxx # token from above
+    echo $CR_PAT | docker login ghcr.io -u pauldreik --password-stdin
+    docker push ghcr.io/pauldreik/clang-format-18:latest
+
+## Setting the rights
+
+Go to the packages page in the github UI and modify the rights from private to public
+on the clang-format-18 image.

package/deps/simdutf/scripts/ppc64_convert_utf16_to_utf8.py

@@ -0,0 +1,155 @@
+#!/usr/bin/env python3
+"""
+Script is used to produce file `ppc64_utf16_to_utf8_tables.h`, that
+contains lookup tables used in UTF-16 -> UTF-8 translation. Lookup
+tables provide shuffle pattern for packing words into 1, 2, or 3-byte
+UTF-8 characters.
+"""
+
+import sys
+from os.path import normpath
+from pathlib import Path
+from contextlib import redirect_stdout
+
+
+def format_array(array):
+    result = []
+    for value in array:
+        if value < 0 or value == 0x80:
+            result.append('0x80')
+        else:
+            result.append(str(value))
+
+    return ', '.join(result)
+
+
+def assure_array_length(array, size, value=0x80):
+    while len(array) < size:
+        array.append(value)
+
+
+LE = True
+BE = False
+
+
+def shuffle_for_conversion_1_2_3_utf8_bytes(endianness):
+    # There are two 8-bit bitmask telling how many bytes each word produces (1, 2 or 3).
+    # mask1 = ddccbbaa -- output exactly one byte (d - MSB, a - LSB)
+    # mask2 = hhggffee -- output one or two bytes
+
+    # Please note that each bit is duplicated. In final form these bits are interleaved:
+    # mask  = (mask1 & 0x5555) | (mask2 & 0xaaaa)
+    #       = hdgcfbea
+
+    # Each two-bit subword decides how many bytes will be copied from a 32-bit word of register:
+    # | e | a | ea |
+    # +---+---+----+-------
+    # | 0 | 0 |  0 |  3 bytes
+    # | 0 | 1 |  1 |  -- such combination will never come from C++ code, it has no sense
+    # | 1 | 0 |  2 |  2 bytes
+    # | 1 | 1 |  3 |  1 byte
+
+    # unlike SSE, the PPC64 shuffle reads from **two** 16-byte vectors
+    if endianness == BE:
+        byte0_3bytes = 1
+        byte1_3bytes = 0
+        byte2_3bytes = 16 + 0
+
+        byte0_2bytes = 0
+        byte1_2bytes = 16 + 0
+
+        byte0_1byte = 16 + 1
+    else:
+        byte0_3bytes = 0
+        byte1_3bytes = 1
+        byte2_3bytes = 16 + 1
+
+        byte0_2bytes = 1
+        byte1_2bytes = 16 + 1
+
+        byte0_1byte = 16 + 0
+
+    for mask in range(256):
+        empty = 0x80
+        shuffle = []
+        for i in range(4):
+            subword = mask & 0b11
+            mask >>= 2
+
+            if subword == 0:
+                shuffle.append(i*2 + byte0_3bytes)
+                shuffle.append(i*2 + byte1_3bytes)
+                shuffle.append(i*2 + byte2_3bytes)
+            elif subword == 3:
+                shuffle.append(i*2 + byte0_1byte)
+            elif subword == 2:
+                shuffle.append(i*2 + byte0_2bytes)
+                shuffle.append(i*2 + byte1_2bytes)
+
+        output_bytes = len(shuffle)
+        assure_array_length(shuffle, 16, empty)
+
+        yield (shuffle, output_bytes)
+
+
+CPP_HEADER = """// Code generated automatically; DO NOT EDIT
+// file generated by scripts/ppc64_convert_utf16_to_utf8.py
+#ifndef PPC64_SIMDUTF_UTF16_TO_UTF8_TABLES_H
+#define PPC64_SIMDUTF_UTF16_TO_UTF8_TABLES_H
+
+namespace simdutf {
+namespace {
+namespace tables {
+namespace ppc64_utf16_to_utf8 {
+"""
+
+CPP_FOOTER = """} // ppc64_utf16_to_utf8 namespace
+} // tables namespace
+} // unnamed namespace
+} // namespace simdutf
+
+#endif // PPC64_SIMDUTF_UTF16_TO_UTF8_TABLES_H"""
+
+
+def lookup_3_byte_utf8_for_perm():
+    byte0_3bytes = 1
+    byte1_3bytes = 0
+    byte2_3bytes = 16 + 0
+
+    tmp = []
+    for i in range(8):
+        tmp.append(2*i + byte0_3bytes)
+        tmp.append(2*i + byte1_3bytes)
+        tmp.append(2*i + byte2_3bytes)
+
+    print("lo =", tmp[:16])
+    print("hi =", tmp[16:])
+
+
+def main():
+    name = 'ppc64_utf16_to_utf8_tables.h'
+    path = normpath(Path(__file__).parent / '..' / 'src' / 'ppc64' / name)
+    print(f"creating {path}")
+    with open(path, 'wt') as f:
+        with redirect_stdout(f):
+            print(CPP_HEADER)
+
+            print("#if SIMDUTF_IS_BIG_ENDIAN")
+            print("// 1 byte for length, 16 bytes for mask")
+            print("const uint8_t pack_1_2_3_utf8_bytes[256][17] = {")
+            for shuffle, size in shuffle_for_conversion_1_2_3_utf8_bytes(BE):
+                print("  {%s}," % format_array([size] + shuffle))
+            print("};")
+            print("#else")
+            print("// 1 byte for length, 16 bytes for mask")
+            print("const uint8_t pack_1_2_3_utf8_bytes[256][17] = {")
+            for shuffle, size in shuffle_for_conversion_1_2_3_utf8_bytes(LE):
+                print("  {%s}," % format_array([size] + shuffle))
+            print("};")
+            print("#endif // SIMDUTF_IS_BIG_ENDIAN")
+
+            print(CPP_FOOTER)
+
+
+if __name__ == '__main__':
+    main()

package/deps/simdutf/scripts/prepare_doxygen.sh

@@ -0,0 +1,21 @@
+#!/bin/sh
+set -e
+
+PACKAGE_URL="https://github.com/jothepro/doxygen-awesome-css.git"
+PACKAGE_VERSION="v2.1.0"
+
+BASE_DIR=$(pwd)
+THEME_DIR="$BASE_DIR/theme"
+WORKSPACE=$(mktemp -d 2> /dev/null || mktemp -d -t 'tmp')
+cleanup () {
+  EXIT_CODE=$?
+  [ -d "$WORKSPACE" ] && rm -rf "$WORKSPACE"
+  exit $EXIT_CODE
+}
+
+trap cleanup INT TERM EXIT
+
+cd "$WORKSPACE"
+git clone --depth=1 --branch "$PACKAGE_VERSION" "$PACKAGE_URL" theme
+rm -rf "$THEME_DIR"
+mv "$WORKSPACE/theme" "$BASE_DIR"

package/deps/simdutf/scripts/release.py

@@ -0,0 +1,197 @@
+#!/usr/bin/env python3
+########################################################################
+# Generates a new release.
+########################################################################
+import sys
+import re
+import subprocess
+import io
+import os
+import fileinput
+if sys.version_info < (3, 0):
+    sys.stdout.write("Sorry, requires Python 3.x or better\n")
+    sys.exit(1)
+
+def colored(r, g, b, text):
+    return "\033[38;2;{};{};{}m{} \033[38;2;255;255;255m".format(r, g, b, text)
+
+def extractnumbers(s):
+    return tuple(map(int,re.findall(r"(\d+)\.(\d+)\.(\d+)",str(s))[0]))
+
+def toversionstring(major, minor, rev):
+    return str(major)+"."+str(minor)+"."+str(rev)
+
+def topaddedversionstring(major, minor, rev):
+    return str(major)+str(minor).zfill(3)+str(rev).zfill(3)
+print("Calling git rev-parse --abbrev-ref HEAD")
+pipe = subprocess.Popen(["git", "rev-parse", "--abbrev-ref", "HEAD"], stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+branchresult = pipe.communicate()[0].decode().strip()
+
+if(branchresult != "master"):
+    print(colored(255, 0, 0, "We recommend that you release on master, you are on '"+branchresult+"'"))
+
+ret = subprocess.call(["git", "remote", "update"])
+
+if(ret != 0):
+    sys.exit(ret)
+print("Calling git log HEAD.. --oneline")
+pipe = subprocess.Popen(["git", "log", "HEAD..", "--oneline"], stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+uptodateresult = pipe.communicate()[0].decode().strip()
+
+if(len(uptodateresult) != 0):
+    print(uptodateresult)
+    sys.exit(-1)
+
+pipe = subprocess.Popen(["git", "rev-parse", "--show-toplevel"], stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+maindir = pipe.communicate()[0].decode().strip()
+scriptlocation = os.path.dirname(os.path.abspath(__file__))
+
+print("repository: "+maindir)
+
+pipe = subprocess.Popen(["git", "describe", "--abbrev=0", "--tags"], stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+versionresult = pipe.communicate()[0].decode().strip()
+
+print("last version: "+versionresult )
+try:
+  currentv = extractnumbers(versionresult)
+except:
+  currentv = [0,0,0]
+if(len(sys.argv) != 2):
+    nextv = (currentv[0],currentv[1], currentv[2]+1)
+    print ("please specify version number, e.g. "+toversionstring(*nextv))
+    sys.exit(-1)
+try:
+    newversion = extractnumbers(sys.argv[1])
+    print(newversion)
+except:
+    print("can't parse version number "+sys.argv[1])
+    sys.exit(-1)
+
+print("checking that new version is valid")
+if(newversion[0] !=  currentv[0]):
+    assert newversion[0] >=  currentv[0]
+    assert newversion[1] == 0
+    assert newversion[2] == 0
+elif (newversion[1] !=  currentv[1]):
+    assert newversion[1] >=  currentv[1]
+    assert newversion[2] == 0
+else :
+    assert newversion[2] >=  currentv[2]
+
+atleastminor= (currentv[0] != newversion[0]) or (currentv[1] != newversion[1])
+
+
+versionfilerel = os.sep + "include" + os.sep + "simdutf" + os.sep + "simdutf_version.h"
+versionfile = maindir + versionfilerel
+
+with open(versionfile, 'w') as file:
+    file.write("// /include/simdutf/simdutf_version.h automatically generated by release.py,\n")
+    file.write("// do not change by hand\n")
+    file.write("#ifndef SIMDUTF_SIMDUTF_VERSION_H\n")
+    file.write("#define SIMDUTF_SIMDUTF_VERSION_H\n")
+    file.write("\n")
+    file.write("/** The version of simdutf being used (major.minor.revision) */\n")
+    file.write("#define SIMDUTF_VERSION \""+toversionstring(*newversion)+"\"\n")
+    file.write("\n")
+    file.write("namespace simdutf {\n")
+    file.write("enum {\n")
+    file.write("  /**\n")
+    file.write("   * The major version (MAJOR.minor.revision) of simdutf being used.\n")
+    file.write("   */\n")
+    file.write("  SIMDUTF_VERSION_MAJOR = "+str(newversion[0])+",\n")
+    file.write("  /**\n")
+    file.write("   * The minor version (major.MINOR.revision) of simdutf being used.\n")
+    file.write("   */\n")
+    file.write("  SIMDUTF_VERSION_MINOR = "+str(newversion[1])+",\n")
+    file.write("  /**\n")
+    file.write("   * The revision (major.minor.REVISION) of simdutf being used.\n")
+    file.write("   */\n")
+    file.write("  SIMDUTF_VERSION_REVISION = "+str(newversion[2])+"\n")
+    file.write("};\n")
+    file.write("} // namespace simdutf\n")
+    file.write("\n")
+    file.write("#endif // SIMDUTF_SIMDUTF_VERSION_H\n")
+
+print(versionfile + " modified")
+
+newmajorversionstring = str(newversion[0])
+mewminorversionstring = str(newversion[1])
+newrevversionstring = str(newversion[2])
+newversionstring = str(newversion[0]) + "." + str(newversion[1]) + "." + str(newversion[2])
+cmakefile = maindir + os.sep + "CMakeLists.txt"
+sonumber = None
+pattern = re.compile(r"""set\(SIMDUTF_LIB_SOVERSION "(\d+)" CACHE STRING "simdutf library soversion"\)""")
+with open (cmakefile, 'rt') as myfile:
+    for line in myfile:
+        m = pattern.search(line)
+        if m is not None:
+            sonumber = int(m.group(1))
+            break
+print("so library number "+str(sonumber))
+
+if(atleastminor):
+    print("Given that we have a minor revision, it seems necessary to bump the so library number")
+    if sonumber is None:
+        print("I cannot find the so library number in the CMakeLists.txt file")
+        sys.exit(-1)
+    sonumber += 1
+
+for line in fileinput.input(cmakefile, inplace=True, backup='.bak'):
+    line = re.sub(r'  VERSION \d+\.\d+\.\d+','  VERSION '+newmajorversionstring+'.'+mewminorversionstring+'.'+newrevversionstring, line.rstrip())
+    line = re.sub(r'SIMDUTF_LIB_VERSION "\d+\.\d+\.\d+','SIMDUTF_LIB_VERSION "'+str(sonumber)+".0.0", line)
+    line = re.sub(r'set\(SIMDUTF_LIB_SOVERSION "\d+"','set(SIMDUTF_LIB_SOVERSION \"'+str(sonumber)+'\"', line)
+    print(line)
+
+print("modified "+cmakefile+", a backup was made")
+
+
+doxyfile = maindir + os.sep + "Doxyfile"
+for line in fileinput.input(doxyfile, inplace=True, backup='.bak'):
+    line = re.sub(r'PROJECT_NUMBER         = "\d+\.\d+\.\d+','PROJECT_NUMBER         = "'+newversionstring, line.rstrip())
+    print(line)
+print("modified "+doxyfile+", a backup was made")
+
+
+print("running amalgamate.py")
+cp = subprocess.run(["python3", maindir+ os.sep + "singleheader/amalgamate.py"], stdout=subprocess.DEVNULL)  # doesn't capture output
+
+if(cp.returncode != 0):
+    print("Failed to run amalgamate")
+
+print("running doxygen")
+cp = subprocess.run(["doxygen"], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, cwd=maindir)  # doesn't capture output
+
+if(cp.returncode != 0):
+    print("Failed to run doxygen")
+
+
+readmefile = maindir + os.sep + "README.md"
+
+
+for line in fileinput.input(readmefile, inplace=True, backup='.bak'):
+    line = re.sub(r'   wget https://github.com/simdutf/simdutf/releases/download/v\d+\.\d+\.\d+/singleheader.zip','   wget https://github.com/simdutf/simdutf/releases/download/v'+newmajorversionstring+'.'+mewminorversionstring+'.'+newrevversionstring+'/singleheader.zip', line.rstrip())
+    line = re.sub(r'https://github.com/simdutf/simdutf/releases/download/v\d+\.\d+\.\d+/singleheader.zip','https://github.com/simdutf/simdutf/releases/download/v'+newmajorversionstring+'.'+mewminorversionstring+'.'+newrevversionstring+'/singleheader.zip', line.rstrip())
+    print(line)
+
+print("modified "+readmefile+", a backup was made")
+
+pattern = re.compile(r"https://simdutf.org/api/(\d+\.\d+\.\d+)/index.html")
+readmedata = open(readmefile).read()
+m = pattern.search(readmedata)
+if m == None:
+    print('I cannot find a link to the API documentation in your README')
+else:
+    if m is not None:
+        detectedreadme = m.group(1)
+        print("found a link to your API documentation in the README file: "+detectedreadme+" ("+toversionstring(*newversion)+")")
+        if(atleastminor):
+            if(detectedreadme != toversionstring(*newversion)):
+                print(colored(255, 0, 0, "Consider updating the readme link to "+toversionstring(*newversion)))
+
+
+
+print("Please run the tests before issuing a release. \n")
+print("to issue release, enter \n git commit -a && git push  &&  git tag -a v"+toversionstring(*newversion)+" -m \"version "+toversionstring(*newversion)+"\" &&  git push --tags \n")
+
+
+

package/deps/simdutf/scripts/shortinputplots.py

@@ -0,0 +1,97 @@
+# !/usr/bin/env python3
+# You may need to install matplotlib:
+# pip install matplotlib
+# Or use uv: 
+# uv run --with=matplotlib scripts/shortinputplots.py
+
+#
+# This script reads the output file generated by the shortbench benchmark
+# and generates plots for each function showing total time and time per unit
+# against input size.
+#
+# Usage:
+# 1. Run the shortbench benchmark to generate output.txt in the benchmarks directory:
+#    mybuilddirector/benchmarks/shortbench --all > output.txt
+# 2. Execute this script: python scripts/shortinputplots.py output.txt
+#
+
+import matplotlib.pyplot as plt
+import sys
+
+def parse_output_file(filename):
+    functions = {}
+    with open(filename, 'r') as f:
+        lines = f.readlines()
+    
+    i = 0
+    while i < len(lines):
+        line = lines[i].strip()
+        if line.startswith('# Benchmarking'):
+            # Extract function name
+            parts = line.split()
+            func_name = parts[2]  # e.g., validate_ascii
+            functions[func_name] = {'sizes': [], 'times': [], 'time_per_units': []}
+            i += 1
+            # Skip the next lines until the table header
+            while i < len(lines) and not lines[i].strip().startswith('Size'):
+                i += 1
+            if i < len(lines):
+                i += 1  # Skip the header
+                i += 1  # Skip the dashes
+                # Now read data lines
+                while i < len(lines) and lines[i].strip() and not lines[i].strip().startswith('#'):
+                    data_line = lines[i].strip()
+                    if data_line:
+                        parts = data_line.split()
+                        if len(parts) >= 3:
+                            size = int(parts[0])
+                            time = float(parts[1])
+                            time_per_unit = float(parts[2])
+                            functions[func_name]['sizes'].append(size)
+                            functions[func_name]['times'].append(time)
+                            functions[func_name]['time_per_units'].append(time_per_unit)
+                    i += 1
+        else:
+            i += 1
+    return functions
+
+def generate_plots(functions):
+    for func_name, data in functions.items():
+        sizes = data['sizes']
+        times = data['times']
+        time_per_units = data['time_per_units']
+        
+        fig, ax1 = plt.subplots(figsize=(10, 6))
+        
+        # Plot total time
+        ax1.plot(sizes, times, marker='o', linestyle='-', color='blue', label='Total Time')
+        ax1.set_xlabel('Size (bytes)')
+        ax1.set_ylabel('Total Time (ns)', color='blue')
+        ax1.tick_params(axis='y', labelcolor='blue')
+        ax1.set_ylim(bottom=0)
+        ax1.grid(True)
+        
+        # Create second y-axis for time per unit
+        ax2 = ax1.twinx()
+        ax2.plot(sizes, time_per_units, marker='x', linestyle='--', color='red', label='Time per Unit')
+        ax2.set_ylabel('Time per Byte (ns)', color='red')
+        ax2.tick_params(axis='y', labelcolor='red')
+        ax2.set_ylim(bottom=0)
+        
+        plt.title(f'{func_name} - Total Time and Time per Unit vs Size')
+        
+        # Add legends
+        lines1, labels1 = ax1.get_legend_handles_labels()
+        lines2, labels2 = ax2.get_legend_handles_labels()
+        ax1.legend(lines1 + lines2, labels1 + labels2, loc='upper left')
+        
+        plt.savefig(f'{func_name}.png')
+        plt.close()
+
+if __name__ == '__main__':
+    if len(sys.argv) != 2:
+        print("Usage: python scripts/shortinputplots.py <output_file>")
+        sys.exit(1)
+    filename = sys.argv[1]
+    functions = parse_output_file(filename)
+    generate_plots(functions)