slidge-whatsapp 0.2.2__cp313-cp313-manylinux_2_36_aarch64.whl → 0.2.5__cp313-cp313-manylinux_2_36_aarch64.whl

slidge_whatsapp/vendor/github.com/gen2brain/go-fitz/include/mupdf/fitz.h

@@ -0,0 +1,97 @@
+// Copyright (C) 2004-2021 Artifex Software, Inc.
+//
+// This file is part of MuPDF.
+//
+// MuPDF is free software: you can redistribute it and/or modify it under the
+// terms of the GNU Affero General Public License as published by the Free
+// Software Foundation, either version 3 of the License, or (at your option)
+// any later version.
+//
+// MuPDF is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+// FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
+// details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with MuPDF. If not, see <https://www.gnu.org/licenses/agpl-3.0.en.html>
+//
+// Alternative licensing terms are available from the licensor.
+// For commercial licensing, see <https://www.artifex.com/> or contact
+// Artifex Software, Inc., 39 Mesa Street, Suite 108A, San Francisco,
+// CA 94129, USA, for further information.
+
+#ifndef MUDPF_FITZ_H
+#define MUDPF_FITZ_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "mupdf/fitz/version.h"
+#include "mupdf/fitz/config.h"
+#include "mupdf/fitz/system.h"
+#include "mupdf/fitz/context.h"
+#include "mupdf/fitz/output.h"
+#include "mupdf/fitz/log.h"
+
+#include "mupdf/fitz/crypt.h"
+#include "mupdf/fitz/getopt.h"
+#include "mupdf/fitz/geometry.h"
+#include "mupdf/fitz/hash.h"
+#include "mupdf/fitz/pool.h"
+#include "mupdf/fitz/string-util.h"
+#include "mupdf/fitz/tree.h"
+#include "mupdf/fitz/bidi.h"
+#include "mupdf/fitz/xml.h"
+
+/* I/O */
+#include "mupdf/fitz/buffer.h"
+#include "mupdf/fitz/stream.h"
+#include "mupdf/fitz/compress.h"
+#include "mupdf/fitz/compressed-buffer.h"
+#include "mupdf/fitz/filter.h"
+#include "mupdf/fitz/archive.h"
+#include "mupdf/fitz/heap.h"
+
+
+/* Resources */
+#include "mupdf/fitz/store.h"
+#include "mupdf/fitz/color.h"
+#include "mupdf/fitz/pixmap.h"
+#include "mupdf/fitz/bitmap.h"
+#include "mupdf/fitz/image.h"
+#include "mupdf/fitz/shade.h"
+#include "mupdf/fitz/font.h"
+#include "mupdf/fitz/path.h"
+#include "mupdf/fitz/text.h"
+#include "mupdf/fitz/separation.h"
+#include "mupdf/fitz/glyph.h"
+
+#include "mupdf/fitz/device.h"
+#include "mupdf/fitz/display-list.h"
+#include "mupdf/fitz/structured-text.h"
+
+#include "mupdf/fitz/transition.h"
+#include "mupdf/fitz/glyph-cache.h"
+
+/* Document */
+#include "mupdf/fitz/link.h"
+#include "mupdf/fitz/outline.h"
+#include "mupdf/fitz/document.h"
+
+#include "mupdf/fitz/util.h"
+
+/* Output formats */
+#include "mupdf/fitz/writer.h"
+#include "mupdf/fitz/band-writer.h"
+#include "mupdf/fitz/write-pixmap.h"
+#include "mupdf/fitz/output-svg.h"
+
+#include "mupdf/fitz/story.h"
+#include "mupdf/fitz/story-writer.h"
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

slidge_whatsapp/vendor/github.com/gen2brain/go-fitz/include/mupdf/memento.h

@@ -0,0 +1,423 @@
+/* Copyright (C) 2009-2022 Artifex Software, Inc.
+   All Rights Reserved.
+
+   This software is provided AS-IS with no warranty, either express or
+   implied.
+
+   This software is distributed under license and may not be copied,
+   modified or distributed except as expressly authorized under the terms
+   of the license contained in the file COPYING in this distribution.
+
+   Refer to licensing information at http://www.artifex.com or contact
+   Artifex Software, Inc.,  39 Mesa Street, Suite 108A, San Francisco,
+   CA 94129, USA, for further information.
+*/
+
+/* Memento: A library to aid debugging of memory leaks/heap corruption.
+ *
+ * Usage (with C):
+ *    First, build your project with MEMENTO defined, and include this
+ *    header file wherever you use malloc, realloc or free.
+ *    This header file will use macros to point malloc, realloc and free to
+ *    point to Memento_malloc, Memento_realloc, Memento_free.
+ *
+ *    Run your program, and all mallocs/frees/reallocs should be redirected
+ *    through here. When the program exits, you will get a list of all the
+ *    leaked blocks, together with some helpful statistics. You can get the
+ *    same list of allocated blocks at any point during program execution by
+ *    calling Memento_listBlocks();
+ *
+ *    Every call to malloc/free/realloc counts as an 'allocation event'.
+ *    On each event Memento increments a counter. Every block is tagged with
+ *    the current counter on allocation. Every so often during program
+ *    execution, the heap is checked for consistency. By default this happens
+ *    after 1024 events, then after 2048 events, then after 4096 events, etc.
+ *    This can be changed at runtime by using Memento_setParanoia(int level).
+ *    0 turns off such checking, 1 sets checking to happen on every event,
+ *    any positive number n sets checking to happen once every n events,
+ *    and any negative number n sets checking to happen after -n events, then
+ *    after -2n events etc.
+ *
+ *    The default paranoia level is therefore -1024.
+ *
+ *    Memento keeps blocks around for a while after they have been freed, and
+ *    checks them as part of these heap checks to see if they have been
+ *    written to (or are freed twice etc).
+ *
+ *    A given heap block can be checked for consistency (it's 'pre' and
+ *    'post' guard blocks are checked to see if they have been written to)
+ *    by calling Memento_checkBlock(void *blockAddress);
+ *
+ *    A check of all the memory can be triggered by calling Memento_check();
+ *    (or Memento_checkAllMemory(); if you'd like it to be quieter).
+ *
+ *    A good place to breakpoint is Memento_breakpoint, as this will then
+ *    trigger your debugger if an error is detected. This is done
+ *    automatically for debug windows builds.
+ *
+ *    If a block is found to be corrupt, information will be printed to the
+ *    console, including the address of the block, the size of the block,
+ *    the type of corruption, the number of the block and the event on which
+ *    it last passed a check for correctness.
+ *
+ *    If you rerun, and call Memento_paranoidAt(int event); with this number
+ *    the code will wait until it reaches that event and then start
+ *    checking the heap after every allocation event. Assuming it is a
+ *    deterministic failure, you should then find out where in your program
+ *    the error is occurring (between event x-1 and event x).
+ *
+ *    Then you can rerun the program again, and call
+ *    Memento_breakAt(int event); and the program will call
+ *    Memento_Breakpoint() when event x is reached, enabling you to step
+ *    through.
+ *
+ *    Memento_find(address) will tell you what block (if any) the given
+ *    address is in.
+ *
+ * An example:
+ *    Suppose we have a gs invocation that crashes with memory corruption.
+ *     * Build with -DMEMENTO.
+ *     * In your debugger put a breakpoint on Memento_breakpoint.
+ *     * Run the program. It will stop in Memento_inited.
+ *     * Execute Memento_setParanoia(1);  (In VS use Ctrl-Alt-Q). (Note #1)
+ *     * Continue execution.
+ *     * It will detect the memory corruption on the next allocation event
+ *       after it happens, and stop in Memento_breakpoint. The console should
+ *       show something like:
+ *
+ *       Freed blocks:
+ *         0x172e610(size=288,num=1415) index 256 (0x172e710) onwards corrupted
+ *           Block last checked OK at allocation 1457. Now 1458.
+ *
+ *     * This means that the block became corrupted between allocation 1457
+ *       and 1458 - so if we rerun and stop the program at 1457, we can then
+ *       step through, possibly with a data breakpoint at 0x172e710 and see
+ *       when it occurs.
+ *     * So restart the program from the beginning. When we stop after
+ *       initialisation execute Memento_breakAt(1457); (and maybe
+ *       Memento_setParanoia(1), or Memento_setParanoidAt(1457))
+ *     * Continue execution until we hit Memento_breakpoint.
+ *     * Now you can step through and watch the memory corruption happen.
+ *
+ *    Note #1: Using Memento_setParanoia(1) can cause your program to run
+ *    very slowly. You may instead choose to use Memento_setParanoia(100)
+ *    (or some other figure). This will only exhaustively check memory on
+ *    every 100th allocation event. This trades speed for the size of the
+ *    average allocation event range in which detection of memory corruption
+ *    occurs. You may (for example) choose to run once checking every 100
+ *    allocations and discover that the corruption happens between events
+ *    X and X+100. You can then rerun using Memento_paranoidAt(X), and
+ *    it'll only start exhaustively checking when it reaches X.
+ *
+ * More than one memory allocator?
+ *
+ *    If you have more than one memory allocator in the system (like for
+ *    instance the ghostscript chunk allocator, that builds on top of the
+ *    standard malloc and returns chunks itself), then there are some things
+ *    to note:
+ *
+ *    * If the secondary allocator gets its underlying blocks from calling
+ *      malloc, then those will be checked by Memento, but 'subblocks' that
+ *      are returned to the secondary allocator will not. There is currently
+ *      no way to fix this other than trying to bypass the secondary
+ *      allocator. One way I have found to do this with the chunk allocator
+ *      is to tweak its idea of a 'large block' so that it puts every
+ *      allocation in its own chunk. Clearly this negates the point of having
+ *      a secondary allocator, and is therefore not recommended for general
+ *      use.
+ *
+ *    * Again, if the secondary allocator gets its underlying blocks from
+ *      calling malloc (and hence Memento) leak detection should still work
+ *      (but whole blocks will be detected rather than subblocks).
+ *
+ *    * If on every allocation attempt the secondary allocator calls into
+ *      Memento_failThisEvent(), and fails the allocation if it returns true
+ *      then more useful features can be used; firstly memory squeezing will
+ *      work, and secondly, Memento will have a "finer grained" paranoia
+ *      available to it.
+ *
+ * Usage with C++:
+ *
+ *    Memento has some experimental code in it to trap new/delete (and
+ *    new[]/delete[] if required) calls.
+ *
+ *    In all cases, Memento will provide a C API that new/delete
+ *    operators can be built upon:
+ *         void *Memento_cpp_new(size_t size);
+ *         void Memento_cpp_delete(void *pointer);
+ *         void *Memento_cpp_new_array(size_t size);
+ *         void Memento_cpp_delete_array(void *pointer);
+ *
+ *    There are various ways that actual operator definitions can be
+ *    provided:
+ *
+ *    1) If memento.c is built with the c++ compiler, then global new
+ *    and delete operators will be built in to memento by default.
+ *
+ *    2) If memento.c is built as normal with the C compiler, then
+ *    no such veneers will be built in. The caller must provide them
+ *    themselves. This can be done either by:
+ *
+ *       a) Copying the lines between:
+ *               // C++ Operator Veneers - START
+ *       and
+ *               // C++ Operator Veneers - END
+ *       from memento.c into a C++ file within their own project.
+ *
+ *    or
+ *
+ *       b) Add the following lines to a C++ file in the project:
+ *          #define MEMENTO_CPP_EXTRAS_ONLY
+ *          #include "memento.c"
+ *
+ *    3) For those people that would like to be able to compile memento.c
+ *    with a C compiler, and provide new/delete veneers globally
+ *    within their own C++ code (so avoiding the need for memento.h to
+ *    be included from every file), define MEMENTO_NO_CPLUSPLUS as you
+ *    build, and Memento will not provide any veneers itself, instead
+ *    relying on the library user to provide them.
+ *
+ *    For convenience the lines to implement such veneers can be found
+ *    at the end of memento.c between:
+ *        // C++ Operator Veneers - START
+ *    and
+ *        // C++ Operator Veneers - END
+ *
+ *    Memento's interception of new/delete can be disabled at runtime
+ *    by using Memento_setIgnoreNewDelete(1). Alternatively the
+ *    MEMENTO_IGNORENEWDELETE environment variable can be set to 1 to
+ *    achieve the same result.
+ *
+ *    Both Windows and GCC provide separate new[] and delete[] operators
+ *    for arrays. Apparently some systems do not. If this is the case for
+ *    your system, define MEMENTO_CPP_NO_ARRAY_CONSTRUCTORS.
+ *
+ * "libbacktrace.so failed to load"
+ *
+ *    In order to give nice backtraces on unix, Memento will try to use
+ *    a libbacktrace dynamic library. If it can't find it, you'll see
+ *    that warning, and your backtraces won't include file/line information.
+ *
+ *    To fix this you'll need to build your own libbacktrace. Don't worry
+ *    it's really easy:
+ *       git clone git://github.com/ianlancetaylor/libbacktrace
+ *       cd libbacktrace
+ *       ./configure --enable-shared
+ *       make
+ *
+ *    This leaves the build .so as .libs/libbacktrace.so
+ *
+ *    Memento will look for this on LD_LIBRARY_PATH, or in /opt/lib/,
+ *    or in /lib/, or  in /usr/lib/, or in /usr/local/lib/. I recommend
+ *    using /opt/lib/ as this won't conflict with anything that you
+ *    get via a package manager like apt.
+ *
+ *       sudo mkdir /opt
+ *       sudo mkdir /opt/lib
+ *       sudo cp .libs/libbacktrace.so /opt/lib/
+ */
+
+#ifdef __cplusplus
+
+// Avoids problems with strdup()'s throw() attribute on Linux.
+#include <string.h>
+
+extern "C" {
+#endif
+
+#ifndef MEMENTO_H
+
+/* Include all these first, so our definitions below do
+ * not conflict with them. */
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+
+#define MEMENTO_H
+
+#ifndef MEMENTO_UNDERLYING_MALLOC
+#define MEMENTO_UNDERLYING_MALLOC malloc
+#endif
+#ifndef MEMENTO_UNDERLYING_FREE
+#define MEMENTO_UNDERLYING_FREE free
+#endif
+#ifndef MEMENTO_UNDERLYING_REALLOC
+#define MEMENTO_UNDERLYING_REALLOC realloc
+#endif
+#ifndef MEMENTO_UNDERLYING_CALLOC
+#define MEMENTO_UNDERLYING_CALLOC calloc
+#endif
+
+#ifndef MEMENTO_MAXALIGN
+#define MEMENTO_MAXALIGN (sizeof(int))
+#endif
+
+#define MEMENTO_PREFILL   0xa6
+#define MEMENTO_POSTFILL  0xa7
+#define MEMENTO_ALLOCFILL 0xa8
+#define MEMENTO_FREEFILL  0xa9
+
+int Memento_checkBlock(void *);
+int Memento_checkAllMemory(void);
+int Memento_check(void);
+
+int Memento_setParanoia(int);
+int Memento_paranoidAt(int);
+int Memento_breakAt(int);
+void Memento_breakOnFree(void *a);
+void Memento_breakOnRealloc(void *a);
+int Memento_getBlockNum(void *);
+int Memento_find(void *a);
+void Memento_breakpoint(void);
+int Memento_failAt(int);
+int Memento_failThisEvent(void);
+void Memento_listBlocks(void);
+void Memento_listNewBlocks(void);
+void Memento_listPhasedBlocks(void);
+size_t Memento_setMax(size_t);
+void Memento_stats(void);
+void *Memento_label(void *, const char *);
+void Memento_tick(void);
+int Memento_setVerbose(int);
+
+/* Terminate backtraces if we see specified function name. E.g.
+'cfunction_call' will exclude Python interpreter functions when Python calls C
+code. Returns 0 on success, -1 on failure (out of memory). */
+int Memento_addBacktraceLimitFnname(const char *fnname);
+
+/* If <atexitfin> is 0, we do not call Memento_fin() in an atexit() handler. */
+int Memento_setAtexitFin(int atexitfin);
+
+int Memento_setIgnoreNewDelete(int ignore);
+
+void *Memento_malloc(size_t s);
+void *Memento_realloc(void *, size_t s);
+void  Memento_free(void *);
+void *Memento_calloc(size_t, size_t);
+char *Memento_strdup(const char*);
+#if !defined(MEMENTO_GS_HACKS) && !defined(MEMENTO_MUPDF_HACKS)
+int Memento_asprintf(char **ret, const char *format, ...);
+int Memento_vasprintf(char **ret, const char *format, va_list ap);
+#endif
+
+void Memento_info(void *addr);
+void Memento_listBlockInfo(void);
+void Memento_blockInfo(void *blk);
+void *Memento_takeByteRef(void *blk);
+void *Memento_dropByteRef(void *blk);
+void *Memento_takeShortRef(void *blk);
+void *Memento_dropShortRef(void *blk);
+void *Memento_takeIntRef(void *blk);
+void *Memento_dropIntRef(void *blk);
+void *Memento_takeRef(void *blk);
+void *Memento_dropRef(void *blk);
+void *Memento_adjustRef(void *blk, int adjust);
+void *Memento_reference(void *blk);
+
+int Memento_checkPointerOrNull(void *blk);
+int Memento_checkBytePointerOrNull(void *blk);
+int Memento_checkShortPointerOrNull(void *blk);
+int Memento_checkIntPointerOrNull(void *blk);
+
+void Memento_startLeaking(void);
+void Memento_stopLeaking(void);
+
+/* Returns number of allocation events so far. */
+int Memento_sequence(void);
+
+/* Returns non-zero if our process was forked by Memento squeeze. */
+int Memento_squeezing(void);
+
+void Memento_fin(void);
+
+void Memento_bt(void);
+
+void *Memento_cpp_new(size_t size);
+void Memento_cpp_delete(void *pointer);
+void *Memento_cpp_new_array(size_t size);
+void Memento_cpp_delete_array(void *pointer);
+
+void Memento_showHash(unsigned int hash);
+
+#ifdef MEMENTO
+
+#ifndef COMPILING_MEMENTO_C
+#define malloc    Memento_malloc
+#define free      Memento_free
+#define realloc   Memento_realloc
+#define calloc    Memento_calloc
+#define strdup    Memento_strdup
+#if !defined(MEMENTO_GS_HACKS) && !defined(MEMENTO_MUPDF_HACKS)
+#define asprintf  Memento_asprintf
+#define vasprintf Memento_vasprintf
+#endif
+#endif
+
+#else
+
+#define Memento_malloc    MEMENTO_UNDERLYING_MALLOC
+#define Memento_free      MEMENTO_UNDERLYING_FREE
+#define Memento_realloc   MEMENTO_UNDERLYING_REALLOC
+#define Memento_calloc    MEMENTO_UNDERLYING_CALLOC
+#define Memento_strdup    strdup
+#if !defined(MEMENTO_GS_HACKS) && !defined(MEMENTO_MUPDF_HACKS)
+#define Memento_asprintf  asprintf
+#define Memento_vasprintf vasprintf
+#endif
+
+#define Memento_checkBlock(A)              0
+#define Memento_checkAllMemory()           0
+#define Memento_check()                    0
+#define Memento_setParanoia(A)             0
+#define Memento_paranoidAt(A)              0
+#define Memento_breakAt(A)                 0
+#define Memento_breakOnFree(A)             0
+#define Memento_breakOnRealloc(A)          0
+#define Memento_getBlockNum(A)             0
+#define Memento_find(A)                    0
+#define Memento_breakpoint()               do {} while (0)
+#define Memento_failAt(A)                  0
+#define Memento_failThisEvent()            0
+#define Memento_listBlocks()               do {} while (0)
+#define Memento_listNewBlocks()            do {} while (0)
+#define Memento_listPhasedBlocks()         do {} while (0)
+#define Memento_setMax(A)                  0
+#define Memento_stats()                    do {} while (0)
+#define Memento_label(A,B)                 (A)
+#define Memento_info(A)                    do {} while (0)
+#define Memento_listBlockInfo()            do {} while (0)
+#define Memento_blockInfo(A)               do {} while (0)
+#define Memento_takeByteRef(A)             (A)
+#define Memento_dropByteRef(A)             (A)
+#define Memento_takeShortRef(A)            (A)
+#define Memento_dropShortRef(A)            (A)
+#define Memento_takeIntRef(A)              (A)
+#define Memento_dropIntRef(A)              (A)
+#define Memento_takeRef(A)                 (A)
+#define Memento_dropRef(A)                 (A)
+#define Memento_adjustRef(A,V)             (A)
+#define Memento_reference(A)               (A)
+#define Memento_checkPointerOrNull(A)      0
+#define Memento_checkBytePointerOrNull(A)  0
+#define Memento_checkShortPointerOrNull(A) 0
+#define Memento_checkIntPointerOrNull(A)   0
+#define Memento_setIgnoreNewDelete(v)      0
+
+#define Memento_tick()                     do {} while (0)
+#define Memento_startLeaking()             do {} while (0)
+#define Memento_stopLeaking()              do {} while (0)
+#define Memento_fin()                      do {} while (0)
+#define Memento_bt()                       do {} while (0)
+#define Memento_sequence()                 (0)
+#define Memento_squeezing()                (0)
+#define Memento_setVerbose(A)              (A)
+#define Memento_addBacktraceLimitFnname(A) (0)
+#define Memento_setAtexitFin(atexitfin)    (0)
+
+#endif /* MEMENTO */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* MEMENTO_H */

slidge_whatsapp/vendor/github.com/gen2brain/go-fitz/include/mupdf/vendor.go

@@ -0,0 +1,3 @@
+//go:build required
+
+package vendor

slidge_whatsapp/vendor/github.com/gen2brain/go-fitz/libs/vendor.go

@@ -0,0 +1,3 @@
+//go:build required
+
+package vendor

slidge_whatsapp/vendor/github.com/gen2brain/go-fitz/purego_darwin.go

@@ -0,0 +1,23 @@
+//go:build (!cgo || nocgo) && darwin
+
+package fitz
+
+import (
+	"fmt"
+
+	"github.com/ebitengine/purego"
+)
+
+const (
+	libname = "libmupdf.dylib"
+)
+
+// loadLibrary loads the so and panics on error.
+func loadLibrary() uintptr {
+	handle, err := purego.Dlopen(libname, purego.RTLD_NOW|purego.RTLD_GLOBAL)
+	if err != nil {
+		panic(fmt.Errorf("cannot load library: %w", err))
+	}
+
+	return uintptr(handle)
+}

slidge_whatsapp/vendor/github.com/gen2brain/go-fitz/purego_linux.go

@@ -0,0 +1,22 @@
+//go:build (!cgo || nocgo) && unix && !darwin
+
+package fitz
+
+import (
+	"fmt"
+	"github.com/ebitengine/purego"
+)
+
+const (
+	libname = "libmupdf.so"
+)
+
+// loadLibrary loads the so and panics on error.
+func loadLibrary() uintptr {
+	handle, err := purego.Dlopen(libname, purego.RTLD_NOW|purego.RTLD_GLOBAL)
+	if err != nil {
+		panic(fmt.Errorf("cannot load library: %w", err))
+	}
+
+	return handle
+}

slidge_whatsapp/vendor/github.com/gen2brain/go-fitz/purego_windows.go

@@ -0,0 +1,22 @@
+//go:build (!cgo || nocgo) && windows
+
+package fitz
+
+import (
+	"fmt"
+	"syscall"
+)
+
+const (
+	libname = "libmupdf.dll"
+)
+
+// loadLibrary loads the dll and panics on error.
+func loadLibrary() uintptr {
+	handle, err := syscall.LoadLibrary(libname)
+	if err != nil {
+		panic(fmt.Errorf("cannot load library %s: %w", libname, err))
+	}
+
+	return uintptr(handle)
+}

slidge_whatsapp/vendor/github.com/go-python/gopy/LICENSE

@@ -0,0 +1,23 @@
+Copyright ©2015 The go-python Authors. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the gonum project nor the names of its authors and
+      contributors may be used to endorse or promote products derived from this
+      software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.