react-native-quick-crypto 1.0.19 → 1.1.0

package/deps/simdutf/benchmarks/competition/u8u16/lib/stdint.h

@@ -0,0 +1,222 @@
+// ISO C9x  compliant stdint.h for Microsoft Visual Studio
+// Based on ISO/IEC 9899:TC2 Committee draft (May 6, 2005) WG14/N1124 
+// 
+//  Copyright (c) 2006 Alexander Chemeris
+// 
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+// 
+//   1. Redistributions of source code must retain the above copyright notice,
+//      this list of conditions and the following disclaimer.
+// 
+//   2. 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.
+// 
+//   3. The name of the author may be used to endorse or promote products
+//      derived from this software without specific prior written permission.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
+// 
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef _MSC_VER // [
+#error "Use this header only with Microsoft Visual C++ compilers!"
+#endif // _MSC_VER ]
+
+#ifndef _MSC_STDINT_H_ // [
+#define _MSC_STDINT_H_
+
+#if _MSC_VER > 1000
+#pragma once
+#endif
+
+#include <limits.h>
+
+// For Visual Studio 6 in C++ mode wrap <wchar.h> include with 'extern "C++" {}'
+// or compiler give many errors like this:
+//   error C2733: second C linkage of overloaded function 'wmemchr' not allowed
+#if (_MSC_VER < 1300) && defined(__cplusplus)
+   extern "C++" {
+#endif 
+#     include <wchar.h>
+#if (_MSC_VER < 1300) && defined(__cplusplus)
+   }
+#endif
+
+// 7.18.1 Integer types
+
+// 7.18.1.1 Exact-width integer types
+typedef __int8            int8_t;
+typedef __int16           int16_t;
+typedef __int32           int32_t;
+typedef __int64           int64_t;
+typedef unsigned __int8   uint8_t;
+typedef unsigned __int16  uint16_t;
+typedef unsigned __int32  uint32_t;
+typedef unsigned __int64  uint64_t;
+
+// 7.18.1.2 Minimum-width integer types
+typedef int8_t    int_least8_t;
+typedef int16_t   int_least16_t;
+typedef int32_t   int_least32_t;
+typedef int64_t   int_least64_t;
+typedef uint8_t   uint_least8_t;
+typedef uint16_t  uint_least16_t;
+typedef uint32_t  uint_least32_t;
+typedef uint64_t  uint_least64_t;
+
+// 7.18.1.3 Fastest minimum-width integer types
+typedef int8_t    int_fast8_t;
+typedef int16_t   int_fast16_t;
+typedef int32_t   int_fast32_t;
+typedef int64_t   int_fast64_t;
+typedef uint8_t   uint_fast8_t;
+typedef uint16_t  uint_fast16_t;
+typedef uint32_t  uint_fast32_t;
+typedef uint64_t  uint_fast64_t;
+
+// 7.18.1.4 Integer types capable of holding object pointers
+#ifdef _WIN64 // [
+   typedef __int64           intptr_t;
+   typedef unsigned __int64  uintptr_t;
+#else // _WIN64 ][
+   typedef int               intptr_t;
+   typedef unsigned int      uintptr_t;
+#endif // _WIN64 ]
+
+// 7.18.1.5 Greatest-width integer types
+typedef int64_t   intmax_t;
+typedef uint64_t  uintmax_t;
+
+
+// 7.18.2 Limits of specified-width integer types
+
+#if !defined(__cplusplus) || defined(__STDC_LIMIT_MACROS) // [   See footnote 220 at page 257 and footnote 221 at page 259
+
+// 7.18.2.1 Limits of exact-width integer types
+#define INT8_MIN     ((int8_t)_I8_MIN)
+#define INT8_MAX     _I8_MAX
+#define INT16_MIN    ((int16_t)_I16_MIN)
+#define INT16_MAX    _I16_MAX
+#define INT32_MIN    ((int32_t)_I32_MIN)
+#define INT32_MAX    _I32_MAX
+#define INT64_MIN    ((int64_t)_I64_MIN)
+#define INT64_MAX    _I64_MAX
+#define UINT8_MAX    _UI8_MAX
+#define UINT16_MAX   _UI16_MAX
+#define UINT32_MAX   _UI32_MAX
+#define UINT64_MAX   _UI64_MAX
+
+// 7.18.2.2 Limits of minimum-width integer types
+#define INT_LEAST8_MIN    INT8_MIN
+#define INT_LEAST8_MAX    INT8_MAX
+#define INT_LEAST16_MIN   INT16_MIN
+#define INT_LEAST16_MAX   INT16_MAX
+#define INT_LEAST32_MIN   INT32_MIN
+#define INT_LEAST32_MAX   INT32_MAX
+#define INT_LEAST64_MIN   INT64_MIN
+#define INT_LEAST64_MAX   INT64_MAX
+#define UINT_LEAST8_MAX   UINT8_MAX
+#define UINT_LEAST16_MAX  UINT16_MAX
+#define UINT_LEAST32_MAX  UINT32_MAX
+#define UINT_LEAST64_MAX  UINT64_MAX
+
+// 7.18.2.3 Limits of fastest minimum-width integer types
+#define INT_FAST8_MIN    INT8_MIN
+#define INT_FAST8_MAX    INT8_MAX
+#define INT_FAST16_MIN   INT16_MIN
+#define INT_FAST16_MAX   INT16_MAX
+#define INT_FAST32_MIN   INT32_MIN
+#define INT_FAST32_MAX   INT32_MAX
+#define INT_FAST64_MIN   INT64_MIN
+#define INT_FAST64_MAX   INT64_MAX
+#define UINT_FAST8_MAX   UINT8_MAX
+#define UINT_FAST16_MAX  UINT16_MAX
+#define UINT_FAST32_MAX  UINT32_MAX
+#define UINT_FAST64_MAX  UINT64_MAX
+
+// 7.18.2.4 Limits of integer types capable of holding object pointers
+#ifdef _WIN64 // [
+#  define INTPTR_MIN   INT64_MIN
+#  define INTPTR_MAX   INT64_MAX
+#  define UINTPTR_MAX  UINT64_MAX
+#else // _WIN64 ][
+#  define INTPTR_MIN   INT32_MIN
+#  define INTPTR_MAX   INT32_MAX
+#  define UINTPTR_MAX  UINT32_MAX
+#endif // _WIN64 ]
+
+// 7.18.2.5 Limits of greatest-width integer types
+#define INTMAX_MIN   INT64_MIN
+#define INTMAX_MAX   INT64_MAX
+#define UINTMAX_MAX  UINT64_MAX
+
+// 7.18.3 Limits of other integer types
+
+#ifdef _WIN64 // [
+#  define PTRDIFF_MIN  _I64_MIN
+#  define PTRDIFF_MAX  _I64_MAX
+#else  // _WIN64 ][
+#  define PTRDIFF_MIN  _I32_MIN
+#  define PTRDIFF_MAX  _I32_MAX
+#endif  // _WIN64 ]
+
+#define SIG_ATOMIC_MIN  INT_MIN
+#define SIG_ATOMIC_MAX  INT_MAX
+
+#ifndef SIZE_MAX // [
+#  ifdef _WIN64 // [
+#     define SIZE_MAX  _UI64_MAX
+#  else // _WIN64 ][
+#     define SIZE_MAX  _UI32_MAX
+#  endif // _WIN64 ]
+#endif // SIZE_MAX ]
+
+// WCHAR_MIN and WCHAR_MAX are also defined in <wchar.h>
+#ifndef WCHAR_MIN // [
+#  define WCHAR_MIN  0
+#endif  // WCHAR_MIN ]
+#ifndef WCHAR_MAX // [
+#  define WCHAR_MAX  _UI16_MAX
+#endif  // WCHAR_MAX ]
+
+#define WINT_MIN  0
+#define WINT_MAX  _UI16_MAX
+
+#endif // __STDC_LIMIT_MACROS ]
+
+
+// 7.18.4 Limits of other integer types
+
+#if !defined(__cplusplus) || defined(__STDC_CONSTANT_MACROS) // [   See footnote 224 at page 260
+
+// 7.18.4.1 Macros for minimum-width integer constants
+
+#define INT8_C(val)  val##i8
+#define INT16_C(val) val##i16
+#define INT32_C(val) val##i32
+#define INT64_C(val) val##i64
+
+#define UINT8_C(val)  val##ui8
+#define UINT16_C(val) val##ui16
+#define UINT32_C(val) val##ui32
+#define UINT64_C(val) val##ui64
+
+// 7.18.4.2 Macros for greatest-width integer constants
+#define INTMAX_C   INT64_C
+#define UINTMAX_C  UINT64_C
+
+#endif // __STDC_CONSTANT_MACROS ]
+
+
+#endif // _MSC_STDINT_H_ ]

package/deps/simdutf/benchmarks/competition/u8u16/libu8u16_BE.c

@@ -0,0 +1,4 @@
+#include <stdio.h>
+#include <stdlib.h> 
+#include "config/p4_config.h"
+#include "src/libu8u16.c"

package/deps/simdutf/benchmarks/competition/u8u16/libu8u16_LE.c

@@ -0,0 +1,5 @@
+#define UTF16_LE
+#include <stdio.h>
+#include <stdlib.h> 
+#include "config/p4_config.h"
+#include "src/libu8u16.c"

package/deps/simdutf/benchmarks/competition/u8u16/proto/u8u16.py

@@ -0,0 +1,390 @@
+#!/usr/bin/python
+
+# u8u16.py
+#
+# Python prototype implementation
+# Robert D. Cameron
+# revised August 5, 2009 - use generated UTF-8 definitions
+#
+#
+#
+#----------------------------------------------------------------------------
+# 
+# We use python's unlimited precision integers for unbounded bit streams.
+# This permits simple logical operations on the entire stream.
+# Assumption: bitstreams are little-endian (e.g., as on x86).
+#
+#----------------------------------------------------------------------------
+# 
+
+# Utility functions for demo purposes.  Slowwwww, but simple.
+
+
+#
+def readfile(filename):
+	f = open(filename)
+	contents = f.read()
+	f.close()
+	return contents
+
+
+def count_leading_zeroes(strm):
+	zeroes = 0
+	while (strm & 0xFFFFFFFF) == 0: 
+		zeroes += 32
+		strm >>= 32
+	while (strm & 1) == 0:
+		zeroes += 1
+		strm >>= 1
+	return zeroes
+	
+#
+def transpose_streams(s):
+	
+	b = []
+	
+	mask = 128
+	index = 0
+	while index < 8:
+		current = 0
+		cursor = 1
+		for c in s:
+			
+			if isinstance(c,str):
+				val = ord(c)
+			else:
+				val = c
+			if  (val & mask != 0):
+				current += cursor
+			cursor <<= 1
+			
+		index+=1
+		mask>>=1
+		b.append(current)
+	return b
+
+def inverse_transpose(bitset, len):
+	bytestream=""
+	cursor = 1
+	for i in range(0, len):
+		byteval = 0
+	       	for j in range(0,8):
+       			if bitset[j] & cursor != 0:
+       				byteval += 128 >> j
+	       	bytestream += chr(byteval)
+		cursor += cursor
+	return bytestream
+			
+def filter_bytes(bytestream, delmask):
+	newstream=""
+	cursor = 1
+	for c in bytestream:
+		if delmask & cursor == 0:
+			newstream += c
+		cursor += cursor
+	return newstream
+			
+def merge_bytes(stream1, stream2):
+	s = ""
+	for i in range(len(stream1)):
+		s += stream1[i]
+		s += stream2[i]
+	return s
+
+def bitstream2string(stream, lgth):
+	str = ""
+	for i in range(lgth):
+		if stream & 1 == 1: str += '1'
+		else: str += '_'
+		stream >>= 1
+	return str
+#
+# Advance all cursors by one position.
+def Advance(stream):
+	return stream + stream
+
+def ShiftBack(stream):
+	return stream >> 1
+
+
+def u8_streams(u8bit):
+	u8 = {}
+	u8['unibyte'] = ~u8bit[0]
+	u8['prefix'] = u8bit[0] & u8bit[1]
+	u8['suffix'] = u8bit[0] & ~u8bit[1]
+	u8prefix3or4 = u8['prefix'] & u8bit[2]
+	u8['prefix2'] = u8['prefix'] & ~u8bit[2]
+	u8['prefix3'] = u8prefix3or4 & ~u8bit[3]
+	u8['prefix4'] = u8prefix3or4 & u8bit[3]
+	u8['scope22'] = Advance(u8['prefix2'])
+	u8['scope32'] = Advance(u8['prefix3'])
+	u8['scope42'] = Advance(u8['prefix4'])
+	u8['scope33'] = Advance(u8['scope32'])
+	u8['scope43'] = Advance(u8['scope42'])
+	u8['scope44'] = Advance(u8['scope43'])
+	
+	u8lastscope = u8['scope22'] | u8['scope33'] | u8['scope44']
+	u8anyscope = u8lastscope | u8['scope32'] | u8['scope42'] | u8['scope43']
+	
+	# C0-C1 are illegal
+	error_mask = u8['prefix2'] &~ (u8bit[3] | u8bit[4] | u8bit[5] | u8bit[6]) 
+	
+	prefix_E0ED = u8['prefix3'] &~ ((u8bit[6] | (u8bit[4] ^ u8bit[7])) | (u8bit[4] ^ u8bit[5]))
+	E0ED_constraint = Advance(u8bit[5]) ^ u8bit[2]
+	error_mask |= Advance(prefix_E0ED) &~ E0ED_constraint
+	
+	prefix_F5FF = u8['prefix4'] & (u8bit[4] | (u8bit[5] & (u8bit[6] | u8bit[7])))
+	error_mask |= prefix_F5FF
+
+	prefix_F0F4 = u8['prefix4'] &~ (u8bit[4] | u8bit[6] | u8bit[7])
+	F0F4_constraint = Advance(u8bit[5]) ^ (u8bit[2] | u8bit[3])
+	error_mask |= Advance(prefix_F0F4) &~ F0F4_constraint
+	
+	error_mask |= u8anyscope ^ u8['suffix']
+	u8['error'] = error_mask
+	return u8
+
+
+#
+# Generated version using chardeflist2py(DefinitionSet['UTF8'])
+#
+def u8_streams_generated(bit):  
+  unibyte = (~bit[0]);
+  prefix = (bit[0] & bit[1]);
+  prefix2 = (prefix &~ bit[2]);
+  temp1 = (bit[2] &~ bit[3]);
+  prefix3 = (prefix & temp1);
+  temp2 = (bit[2] & bit[3]);
+  prefix4 = (prefix & temp2);
+  suffix = (bit[0] &~ bit[1]);
+  temp3 = (bit[2] | bit[3]);
+  temp4 = (prefix &~ temp3);
+  temp5 = (bit[4] | bit[5]);
+  temp6 = (temp5 | bit[6]);
+  temp7 = (temp4 &~ temp6);
+  temp8 = (bit[6] | bit[7]);
+  temp9 = (bit[5] & temp8);
+  temp10 = (bit[4] | temp9);
+  temp11 = (prefix4 & temp10);
+  badprefix = (temp7 | temp11);
+  temp12 = (temp5 | temp8);
+  xE0 = (prefix3 &~ temp12);
+  temp13 = (bit[4] & bit[5]);
+  temp14 = (bit[7] &~ bit[6]);
+  temp15 = (temp13 & temp14);
+  xED = (prefix3 & temp15);
+  xF0 = (prefix4 &~ temp12);
+  temp16 = (bit[5] &~ bit[4]);
+  temp17 = (temp16 &~ temp8);
+  xF4 = (prefix4 & temp17);
+  xA0_xBF = (suffix & bit[2]);
+  x80_x9F = (suffix &~ bit[2]);
+  x90_xBF = (suffix & temp3);
+  x80_x8F = (suffix &~ temp3);
+
+#
+# End of generated code
+  u8 = {}
+  u8['unibyte'] = unibyte
+  u8['prefix'] = prefix
+  u8['suffix'] = suffix
+  u8['prefix2'] = prefix2
+  u8['prefix3'] = prefix3
+  u8['prefix4'] = prefix4
+  u8['scope22'] = Advance(u8['prefix2'])
+  u8['scope32'] = Advance(u8['prefix3'])
+  u8['scope42'] = Advance(u8['prefix4'])
+  u8['scope33'] = Advance(u8['scope32'])
+  u8['scope43'] = Advance(u8['scope42'])
+  u8['scope44'] = Advance(u8['scope43'])
+	
+  u8lastscope = u8['scope22'] | u8['scope33'] | u8['scope44']
+  u8anyscope = u8lastscope | u8['scope32'] | u8['scope42'] | u8['scope43']
+	
+  # C0-C1 and F5-FF are illegal
+  error_mask = badprefix
+	
+  error_mask |= Advance(xE0) & x80_x9F
+  error_mask |= Advance(xED) & xA0_xBF
+  error_mask |= Advance(xF0) & x80_x8F
+  error_mask |= Advance(xF4) & x90_xBF
+	
+  error_mask |= u8anyscope ^ u8['suffix']
+  u8['error'] = error_mask
+  return u8
+
+
+#
+# The following calculation of UTF-16 bit streams is consistent
+# with the original u8u16, calculating streams at u8scope42 and
+# u8scope44 positions.
+#
+
+def u16_streams(u8, u8bit):
+	u16hi = [0,0,0,0,0,0,0,0]
+	u16lo = [0,0,0,0,0,0,0,0]
+	
+	u8lastscope = u8['scope22'] | u8['scope33'] | u8['scope44']
+	u8lastbyte = u8['unibyte'] | u8lastscope
+	u16lo[2] = u8lastbyte & u8bit[2]
+	u16lo[3] = u8lastbyte & u8bit[3]
+	u16lo[4] = u8lastbyte & u8bit[4]
+	u16lo[5] = u8lastbyte & u8bit[5]
+	u16lo[6] = u8lastbyte & u8bit[6]
+	u16lo[7] = u8lastbyte & u8bit[7]
+	u16lo[1] = (u8['unibyte'] & u8bit[1]) | (u8lastscope & Advance(u8bit[7]))
+	u16lo[0] = u8lastscope & Advance(u8bit[6])
+	
+	u16hi[5] = u8lastscope & Advance(u8bit[3])
+	u16hi[6] = u8lastscope & Advance(u8bit[4])
+	u16hi[7] = u8lastscope & Advance(u8bit[5])
+	u16hi[0] = u8['scope33'] & Advance(Advance(u8bit[4]))
+	u16hi[1] = u8['scope33'] & Advance(Advance(u8bit[5]))
+	u16hi[2] = u8['scope33'] & Advance(Advance(u8bit[6]))
+	u16hi[3] = u8['scope33'] & Advance(Advance(u8bit[7]))
+	u16hi[4] = u8['scope33'] & Advance(u8bit[2])
+
+	u8surrogate = u8['scope42'] | u8['scope44']
+	u16hi[0] = u16hi[0] | u8surrogate	
+	u16hi[1] = u16hi[1] | u8surrogate	
+	u16hi[3] = u16hi[3] | u8surrogate	
+	u16hi[4] = u16hi[4] | u8surrogate	
+	u16hi[5] = u16hi[5] | u8['scope44']
+
+	s42lo1 = ~u8bit[3] # subtract 1 
+	u16lo[1] = u16lo[1] | (u8['scope42'] & s42lo1)
+	s42lo0 = u8bit[2] ^ s42lo1 # borrow *
+	u16lo[0] = u16lo[0] | (u8['scope42'] & s42lo0)
+	borrow1 = s42lo1 & ~u8bit[2]
+	s42hi7 = Advance(u8bit[7]) ^ borrow1
+	u16hi[7]= u16hi[7] | (u8['scope42'] & s42hi7)
+	borrow2 = borrow1 & ~Advance(u8bit[7])
+	s42hi6 = Advance(u8bit[6]) ^ borrow2
+	u16hi[6] = u16hi[6] | (u8['scope42'] & s42hi6)
+
+	u16lo[2] = u16lo[2] | (u8['scope42'] & u8bit[4])
+	u16lo[3] = u16lo[3] | (u8['scope42'] & u8bit[5])
+	u16lo[4] = u16lo[4] | (u8['scope42'] & u8bit[6])
+	u16lo[5] = u16lo[5] | (u8['scope42'] & u8bit[7])
+	u16lo[6] = u16lo[6] | (u8['scope42'] & ShiftBack(u8bit[2]))
+	u16lo[7] = u16lo[7] | (u8['scope42'] & ShiftBack(u8bit[3]))
+
+	delmask = u8['prefix'] | u8['scope32'] | u8['scope43']
+	return (u16hi, u16lo, delmask)
+
+
+
+
+#
+# The following calculation of UTF-16 bit streams uses the 
+# u8scope43 position rather than the u8scope42 position for
+# the bits of the first UTF-16 code unit of a surrogate pair.
+# This requires more shifting than with the use of u8scope42,
+# but has the advantage that all shifts are in the forward
+# direction only and can hence be implemented using addition
+# on little-endian architecture.
+#
+
+def u16_streams_fwdonly(u8, u8bit):
+	u16hi = [0,0,0,0,0,0,0,0]
+	u16lo = [0,0,0,0,0,0,0,0]
+	
+	u8lastscope = u8['scope22'] | u8['scope33'] | u8['scope44']
+	u8lastbyte = u8['unibyte'] | u8lastscope
+	u16lo[2] = u8lastbyte & u8bit[2]
+	u16lo[3] = u8lastbyte & u8bit[3]
+	u16lo[4] = u8lastbyte & u8bit[4]
+	u16lo[5] = u8lastbyte & u8bit[5]
+	u16lo[6] = u8lastbyte & u8bit[6]
+	u16lo[7] = u8lastbyte & u8bit[7]
+	u16lo[1] = (u8['unibyte'] & u8bit[1]) | (u8lastscope & Advance(u8bit[7]))
+	u16lo[0] = u8lastscope & Advance(u8bit[6])
+	
+	u16hi[5] = u8lastscope & Advance(u8bit[3])
+	u16hi[6] = u8lastscope & Advance(u8bit[4])
+	u16hi[7] = u8lastscope & Advance(u8bit[5])
+	u16hi[0] = u8['scope33'] & Advance(Advance(u8bit[4]))
+	u16hi[1] = u8['scope33'] & Advance(Advance(u8bit[5]))
+	u16hi[2] = u8['scope33'] & Advance(Advance(u8bit[6]))
+	u16hi[3] = u8['scope33'] & Advance(Advance(u8bit[7]))
+	u16hi[4] = u8['scope33'] & Advance(u8bit[2])
+
+	u8surrogate = u8['scope43'] | u8['scope44']
+	u16hi[0] = u16hi[0] | u8surrogate	
+	u16hi[1] = u16hi[1] | u8surrogate	
+	u16hi[3] = u16hi[3] | u8surrogate	
+	u16hi[4] = u16hi[4] | u8surrogate	
+	u16hi[5] = u16hi[5] | u8['scope44']
+
+
+	s42lo1 = ~u8bit[3] # subtract 1 
+	u16lo[1] = u16lo[1] | (u8['scope43'] & Advance(s42lo1))
+	s42lo0 = u8bit[2] ^ s42lo1 # borrow *
+	u16lo[0] = u16lo[0] | (u8['scope43'] & Advance(s42lo0))
+	borrow1 = s42lo1 & ~u8bit[2]
+	advance_bit7 = Advance(u8bit[7])
+	s42hi7 = advance_bit7 ^ borrow1
+	u16hi[7]= u16hi[7] | (u8['scope43'] & Advance(s42hi7))
+	borrow2 = borrow1 & ~advance_bit7
+	s42hi6 = Advance(u8bit[6]) ^ borrow2
+	u16hi[6] = u16hi[6] | (u8['scope43'] & Advance(s42hi6))
+
+	u16lo[2] = u16lo[2] | (u8['scope43'] & Advance(u8bit[4]))
+	u16lo[3] = u16lo[3] | (u8['scope43'] & Advance(u8bit[5]))
+	u16lo[4] = u16lo[4] | (u8['scope43'] & Advance(u8bit[6]))
+	u16lo[5] = u16lo[5] | (u8['scope43'] & Advance(u8bit[7]))
+	u16lo[6] = u16lo[6] | (u8['scope43'] & u8bit[2])
+	u16lo[7] = u16lo[7] | (u8['scope43'] & u8bit[3])
+
+	delmask = u8['prefix'] | u8['scope32'] | u8['scope42']
+	return (u16hi, u16lo, delmask)
+
+
+
+# 
+# Messages to duplicate u8u16 error reporting.
+#
+def IllegalSequenceMessage(pos):
+	return "Illegal UTF-8 sequence at position %i in source.\n" % pos
+
+def IncompleteSequenceMessage(pos):
+	return "EOF with incomplete UTF-8 sequence at position %i in source.\n" % pos
+
+
+import sys
+def main():
+
+	if len(sys.argv) < 2:
+		sys.stderr.write("Usage: u8u16.py u8file [u16file]\n")
+		exit
+	if len(sys.argv) == 3:
+		outfile = open(sys.argv[2],"w")
+	else: outfile = sys.stdout
+	u8data = readfile(sys.argv[1])
+	u8len = len(u8data)
+	u8bit = transpose_streams(u8data)
+#	u8 = u8_streams(u8bit)
+	u8 = u8_streams_generated(u8bit)
+	if u8['error'] != 0:
+		err_pos = count_leading_zeroes(u8['error'])
+		at_EOF = err_pos == len(u8data)
+		if (err_pos >= 1) and ord(u8data[err_pos-1]) >= 0xC0: err_pos -= 1
+		elif err_pos >= 2 and ord(u8data[err_pos-2]) >= 0xE0: err_pos -= 2
+		elif err_pos >= 3 and ord(u8data[err_pos-3]) >= 0xF0: err_pos -= 3	
+		if at_EOF:
+			sys.stderr.write(IncompleteSequenceMessage(err_pos))
+		else:
+			sys.stderr.write(IllegalSequenceMessage(err_pos))
+		u8len = err_pos
+# 	Originally, we used the u16_streams version.
+#	(u16hi, u16lo, delmask) = u16_streams(u8, u8bit)
+	(u16hi, u16lo, delmask) = u16_streams_fwdonly(u8, u8bit)
+	U16H = filter_bytes(inverse_transpose(u16hi, u8len), delmask)
+	U16L = filter_bytes(inverse_transpose(u16lo, u8len), delmask)
+	U16final = merge_bytes(U16H, U16L)
+	outfile.write(U16final)
+	outfile.close()
+		
+if __name__ == "__main__": main()
+
+

package/deps/simdutf/benchmarks/competition/u8u16/src/Makefile

@@ -0,0 +1,18 @@
+CTANGLE= ctangle $(CTFLAGS)
+CWEAVE = cweave $(CWFLAGS)
+PDFLATEX = pdflatex $(TEXFLAGS)
+CWFLAGS=
+CTFLAGS=
+TEXFLAGS=
+
+.SUFFIXES: .tex .pdf .w
+
+.w.tex:
+	$(CWEAVE) $*
+
+.tex.pdf:
+	$(PDFLATEX) $*
+	$(PDFLATEX) $*
+
+.w.c:
+	$(CTANGLE) $*