zemu 0.1.0

data/src/external/Z/API/Z/types/base.h

@@ -0,0 +1,1655 @@
+/* Z Kit - types/base.h
+ _____  _______________
+/_   /_/  -_/_   _/  _ |
+ /____/\___/ /__//___/_| Kit
+Copyright (C) 2006-2018 Manuel Sainz de Baranda y Goñi.
+Released under the terms of the GNU Lesser General Public License v3. */
+
+#ifndef _Z_types_base_H_
+#define _Z_types_base_H_
+
+#include <Z/inspection/CPU.h>
+#include <Z/inspection/floating-point.h>
+#include <Z/inspection/data model.h>
+#include <Z/macros/templating.h>
+#include <Z/macros/structure.h>
+#include <Z/macros/members.h>
+
+/* MARK: - Fixed width numeric types */
+
+typedef Z_DATA_MODEL_TYPE(UINT8)     zuint8;
+typedef struct {zuint8 x, y;}	     Z2DUInt8;
+typedef struct {zuint8 x, y, z;}     Z3DUInt8;
+typedef struct {zuint8 x, y, z, w;}  Z4DUInt8;
+#define Z_UINT8			     Z_DATA_MODEL_LITERAL   (UINT8)
+#define Z_UINT8_VALUE_TYPE	     Z_DATA_MODEL_VALUE_TYPE(UINT8)
+#define Z_UINT8_FIXED_VALUE_TYPE     Z_VALUE_TYPE_UINT8
+#define Z_UINT8_VALUE_FORMAT	     Z_VALUE_FORMAT_8BIT_NATURAL
+#define Z_UINT8_BITS		     8
+#define Z_UINT8_SIZE		     1
+#define Z_UINT8_MINIMUM		     Z_UINT8(0)
+#define Z_UINT8_MAXIMUM		     Z_UINT8(255)
+
+typedef Z_DATA_MODEL_TYPE(SINT8)     zsint8;
+typedef struct {zsint8 x, y;}	     Z2DSInt8;
+typedef struct {zsint8 x, y, z;}     Z3DSInt8;
+typedef struct {zsint8 x, y, z, w;}  Z4DSInt8;
+#define Z_SINT8			     Z_DATA_MODEL_LITERAL   (SINT8)
+#define Z_SINT8_VALUE_TYPE	     Z_DATA_MODEL_VALUE_TYPE(SINT8)
+#define Z_SINT8_FIXED_VALUE_TYPE     Z_VALUE_TYPE_SINT8
+#define Z_SINT8_VALUE_FORMAT	     Z_CPU_FORMAT(INTEGER, 8)
+#define Z_SINT8_BITS		     8
+#define Z_SINT8_SIZE		     1
+#define Z_SINT8_MINIMUM		     Z_SINT8(-128)
+#define Z_SINT8_MAXIMUM		     Z_SINT8( 127)
+
+typedef Z_DATA_MODEL_TYPE(UINT16)    zuint16;
+typedef struct {zuint16 x, y;}	     Z2DUInt16;
+typedef struct {zuint16 x, y, z;}    Z3DUInt16;
+typedef struct {zuint16 x, y, z, w;} Z4DUInt16;
+#define Z_UINT16		     Z_DATA_MODEL_LITERAL   (UINT16)
+#define Z_UINT16_VALUE_TYPE	     Z_DATA_MODEL_VALUE_TYPE(UINT16)
+#define Z_UINT16_FIXED_VALUE_TYPE    Z_VALUE_TYPE_UINT16
+#define Z_UINT16_VALUE_FORMAT	     Z_VALUE_FORMAT_16BIT_NATURAL
+#define Z_UINT16_ENDIANNESS	     Z_CPU_ENDIANNESS(INTEGER, 16)
+#define Z_UINT16_BITS		     16
+#define Z_UINT16_SIZE		     2
+#define Z_UINT16_MINIMUM	     Z_UINT16(0)
+#define Z_UINT16_MAXIMUM	     Z_UINT16(65535)
+
+typedef Z_DATA_MODEL_TYPE(SINT16)    zsint16;
+typedef struct {zsint16 x, y;}	     Z2DSInt16;
+typedef struct {zsint16 x, y, z;}    Z3DSInt16;
+typedef struct {zsint16 x, y, z, w;} Z4DSInt16;
+#define Z_SINT16		     Z_DATA_MODEL_LITERAL   (SINT16)
+#define Z_SINT16_VALUE_TYPE	     Z_DATA_MODEL_VALUE_TYPE(SINT16)
+#define Z_SINT16_FIXED_VALUE_TYPE    Z_VALUE_TYPE_SINT16
+#define Z_SINT16_VALUE_FORMAT	     Z_CPU_FORMAT    (INTEGER, 16)
+#define Z_SINT16_ENDIANNESS	     Z_CPU_ENDIANNESS(INTEGER, 16)
+#define Z_SINT16_BITS		     16
+#define Z_SINT16_SIZE		     2
+#define Z_SINT16_MINIMUM	     Z_SINT16(-32768)
+#define Z_SINT16_MAXIMUM	     Z_SINT16( 32767)
+
+typedef Z_DATA_MODEL_TYPE(UINT32)    zuint32;
+typedef struct {zuint32 x, y;}	     Z2DUInt32;
+typedef struct {zuint32 x, y, z;}    Z3DUInt32;
+typedef struct {zuint32 x, y, z, w;} Z4DUInt32;
+#define Z_UINT32		     Z_DATA_MODEL_LITERAL   (UINT32)
+#define Z_UINT32_VALUE_TYPE	     Z_DATA_MODEL_VALUE_TYPE(UINT32)
+#define Z_UINT32_FIXED_VALUE_TYPE    Z_VALUE_TYPE_UINT32
+#define Z_UINT32_VALUE_FORMAT	     Z_VALUE_FORMAT_32BIT_NATURAL
+#define Z_UINT32_ENDIANNESS	     Z_CPU_ENDIANNESS(INTEGER, 32)
+#define Z_UINT32_BITS		     32
+#define Z_UINT32_SIZE		     4
+#define Z_UINT32_MINIMUM	     Z_UINT32(0)
+#define Z_UINT32_MAXIMUM	     Z_UINT32(4294967295)
+
+typedef Z_DATA_MODEL_TYPE(SINT32)    zsint32;
+typedef struct {zsint32 x, y;}	     Z2DSInt32;
+typedef struct {zsint32 x, y, z;}    Z3DSInt32;
+typedef struct {zsint32 x, y, z, w;} Z4DSInt32;
+#define Z_SINT32		     Z_DATA_MODEL_LITERAL   (SINT32)
+#define Z_SINT32_VALUE_TYPE	     Z_DATA_MODEL_VALUE_TYPE(SINT32)
+#define Z_SINT32_FIXED_VALUE_TYPE    Z_VALUE_TYPE_SINT32
+#define Z_SINT32_VALUE_FORMAT	     Z_CPU_FORMAT    (INTEGER, 32)
+#define Z_SINT32_ENDIANNESS	     Z_CPU_ENDIANNESS(INTEGER, 32)
+#define Z_SINT32_BITS		     32
+#define Z_SINT32_SIZE		     4
+#define Z_SINT32_MINIMUM	     Z_SINT32(-2147483648)
+#define	Z_SINT32_MAXIMUM	     Z_SINT32( 2147483647)
+
+#if Z_DATA_MODEL_HAS_TYPE(UINT64)
+
+	typedef Z_DATA_MODEL_TYPE(UINT64)    zuint64;
+	typedef struct {zuint64 x, y;}	     Z2DUInt64;
+	typedef struct {zuint64 x, y, z;}    Z3DUInt64;
+	typedef struct {zuint64 x, y, z, w;} Z4DUInt64;
+#	define Z_UINT64_VALUE_TYPE	     Z_DATA_MODEL_VALUE_TYPE(UINT64)
+#	define Z_UINT64_FIXED_VALUE_TYPE     Z_VALUE_TYPE_UINT64
+#	define Z_UINT64_VALUE_FORMAT	     Z_VALUE_FORMAT_64BIT_NATURAL
+#	define Z_UINT64_ENDIANNESS	     Z_CPU_ENDIANNESS(INTEGER, 64)
+#	define Z_UINT64_BITS		     64
+#	define Z_UINT64_SIZE		     8
+#	define Z_UINT64_MINIMUM		     0
+
+#	if Z_DATA_MODEL_HAS_LITERAL(UINT64)
+#		define Z_UINT64		Z_DATA_MODEL_LITERAL(UINT64)
+#		define Z_UINT64_MAXIMUM Z_UINT64(18446744073709551615)
+#	else
+#		define Z_UINT64		Z_SAME
+#		define Z_UINT64_MAXIMUM (((zuint64)0) - 1)
+#	endif
+
+#endif
+
+#if Z_DATA_MODEL_HAS_TYPE(SINT64)
+
+	typedef Z_DATA_MODEL_TYPE(SINT64)    zsint64;
+	typedef struct {zsint64 x, y;}	     Z2DSInt64;
+	typedef struct {zsint64 x, y, z;}    Z3DSInt64;
+	typedef struct {zsint64 x, y, z, w;} Z4DSInt64;
+#	define Z_SINT64_VALUE_TYPE	     Z_DATA_MODEL_VALUE_TYPE(SINT64)
+#	define Z_SINT64_FIXED_VALUE_TYPE     Z_VALUE_TYPE_SINT64
+#	define Z_SINT64_VALUE_FORMAT	     Z_CPU_FORMAT    (INTEGER, 64)
+#	define Z_SINT64_ENDIANNESS	     Z_CPU_ENDIANNESS(INTEGER, 64)
+#	define Z_SINT64_BITS		     64
+#	define Z_SINT64_SIZE		     8
+
+#	if Z_DATA_MODEL_HAS_LITERAL(SINT64)
+#		define Z_SINT64		Z_DATA_MODEL_LITERAL(SINT64)
+#		define Z_SINT64_MAXIMUM Z_SINT64(9223372036854775807)
+#		define Z_SINT64_MINIMUM (-Z_SINT64_MAXIMUM - Z_SINT64(1))
+#	else
+#		define Z_SINT64		Z_SAME
+#		define Z_SINT64_MAXIMUM 0 /* TODO */
+#		define Z_SINT64_MINIMUM 0 /* TODO */
+#	endif
+
+#endif
+
+#if Z_DATA_MODEL_HAS_TYPE(UINT128)
+
+	typedef Z_DATA_MODEL_TYPE(UINT128)    zuint128;
+	typedef struct {zuint128 x, y;}	      Z2DUInt128;
+	typedef struct {zuint128 x, y, z;}    Z3DUInt128;
+	typedef struct {zuint128 x, y, z, w;} Z4DUInt128;
+#	define Z_UINT128_VALUE_TYPE	      Z_DATA_MODEL_VALUE_TYPE(UINT128)
+#	define Z_UINT128_FIXED_VALUE_TYPE     Z_VALUE_TYPE_UINT128
+#	define Z_UINT128_VALUE_FORMAT	      Z_VALUE_FORMAT_128BIT_NATURAL
+#	define Z_UINT128_ENDIANNESS	      Z_CPU_ENDIANNESS(INTEGER, 128)
+#	define Z_UINT128_BITS		      128
+#	define Z_UINT128_SIZE		      16
+#	define Z_UINT128_MINIMUM	      0
+
+#	if Z_DATA_MODEL_HAS_LITERAL(UINT128)
+#		define Z_UINT128	 Z_DATA_MODEL_LITERAL(UINT128)
+#		define Z_UINT128_MAXIMUM Z_UINT128(340282366920938463463374607431768211455)
+#	else
+#		define Z_UINT128	 Z_SAME
+#		define Z_UINT128_MAXIMUM (((zuint128)0) - 1)
+#	endif
+
+#endif
+
+#if Z_DATA_MODEL_HAS_TYPE(SINT128)
+
+	typedef Z_DATA_MODEL_TYPE(SINT128)    zsint128;
+	typedef struct {zsint128 x, y;}	      Z2DSInt128;
+	typedef struct {zsint128 x, y, z;}    Z3DSInt128;
+	typedef struct {zsint128 x, y, z, w;} Z4DSInt128;
+#	define Z_SINT128_VALUE_TYPE	      Z_DATA_MODEL_VALUE_TYPE(SINT128)
+#	define Z_SINT128_FIXED_VALUE_TYPE     Z_VALUE_TYPE_SINT128
+#	define Z_SINT128_VALUE_FORMAT	      Z_CPU_FORMAT    (INTEGER, 128)
+#	define Z_SINT128_ENDIANNESS	      Z_CPU_ENDIANNESS(INTEGER, 128)
+#	define Z_SINT128_BITS		      128
+#	define Z_SINT128_SIZE		      16
+
+#	if Z_DATA_MODEL_HAS_LITERAL(SINT128)
+#		define Z_SINT128	 Z_DATA_MODEL_LITERAL(SINT128)
+#		define Z_SINT128_MAXIMUM Z_SINT128(170141183460469231731687303715884105727)
+#		define Z_SINT128_MINIMUM (-Z_SINT128_MAXIMUM - Z_SINT128(1))
+#	else
+#		define Z_SINT128	 Z_SAME
+#		define Z_SINT128_MAXIMUM 0 /* TODO */
+#		define Z_SINT128_MINIMUM 0 /* TODO */
+#	endif
+
+#endif
+
+#if Z_FLOATING_POINT_HAS_TYPE(FLOAT16)
+
+	typedef Z_FLOATING_POINT_TYPE(FLOAT16) zfloat16;
+	typedef struct {zfloat16 x, y;}	       Z2DFloat16;
+	typedef struct {zfloat16 x, y, z;}     Z3DFloat16;
+	typedef struct {zfloat16 x, y, z, w;}  Z4DFloat16;
+#	define Z_FLOAT16		       Z_FLOATING_POINT_LITERAL		   (FLOAT16)
+#	define Z_FLOAT16_VALUE_TYPE	       Z_FLOATING_POINT_VALUE_TYPE	   (FLOAT16)
+#	define Z_FLOAT16_FIXED_VALUE_TYPE      Z_VALUE_TYPE_FLOAT16
+#	define Z_FLOAT16_VALUE_FORMAT	       Z_VALUE_FORMAT_IEEE_754_BINARY16
+#	define Z_FLOAT16_BITS		       16
+#	define Z_FLOAT16_SIZE		       2
+#	define Z_FLOAT16_BIAS		       Z_FLOATING_POINT_BIAS		   (FLOAT16)
+#	define Z_FLOAT16_DECIMAL_DIGITS	       Z_FLOATING_POINT_DECIMAL_DIGITS	   (FLOAT16)
+#	define Z_FLOAT16_SIGNIFICAND_OFFSET    Z_FLOATING_POINT_SIGNIFICAND_OFFSET (FLOAT16)
+#	define Z_FLOAT16_SIGNIFICAND_BITS      Z_FLOATING_POINT_SIGNIFICAND_BITS   (FLOAT16)
+#	define Z_FLOAT16_SIGNIFICAND_DIGITS    Z_FLOATING_POINT_SIGNIFICAND_DIGITS (FLOAT16)
+#	define Z_FLOAT16_EXPONENT_OFFSET       Z_FLOATING_POINT_EXPONENT_OFFSET	   (FLOAT16)
+#	define Z_FLOAT16_EXPONENT_BITS	       Z_FLOATING_POINT_EXPONENT_BITS	   (FLOAT16)
+#	define Z_FLOAT16_EXPONENT_RADIX	       Z_FLOATING_POINT_EXPONENT_RADIX	   (FLOAT16)
+#	define Z_FLOAT16_EXPONENT_MINIMUM      Z_FLOATING_POINT_EXPONENT_MINIMUM   (FLOAT16)
+#	define Z_FLOAT16_EXPONENT_MAXIMUM      Z_FLOATING_POINT_EXPONENT_MAXIMUM   (FLOAT16)
+#	define Z_FLOAT16_EXPONENT_10_MINIMUM   Z_FLOATING_POINT_EXPONENT_10_MINIMUM(FLOAT16)
+#	define Z_FLOAT16_EXPONENT_10_MAXIMUM   Z_FLOATING_POINT_EXPONENT_10_MAXIMUM(FLOAT16)
+#	define Z_FLOAT16_SIGN_OFFSET	       Z_FLOATING_POINT_SIGN_OFFSET	   (FLOAT16)
+#	define Z_FLOAT16_SIGN_BITS	       Z_FLOATING_POINT_SIGN_BITS	   (FLOAT16)
+#	define Z_FLOAT16_EPSILON	       Z_FLOATING_POINT_EPSILON		   (FLOAT16)
+#	define Z_FLOAT16_MINIMUM	       Z_FLOATING_POINT_MINIMUM		   (FLOAT16)
+#	define Z_FLOAT16_MAXIMUM	       Z_FLOATING_POINT_MAXIMUM		   (FLOAT16)
+#	define Z_FLOAT16_INFINITY	       Z_FLOATING_POINT_INFINITY	   (FLOAT16)
+#	define Z_FLOAT16_NAN		       Z_FLOATING_POINT_NAN		   (FLOAT16)
+
+#endif
+
+#if Z_FLOATING_POINT_HAS_TYPE(FLOAT32)
+
+	typedef Z_FLOATING_POINT_TYPE(FLOAT32) zfloat32;
+	typedef struct {zfloat32 x, y;}	       Z2DFloat32;
+	typedef struct {zfloat32 x, y, z;}     Z3DFloat32;
+	typedef struct {zfloat32 x, y, z, w;}  Z4DFloat32;
+#	define Z_FLOAT32		       Z_FLOATING_POINT_LITERAL		   (FLOAT32)
+#	define Z_FLOAT32_VALUE_TYPE	       Z_FLOATING_POINT_VALUE_TYPE	   (FLOAT32)
+#	define Z_FLOAT32_FIXED_VALUE_TYPE      Z_VALUE_TYPE_FLOAT32
+#	define Z_FLOAT32_VALUE_FORMAT	       Z_VALUE_FORMAT_IEEE_754_BINARY32
+#	define Z_FLOAT32_BITS		       32
+#	define Z_FLOAT32_SIZE		       4
+#	define Z_FLOAT32_BIAS		       Z_FLOATING_POINT_BIAS		   (FLOAT32)
+#	define Z_FLOAT32_DECIMAL_DIGITS	       Z_FLOATING_POINT_DECIMAL_DIGITS	   (FLOAT32)
+#	define Z_FLOAT32_SIGNIFICAND_OFFSET    Z_FLOATING_POINT_SIGNIFICAND_OFFSET (FLOAT32)
+#	define Z_FLOAT32_SIGNIFICAND_BITS      Z_FLOATING_POINT_SIGNIFICAND_BITS   (FLOAT32)
+#	define Z_FLOAT32_SIGNIFICAND_DIGITS    Z_FLOATING_POINT_SIGNIFICAND_DIGITS (FLOAT32)
+#	define Z_FLOAT32_EXPONENT_OFFSET       Z_FLOATING_POINT_EXPONENT_OFFSET	   (FLOAT32)
+#	define Z_FLOAT32_EXPONENT_BITS	       Z_FLOATING_POINT_EXPONENT_BITS	   (FLOAT32)
+#	define Z_FLOAT32_EXPONENT_RADIX	       Z_FLOATING_POINT_EXPONENT_RADIX	   (FLOAT32)
+#	define Z_FLOAT32_EXPONENT_MINIMUM      Z_FLOATING_POINT_EXPONENT_MINIMUM   (FLOAT32)
+#	define Z_FLOAT32_EXPONENT_MAXIMUM      Z_FLOATING_POINT_EXPONENT_MAXIMUM   (FLOAT32)
+#	define Z_FLOAT32_EXPONENT_10_MINIMUM   Z_FLOATING_POINT_EXPONENT_10_MINIMUM(FLOAT32)
+#	define Z_FLOAT32_EXPONENT_10_MAXIMUM   Z_FLOATING_POINT_EXPONENT_10_MAXIMUM(FLOAT32)
+#	define Z_FLOAT32_SIGN_OFFSET	       Z_FLOATING_POINT_SIGN_OFFSET	   (FLOAT32)
+#	define Z_FLOAT32_SIGN_BITS	       Z_FLOATING_POINT_SIGN_BITS	   (FLOAT32)
+#	define Z_FLOAT32_EPSILON	       Z_FLOATING_POINT_EPSILON		   (FLOAT32)
+#	define Z_FLOAT32_MINIMUM	       Z_FLOATING_POINT_MINIMUM		   (FLOAT32)
+#	define Z_FLOAT32_MAXIMUM	       Z_FLOATING_POINT_MAXIMUM		   (FLOAT32)
+#	define Z_FLOAT32_INFINITY	       Z_FLOATING_POINT_INFINITY	   (FLOAT32)
+#	define Z_FLOAT32_NAN		       Z_FLOATING_POINT_NAN		   (FLOAT32)
+
+#endif
+
+#if Z_FLOATING_POINT_HAS_TYPE(FLOAT64)
+
+	typedef Z_FLOATING_POINT_TYPE(FLOAT64) zfloat64;
+	typedef struct {zfloat64 x, y;}	       Z2DFloat64;
+	typedef struct {zfloat64 x, y, z;}     Z3DFloat64;
+	typedef struct {zfloat64 x, y, z, w;}  Z4DFloat64;
+#	define Z_FLOAT64		       Z_FLOATING_POINT_LITERAL		   (FLOAT64)
+#	define Z_FLOAT64_VALUE_TYPE	       Z_FLOATING_POINT_VALUE_TYPE	   (FLOAT64)
+#	define Z_FLOAT64_FIXED_VALUE_TYPE      Z_VALUE_TYPE_FLOAT64
+#	define Z_FLOAT64_VALUE_FORMAT	       Z_VALUE_FORMAT_IEEE_754_BINARY64
+#	define Z_FLOAT64_BITS		       64
+#	define Z_FLOAT64_SIZE		       8
+#	define Z_FLOAT64_BIAS		       Z_FLOATING_POINT_BIAS		   (FLOAT64)
+#	define Z_FLOAT64_DECIMAL_DIGITS	       Z_FLOATING_POINT_DECIMAL_DIGITS	   (FLOAT64)
+#	define Z_FLOAT64_SIGNIFICAND_OFFSET    Z_FLOATING_POINT_SIGNIFICAND_OFFSET (FLOAT64)
+#	define Z_FLOAT64_SIGNIFICAND_BITS      Z_FLOATING_POINT_SIGNIFICAND_BITS   (FLOAT64)
+#	define Z_FLOAT64_SIGNIFICAND_DIGITS    Z_FLOATING_POINT_SIGNIFICAND_DIGITS (FLOAT64)
+#	define Z_FLOAT64_EXPONENT_OFFSET       Z_FLOATING_POINT_EXPONENT_OFFSET	   (FLOAT64)
+#	define Z_FLOAT64_EXPONENT_BITS	       Z_FLOATING_POINT_EXPONENT_BITS	   (FLOAT64)
+#	define Z_FLOAT64_EXPONENT_RADIX	       Z_FLOATING_POINT_EXPONENT_RADIX	   (FLOAT64)
+#	define Z_FLOAT64_EXPONENT_MINIMUM      Z_FLOATING_POINT_EXPONENT_MINIMUM   (FLOAT64)
+#	define Z_FLOAT64_EXPONENT_MAXIMUM      Z_FLOATING_POINT_EXPONENT_MAXIMUM   (FLOAT64)
+#	define Z_FLOAT64_EXPONENT_10_MINIMUM   Z_FLOATING_POINT_EXPONENT_10_MINIMUM(FLOAT64)
+#	define Z_FLOAT64_EXPONENT_10_MAXIMUM   Z_FLOATING_POINT_EXPONENT_10_MAXIMUM(FLOAT64)
+#	define Z_FLOAT64_SIGN_OFFSET	       Z_FLOATING_POINT_SIGN_OFFSET	   (FLOAT64)
+#	define Z_FLOAT64_SIGN_BITS	       Z_FLOATING_POINT_SIGN_BITS	   (FLOAT64)
+#	define Z_FLOAT64_EPSILON	       Z_FLOATING_POINT_EPSILON		   (FLOAT64)
+#	define Z_FLOAT64_MINIMUM	       Z_FLOATING_POINT_MINIMUM		   (FLOAT64)
+#	define Z_FLOAT64_MAXIMUM	       Z_FLOATING_POINT_MAXIMUM		   (FLOAT64)
+#	define Z_FLOAT64_INFINITY	       Z_FLOATING_POINT_INFINITY	   (FLOAT64)
+#	define Z_FLOAT64_NAN		       Z_FLOATING_POINT_NAN		   (FLOAT64)
+
+#endif
+
+#if Z_FLOATING_POINT_HAS_TYPE(FLOAT128)
+
+	typedef Z_FLOATING_POINT_TYPE(FLOAT128)	zfloat128;
+	typedef struct {zfloat128 x, y;}	Z2DFloat128;
+	typedef struct {zfloat128 x, y, z;}	Z3DFloat128;
+	typedef struct {zfloat128 x, y, z, w;}	Z4DFloat128;
+#	define Z_FLOAT128			Z_FLOATING_POINT_LITERAL	    (FLOAT128)
+#	define Z_FLOAT128_VALUE_TYPE		Z_FLOATING_POINT_VALUE_TYPE	    (FLOAT128)
+#	define Z_FLOAT128_FIXED_VALUE_TYPE	Z_VALUE_TYPE_FLOAT128
+#	define Z_FLOAT128_VALUE_FORMAT		Z_VALUE_FORMAT_IEEE_754_BINARY128
+#	define Z_FLOAT128_BITS			128
+#	define Z_FLOAT128_SIZE			16
+#	define Z_FLOAT128_BIAS			Z_FLOATING_POINT_BIAS		    (FLOAT128)
+#	define Z_FLOAT128_DECIMAL_DIGITS	Z_FLOATING_POINT_DECIMAL_DIGITS	    (FLOAT128)
+#	define Z_FLOAT128_SIGNIFICAND_OFFSET	Z_FLOATING_POINT_SIGNIFICAND_OFFSET (FLOAT128)
+#	define Z_FLOAT128_SIGNIFICAND_BITS	Z_FLOATING_POINT_SIGNIFICAND_BITS   (FLOAT128)
+#	define Z_FLOAT128_SIGNIFICAND_DIGITS	Z_FLOATING_POINT_SIGNIFICAND_DIGITS (FLOAT128)
+#	define Z_FLOAT128_EXPONENT_OFFSET	Z_FLOATING_POINT_EXPONENT_OFFSET    (FLOAT128)
+#	define Z_FLOAT128_EXPONENT_BITS		Z_FLOATING_POINT_EXPONENT_BITS	    (FLOAT128)
+#	define Z_FLOAT128_EXPONENT_RADIX	Z_FLOATING_POINT_EXPONENT_RADIX	    (FLOAT128)
+#	define Z_FLOAT128_EXPONENT_MINIMUM	Z_FLOATING_POINT_EXPONENT_MINIMUM   (FLOAT128)
+#	define Z_FLOAT128_EXPONENT_MAXIMUM	Z_FLOATING_POINT_EXPONENT_MAXIMUM   (FLOAT128)
+#	define Z_FLOAT128_EXPONENT_10_MINIMUM	Z_FLOATING_POINT_EXPONENT_10_MINIMUM(FLOAT128)
+#	define Z_FLOAT128_EXPONENT_10_MAXIMUM	Z_FLOATING_POINT_EXPONENT_10_MAXIMUM(FLOAT128)
+#	define Z_FLOAT128_SIGN_OFFSET		Z_FLOATING_POINT_SIGN_OFFSET	    (FLOAT128)
+#	define Z_FLOAT128_SIGN_BITS		Z_FLOATING_POINT_SIGN_BITS	    (FLOAT128)
+#	define Z_FLOAT128_EPSILON		Z_FLOATING_POINT_EPSILON	    (FLOAT128)
+#	define Z_FLOAT128_MINIMUM		Z_FLOATING_POINT_MINIMUM	    (FLOAT128)
+#	define Z_FLOAT128_MAXIMUM		Z_FLOATING_POINT_MAXIMUM	    (FLOAT128)
+#	define Z_FLOAT128_INFINITY		Z_FLOATING_POINT_INFINITY	    (FLOAT128)
+#	define Z_FLOAT128_NAN			Z_FLOATING_POINT_NAN		    (FLOAT128)
+
+#endif
+
+#if Z_FLOATING_POINT_HAS_TYPE(FLOAT80_X87)
+
+	typedef Z_FLOATING_POINT_TYPE(FLOAT80_X87) zfloat80_x87;
+	typedef struct {zfloat80_x87 x, y;}	   Z2DFloat80_x87;
+	typedef struct {zfloat80_x87 x, y, z;}	   Z3DFloat80_x87;
+	typedef struct {zfloat80_x87 x, y, z, w;}  Z4DFloat80_x87;
+#	define Z_FLOAT80_X87			   Z_FLOATING_POINT_LITERAL	       (FLOAT80_X87)
+#	define Z_FLOAT80_X87_VALUE_TYPE		   Z_FLOATING_POINT_VALUE_TYPE	       (FLOAT80_X87)
+#	define Z_FLOAT80_X87_FIXED_VALUE_TYPE	   Z_VALUE_TYPE_FLOAT80_X87
+#	define Z_FLOAT80_X87_VALUE_FORMAT	   Z_VALUE_FORMAT_X87_BINARY80
+#	define Z_FLOAT80_X87_BITS		   80
+#	define Z_FLOAT80_X87_SIZE		   10
+#	define Z_FLOAT80_X87_BIAS		   Z_FLOATING_POINT_BIAS	       (FLOAT80_X87)
+#	define Z_FLOAT80_X87_DECIMAL_DIGITS	   Z_FLOATING_POINT_DECIMAL_DIGITS     (FLOAT80_X87)
+#	define Z_FLOAT80_X87_SIGNIFICAND_OFFSET	   Z_FLOATING_POINT_SIGNIFICAND_OFFSET (FLOAT80_X87)
+#	define Z_FLOAT80_X87_SIGNIFICAND_BITS	   Z_FLOATING_POINT_SIGNIFICAND_BITS   (FLOAT80_X87)
+#	define Z_FLOAT80_X87_SIGNIFICAND_DIGITS	   Z_FLOATING_POINT_SIGNIFICAND_DIGITS (FLOAT80_X87)
+#	define Z_FLOAT80_X87_EXPONENT_OFFSET	   Z_FLOATING_POINT_EXPONENT_OFFSET    (FLOAT80_X87)
+#	define Z_FLOAT80_X87_EXPONENT_BITS	   Z_FLOATING_POINT_EXPONENT_BITS      (FLOAT80_X87)
+#	define Z_FLOAT80_X87_EXPONENT_RADIX	   Z_FLOATING_POINT_EXPONENT_RADIX     (FLOAT80_X87)
+#	define Z_FLOAT80_X87_EXPONENT_MINIMUM	   Z_FLOATING_POINT_EXPONENT_MINIMUM   (FLOAT80_X87)
+#	define Z_FLOAT80_X87_EXPONENT_MAXIMUM	   Z_FLOATING_POINT_EXPONENT_MAXIMUM   (FLOAT80_X87)
+#	define Z_FLOAT80_X87_EXPONENT_10_MINIMUM   Z_FLOATING_POINT_EXPONENT_10_MINIMUM(FLOAT80_X87)
+#	define Z_FLOAT80_X87_EXPONENT_10_MAXIMUM   Z_FLOATING_POINT_EXPONENT_10_MAXIMUM(FLOAT80_X87)
+#	define Z_FLOAT80_X87_SIGN_OFFSET	   Z_FLOATING_POINT_SIGN_OFFSET	       (FLOAT80_X87)
+#	define Z_FLOAT80_X87_SIGN_BITS		   Z_FLOATING_POINT_SIGN_BITS	       (FLOAT80_X87)
+#	define Z_FLOAT80_X87_EPSILON		   Z_FLOATING_POINT_EPSILON	       (FLOAT80_X87)
+#	define Z_FLOAT80_X87_MINIMUM		   Z_FLOATING_POINT_MINIMUM	       (FLOAT80_X87)
+#	define Z_FLOAT80_X87_MAXIMUM		   Z_FLOATING_POINT_MAXIMUM	       (FLOAT80_X87)
+#	define Z_FLOAT80_X87_INFINITY		   Z_FLOATING_POINT_INFINITY	       (FLOAT80_X87)
+#	define Z_FLOAT80_X87_NAN		   Z_FLOATING_POINT_NAN		       (FLOAT80_X87)
+
+#endif
+
+#if Z_FLOATING_POINT_HAS_TYPE(FLOAT96_X87)
+
+	typedef Z_FLOATING_POINT_TYPE(FLOAT96_X87) zfloat96_x87;
+	typedef struct {zfloat96_x87 x, y;}	   Z2DFloat96_x87;
+	typedef struct {zfloat96_x87 x, y, z;}	   Z3DFloat96_x87;
+	typedef struct {zfloat96_x87 x, y, z, w;}  Z4DFloat96_x87;
+#	define Z_FLOAT96_X87			   Z_FLOATING_POINT_LITERAL	       (FLOAT96_X87)
+#	define Z_FLOAT96_X87_VALUE_TYPE		   Z_FLOATING_POINT_VALUE_TYPE	       (FLOAT96_X87)
+#	define Z_FLOAT96_X87_FIXED_VALUE_TYPE	   Z_VALUE_TYPE_FLOAT96_X87
+#	define Z_FLOAT96_X87_VALUE_FORMAT	   Z_VALUE_FORMAT_X87_BINARY96
+#	define Z_FLOAT96_X87_BITS		   96
+#	define Z_FLOAT96_X87_SIZE		   12
+#	define Z_FLOAT96_X87_BIAS		   Z_FLOATING_POINT_BIAS	       (FLOAT96_X87)
+#	define Z_FLOAT96_X87_DECIMAL_DIGITS	   Z_FLOATING_POINT_DECIMAL_DIGITS     (FLOAT96_X87)
+#	define Z_FLOAT96_X87_SIGNIFICAND_OFFSET	   Z_FLOATING_POINT_SIGNIFICAND_OFFSET (FLOAT96_X87)
+#	define Z_FLOAT96_X87_SIGNIFICAND_BITS	   Z_FLOATING_POINT_SIGNIFICAND_BITS   (FLOAT96_X87)
+#	define Z_FLOAT96_X87_SIGNIFICAND_DIGITS	   Z_FLOATING_POINT_SIGNIFICAND_DIGITS (FLOAT96_X87)
+#	define Z_FLOAT96_X87_EXPONENT_OFFSET	   Z_FLOATING_POINT_EXPONENT_OFFSET    (FLOAT96_X87)
+#	define Z_FLOAT96_X87_EXPONENT_BITS	   Z_FLOATING_POINT_EXPONENT_BITS      (FLOAT96_X87)
+#	define Z_FLOAT96_X87_EXPONENT_RADIX	   Z_FLOATING_POINT_EXPONENT_RADIX     (FLOAT96_X87)
+#	define Z_FLOAT96_X87_EXPONENT_MINIMUM	   Z_FLOATING_POINT_EXPONENT_MINIMUM   (FLOAT96_X87)
+#	define Z_FLOAT96_X87_EXPONENT_MAXIMUM	   Z_FLOATING_POINT_EXPONENT_MAXIMUM   (FLOAT96_X87)
+#	define Z_FLOAT96_X87_EXPONENT_10_MINIMUM   Z_FLOATING_POINT_EXPONENT_10_MINIMUM(FLOAT96_X87)
+#	define Z_FLOAT96_X87_EXPONENT_10_MAXIMUM   Z_FLOATING_POINT_EXPONENT_10_MAXIMUM(FLOAT96_X87)
+#	define Z_FLOAT96_X87_SIGN_OFFSET	   Z_FLOATING_POINT_SIGN_OFFSET	       (FLOAT96_X87)
+#	define Z_FLOAT96_X87_SIGN_BITS		   Z_FLOATING_POINT_SIGN_BITS	       (FLOAT96_X87)
+#	define Z_FLOAT96_X87_EPSILON		   Z_FLOATING_POINT_EPSILON	       (FLOAT96_X87)
+#	define Z_FLOAT96_X87_MINIMUM		   Z_FLOATING_POINT_MINIMUM	       (FLOAT96_X87)
+#	define Z_FLOAT96_X87_MAXIMUM		   Z_FLOATING_POINT_MAXIMUM	       (FLOAT96_X87)
+#	define Z_FLOAT96_X87_INFINITY		   Z_FLOATING_POINT_INFINITY	       (FLOAT96_X87)
+#	define Z_FLOAT96_X87_NAN		   Z_FLOATING_POINT_NAN		       (FLOAT96_X87)
+
+#endif
+
+#if Z_FLOATING_POINT_HAS_TYPE(FLOAT128_X87)
+
+	typedef Z_FLOATING_POINT_TYPE(FLOAT128_X87) zfloat128_x87;
+	typedef struct {zfloat128_x87 x, y;}	    Z2DFloat128_x87;
+	typedef struct {zfloat128_x87 x, y, z;}	    Z3DFloat128_x87;
+	typedef struct {zfloat128_x87 x, y, z, w;}  Z4DFloat128_x87;
+#	define Z_FLOAT128_X87			    Z_FLOATING_POINT_LITERAL		(FLOAT128_X87)
+#	define Z_FLOAT128_X87_VALUE_TYPE	    Z_FLOATING_POINT_VALUE_TYPE		(FLOAT128_X87)
+#	define Z_FLOAT128_X87_FIXED_VALUE_TYPE	    Z_VALUE_TYPE_FLOAT128_X87
+#	define Z_FLOAT128_X87_VALUE_FORMAT	    Z_VALUE_FORMAT_X87_BINARY128
+#	define Z_FLOAT128_X87_BITS		    128
+#	define Z_FLOAT128_X87_SIZE		    16
+#	define Z_FLOAT128_X87_BIAS		    Z_FLOATING_POINT_BIAS		(FLOAT128_X87)
+#	define Z_FLOAT128_X87_DECIMAL_DIGITS	    Z_FLOATING_POINT_DECIMAL_DIGITS	(FLOAT128_X87)
+#	define Z_FLOAT128_X87_SIGNIFICAND_OFFSET    Z_FLOATING_POINT_SIGNIFICAND_OFFSET (FLOAT128_X87)
+#	define Z_FLOAT128_X87_SIGNIFICAND_BITS	    Z_FLOATING_POINT_SIGNIFICAND_BITS	(FLOAT128_X87)
+#	define Z_FLOAT128_X87_SIGNIFICAND_DIGITS    Z_FLOATING_POINT_SIGNIFICAND_DIGITS (FLOAT128_X87)
+#	define Z_FLOAT128_X87_EXPONENT_OFFSET	    Z_FLOATING_POINT_EXPONENT_OFFSET	(FLOAT128_X87)
+#	define Z_FLOAT128_X87_EXPONENT_BITS	    Z_FLOATING_POINT_EXPONENT_BITS	(FLOAT128_X87)
+#	define Z_FLOAT128_X87_EXPONENT_RADIX	    Z_FLOATING_POINT_EXPONENT_RADIX	(FLOAT128_X87)
+#	define Z_FLOAT128_X87_EXPONENT_MINIMUM	    Z_FLOATING_POINT_EXPONENT_MINIMUM	(FLOAT128_X87)
+#	define Z_FLOAT128_X87_EXPONENT_MAXIMUM	    Z_FLOATING_POINT_EXPONENT_MAXIMUM	(FLOAT128_X87)
+#	define Z_FLOAT128_X87_EXPONENT_10_MINIMUM   Z_FLOATING_POINT_EXPONENT_10_MINIMUM(FLOAT128_X87)
+#	define Z_FLOAT128_X87_EXPONENT_10_MAXIMUM   Z_FLOATING_POINT_EXPONENT_10_MAXIMUM(FLOAT128_X87)
+#	define Z_FLOAT128_X87_SIGN_OFFSET	    Z_FLOATING_POINT_SIGN_OFFSET	(FLOAT128_X87)
+#	define Z_FLOAT128_X87_SIGN_BITS		    Z_FLOATING_POINT_SIGN_BITS		(FLOAT128_X87)
+#	define Z_FLOAT128_X87_EPSILON		    Z_FLOATING_POINT_EPSILON		(FLOAT128_X87)
+#	define Z_FLOAT128_X87_MINIMUM		    Z_FLOATING_POINT_MINIMUM		(FLOAT128_X87)
+#	define Z_FLOAT128_X87_MAXIMUM		    Z_FLOATING_POINT_MAXIMUM		(FLOAT128_X87)
+#	define Z_FLOAT128_X87_INFINITY		    Z_FLOATING_POINT_INFINITY		(FLOAT128_X87)
+#	define Z_FLOAT128_X87_NAN		    Z_FLOATING_POINT_NAN		(FLOAT128_X87)
+
+#endif
+
+#define ztype(			   TYPE) Z_APPEND_##TYPE##_fixed_type(z	 )
+#define Z2DType(		   TYPE) Z_APPEND_##TYPE##_FixedType (Z2D)
+#define Z3DType(		   TYPE) Z_APPEND_##TYPE##_FixedType (Z3D)
+#define Z4DType(		   TYPE) Z_APPEND_##TYPE##_FixedType (Z4D)
+#define Z_TYPE(			   TYPE) Z_APPEND_##TYPE##_FIXED_TYPE(Z_ )
+#define Z_TYPE_VALUE_TYPE(	   TYPE) Z_INSERT_##TYPE##_FIXED_TYPE(Z_, _VALUE_TYPE	      )
+#define Z_TYPE_FIXED_VALUE_TYPE(   TYPE) Z_INSERT_##TYPE##_FIXED_TYPE(Z_, _FIXED_VALUE_TYPE   )
+#define Z_TYPE_VALUE_FORMAT(	   TYPE) Z_INSERT_##TYPE##_FIXED_TYPE(Z_, _VALUE_FORMAT	      )
+#define Z_TYPE_ENDIANNESS(	   TYPE) Z_INSERT_##TYPE##_FIXED_TYPE(Z_, _ENDIANNESS	      )
+#define Z_TYPE_BITS(		   TYPE) Z_INSERT_##TYPE##_FIXED_TYPE(Z_, _BITS		      )
+#define Z_TYPE_SIZE(		   TYPE) Z_INSERT_##TYPE##_FIXED_TYPE(Z_, _SIZE		      )
+#define Z_TYPE_BIAS(		   TYPE) Z_INSERT_##TYPE##_FIXED_TYPE(Z_, _BIAS		      )
+#define Z_TYPE_DECIMAL_DIGITS(	   TYPE) Z_INSERT_##TYPE##_FIXED_TYPE(Z_, _DECIMAL_DIGITS     )
+#define Z_TYPE_SIGNIFICAND_OFFSET( TYPE) Z_INSERT_##TYPE##_FIXED_TYPE(Z_, _SIGNIFICAND_OFFSET )
+#define Z_TYPE_SIGNIFICAND_BITS(   TYPE) Z_INSERT_##TYPE##_FIXED_TYPE(Z_, _SIGNIFICAND_BITS   )
+#define Z_TYPE_SIGNIFICAND_DIGITS( TYPE) Z_INSERT_##TYPE##_FIXED_TYPE(Z_, _SIGNIFICAND_DIGITS )
+#define Z_TYPE_EXPONENT_OFFSET(	   TYPE) Z_INSERT_##TYPE##_FIXED_TYPE(Z_, _EXPONENT_OFFSET    )
+#define Z_TYPE_EXPONENT_BITS(	   TYPE) Z_INSERT_##TYPE##_FIXED_TYPE(Z_, _EXPONENT_BITS      )
+#define Z_TYPE_EXPONENT_RADIX(	   TYPE) Z_INSERT_##TYPE##_FIXED_TYPE(Z_, _EXPONENT_RADIX     )
+#define Z_TYPE_EXPONENT_MINIMUM(   TYPE) Z_INSERT_##TYPE##_FIXED_TYPE(Z_, _EXPONENT_MINIMUM   )
+#define Z_TYPE_EXPONENT_MAXIMUM(   TYPE) Z_INSERT_##TYPE##_FIXED_TYPE(Z_, _EXPONENT_MAXIMUM   )
+#define Z_TYPE_EXPONENT_10_MINIMUM(TYPE) Z_INSERT_##TYPE##_FIXED_TYPE(Z_, _EXPONENT_10_MINIMUM)
+#define Z_TYPE_EXPONENT_10_MAXIMUM(TYPE) Z_INSERT_##TYPE##_FIXED_TYPE(Z_, _EXPONENT_10_MAXIMUM)
+#define Z_TYPE_SIGN_OFFSET(	   TYPE) Z_INSERT_##TYPE##_FIXED_TYPE(Z_, _SIGN_OFFSET	      )
+#define Z_TYPE_SIGN_BITS(	   TYPE) Z_INSERT_##TYPE##_FIXED_TYPE(Z_, _SIGN_BITS	      )
+#define Z_TYPE_EPSILON(		   TYPE) Z_INSERT_##TYPE##_FIXED_TYPE(Z_, _EPSILON	      )
+#define Z_TYPE_MINIMUM(		   TYPE) Z_INSERT_##TYPE##_FIXED_TYPE(Z_, _MINIMUM	      )
+#define Z_TYPE_MAXIMUM(		   TYPE) Z_INSERT_##TYPE##_FIXED_TYPE(Z_, _MAXIMUM	      )
+#define Z_TYPE_INFINITY(	   TYPE) Z_INSERT_##TYPE##_FIXED_TYPE(Z_, _INFINITY	      )
+#define Z_TYPE_NAN(		   TYPE) Z_INSERT_##TYPE##_FIXED_TYPE(Z_, _NAN		      )
+
+/* MARK: - Fundamental types */
+
+#if ('\0' - 1) > 0
+#	define Z_CHAR_IS_SIGNED FALSE
+#else
+#	define Z_CHAR_IS_SIGNED TRUE
+#endif
+
+#define Z_CHAR_BITS		  Z_DATA_MODEL_BITS(CHAR)
+
+typedef char			  zchar;
+#define Z_CHAR			  Z_SAME
+#define Z_CHAR_VALUE_TYPE	  Z_VALUE_TYPE_CHAR
+#define Z_CHAR_FIXED_VALUE_TYPE	  Z_TYPE_FIXED_VALUE_TYPE(CHAR)
+#define Z_CHAR_VALUE_FORMAT	  Z_TYPE_VALUE_FORMAT	 (CHAR)
+#define Z_CHAR_SIZE		  Z_TYPE_SIZE		 (CHAR)
+#define Z_CHAR_MINIMUM		  Z_TYPE_MINIMUM	 (CHAR)
+#define Z_CHAR_MAXIMUM		  Z_TYPE_MAXIMUM	 (CHAR)
+
+#define Z_UCHAR_BITS		  Z_DATA_MODEL_BITS(CHAR)
+
+typedef unsigned char		  zuchar;
+typedef Z2DType(UCHAR)		  Z2DUChar;
+typedef Z3DType(UCHAR)		  Z3DUChar;
+typedef Z4DType(UCHAR)		  Z4DUChar;
+#define Z_UCHAR			  Z_SUFFIX_U
+#define Z_UCHAR_VALUE_TYPE	  Z_VALUE_TYPE_UCHAR
+#define Z_UCHAR_FIXED_VALUE_TYPE  Z_TYPE_FIXED_VALUE_TYPE(UCHAR)
+#define Z_UCHAR_VALUE_FORMAT	  Z_TYPE_VALUE_FORMAT	 (UCHAR)
+#define Z_UCHAR_SIZE		  Z_TYPE_SIZE		 (UCHAR)
+#define Z_UCHAR_MINIMUM		  Z_TYPE_MINIMUM	 (UCHAR)
+#define Z_UCHAR_MAXIMUM		  Z_TYPE_MAXIMUM	 (UCHAR)
+
+#define Z_SCHAR_BITS		  Z_DATA_MODEL_BITS(CHAR)
+
+typedef signed char		  zschar;
+typedef Z2DType(SCHAR)		  Z2DSChar;
+typedef Z3DType(SCHAR)		  Z3DSChar;
+typedef Z4DType(SCHAR)		  Z4DSChar;
+#define Z_SCHAR			  Z_SAME
+#define Z_SCHAR_VALUE_TYPE	  Z_VALUE_TYPE_SCHAR
+#define Z_SCHAR_FIXED_VALUE_TYPE  Z_TYPE_FIXED_VALUE_TYPE(SCHAR)
+#define Z_SCHAR_VALUE_FORMAT	  Z_TYPE_VALUE_FORMAT	 (SCHAR)
+#define Z_SCHAR_SIZE		  Z_TYPE_SIZE		 (SCHAR)
+#define Z_SCHAR_MINIMUM		  Z_TYPE_MINIMUM	 (SCHAR)
+#define Z_SCHAR_MAXIMUM		  Z_TYPE_MAXIMUM	 (SCHAR)
+
+#define Z_USHORT_BITS		  Z_DATA_MODEL_BITS(SHORT)
+
+typedef unsigned short int	  zushort;
+typedef Z2DType(USHORT)		  Z2DUShort;
+typedef Z3DType(USHORT)		  Z3DUShort;
+typedef Z4DType(USHORT)		  Z4DUShort;
+#define Z_USHORT		  Z_SUFFIX_U
+#define Z_USHORT_VALUE_TYPE	  Z_VALUE_TYPE_USHORT
+#define Z_USHORT_FIXED_VALUE_TYPE Z_TYPE_FIXED_VALUE_TYPE(USHORT)
+#define Z_USHORT_VALUE_FORMAT	  Z_TYPE_VALUE_FORMAT	 (USHORT)
+#define Z_USHORT_ENDIANNESS	  Z_TYPE_ENDIANNESS	 (USHORT)
+#define Z_USHORT_SIZE		  Z_TYPE_SIZE		 (USHORT)
+#define Z_USHORT_MINIMUM	  Z_TYPE_MINIMUM	 (USHORT)
+#define Z_USHORT_MAXIMUM	  Z_TYPE_MAXIMUM	 (USHORT)
+
+#define Z_SSHORT_BITS		  Z_DATA_MODEL_BITS(SHORT)
+
+typedef signed short int	  zsshort;
+typedef Z2DType(SSHORT)		  Z2DSShort;
+typedef Z3DType(SSHORT)		  Z3DSShort;
+typedef Z4DType(SSHORT)		  Z4DSShort;
+#define Z_SSHORT		  Z_SAME
+#define Z_SSHORT_VALUE_TYPE	  Z_VALUE_TYPE_SSHORT
+#define Z_SSHORT_FIXED_VALUE_TYPE Z_TYPE_FIXED_VALUE_TYPE(SSHORT)
+#define Z_SSHORT_VALUE_FORMAT	  Z_TYPE_VALUE_FORMAT	 (SSHORT)
+#define Z_SSHORT_ENDIANNESS	  Z_TYPE_ENDIANNESS	 (SSHORT)
+#define Z_SSHORT_SIZE		  Z_TYPE_SIZE		 (SSHORT)
+#define Z_SSHORT_MINIMUM	  Z_TYPE_MINIMUM	 (SSHORT)
+#define Z_SSHORT_MAXIMUM	  Z_TYPE_MAXIMUM	 (SSHORT)
+
+#define Z_UINT_BITS		  Z_DATA_MODEL_BITS(INT)
+
+typedef unsigned int		  zuint;
+typedef Z2DType(UINT)		  Z2DUInt;
+typedef Z3DType(UINT)		  Z3DUInt;
+typedef Z4DType(UINT)		  Z4DUInt;
+#define Z_UINT			  Z_SUFFIX_U
+#define Z_UINT_VALUE_TYPE	  Z_VALUE_TYPE_UINT
+#define Z_UINT_FIXED_VALUE_TYPE	  Z_TYPE_FIXED_VALUE_TYPE(UINT)
+#define Z_UINT_VALUE_FORMAT	  Z_TYPE_VALUE_FORMAT	 (UINT)
+#define Z_UINT_ENDIANNESS	  Z_TYPE_ENDIANNESS	 (UINT)
+#define Z_UINT_SIZE		  Z_TYPE_SIZE		 (UINT)
+#define Z_UINT_MINIMUM		  Z_TYPE_MINIMUM	 (UINT)
+#define Z_UINT_MAXIMUM		  Z_TYPE_MAXIMUM	 (UINT)
+
+#define Z_SINT_BITS		  Z_DATA_MODEL_BITS(INT)
+
+typedef signed int		  zsint;
+typedef Z2DType(SINT)		  Z2DSInt;
+typedef Z3DType(SINT)		  Z3DSInt;
+typedef Z4DType(SINT)		  Z4DSInt;
+#define Z_SINT			  Z_SAME
+#define Z_SINT_VALUE_TYPE	  Z_VALUE_TYPE_SINT
+#define Z_SINT_FIXED_VALUE_TYPE	  Z_TYPE_FIXED_VALUE_TYPE(SINT)
+#define Z_SINT_VALUE_FORMAT	  Z_TYPE_VALUE_FORMAT	 (SINT)
+#define Z_SINT_ENDIANNESS	  Z_TYPE_ENDIANNESS	 (SINT)
+#define Z_SINT_SIZE		  Z_TYPE_SIZE		 (SINT)
+#define Z_SINT_MINIMUM		  Z_TYPE_MINIMUM	 (SINT)
+#define Z_SINT_MAXIMUM		  Z_TYPE_MAXIMUM	 (SINT)
+
+#define Z_ULONG_BITS		  Z_DATA_MODEL_BITS(LONG)
+
+typedef unsigned long int	  zulong;
+typedef Z2DType(ULONG)		  Z2DULong;
+typedef Z3DType(ULONG)		  Z3DULong;
+typedef Z4DType(ULONG)		  Z4DULong;
+#define Z_ULONG			  Z_SUFFIX_UL
+#define Z_ULONG_VALUE_TYPE	  Z_VALUE_TYPE_ULONG
+#define Z_ULONG_FIXED_VALUE_TYPE  Z_TYPE_FIXED_VALUE_TYPE(ULONG)
+#define Z_ULONG_VALUE_FORMAT	  Z_TYPE_VALUE_FORMAT	 (ULONG)
+#define Z_ULONG_ENDIANNESS	  Z_TYPE_ENDIANNESS	 (ULONG)
+#define Z_ULONG_SIZE		  Z_TYPE_SIZE		 (ULONG)
+#define Z_ULONG_MINIMUM		  Z_TYPE_MINIMUM	 (ULONG)
+#define Z_ULONG_MAXIMUM		  Z_TYPE_MAXIMUM	 (ULONG)
+
+#define Z_SLONG_BITS		  Z_DATA_MODEL_BITS(LONG)
+
+typedef signed long int		  zslong;
+typedef Z2DType(SLONG)		  Z2DSLong;
+typedef Z3DType(SLONG)		  Z3DSLong;
+typedef Z4DType(SLONG)		  Z4DSLong;
+#define Z_SLONG			  Z_SUFFIX_L
+#define Z_SLONG_VALUE_TYPE	  Z_VALUE_TYPE_SLONG
+#define Z_SLONG_FIXED_VALUE_TYPE  Z_TYPE_FIXED_VALUE_TYPE(SLONG)
+#define Z_SLONG_VALUE_FORMAT	  Z_TYPE_VALUE_FORMAT	 (SLONG)
+#define Z_SLONG_ENDIANNESS	  Z_TYPE_ENDIANNESS	 (SLONG)
+#define Z_SLONG_SIZE		  Z_TYPE_SIZE		 (SLONG)
+#define Z_SLONG_MINIMUM		  Z_TYPE_MINIMUM	 (SLONG)
+#define Z_SLONG_MAXIMUM		  Z_TYPE_MAXIMUM	 (SLONG)
+
+#if Z_LANGUAGE_HAS_TYPE(C, LLONG) || Z_LANGUAGE_HAS_TYPE(CPP, LLONG)
+
+#	define Z_ULLONG_BITS		 Z_DATA_MODEL_BITS(LLONG)
+
+	typedef unsigned long long int	 zullong;
+	typedef Z2DType(ULLONG)		 Z2DULLong;
+	typedef Z3DType(ULLONG)		 Z3DULLong;
+	typedef Z4DType(ULLONG)		 Z4DULLong;
+#	define Z_ULLONG			 Z_SUFFIX_LL
+#	define Z_ULLONG_VALUE_TYPE	 Z_VALUE_TYPE_ULLONG
+#	define Z_ULLONG_FIXED_VALUE_TYPE Z_TYPE_FIXED_VALUE_TYPE(ULLONG)
+#	define Z_ULLONG_VALUE_FORMAT	 Z_TYPE_VALUE_FORMAT	(ULLONG)
+#	define Z_ULLONG_ENDIANNESS	 Z_TYPE_ENDIANNESS	(ULLONG)
+#	define Z_ULLONG_SIZE		 Z_TYPE_SIZE		(ULLONG)
+#	define Z_ULLONG_MINIMUM		 Z_TYPE_MINIMUM		(ULLONG)
+#	define Z_ULLONG_MAXIMUM		 Z_TYPE_MAXIMUM		(ULLONG)
+
+#	define Z_SLLONG_BITS		 Z_DATA_MODEL_BITS(LLONG)
+
+	typedef signed long long int	 zsllong;
+	typedef Z2DType(SLLONG)		 Z2DSLLong;
+	typedef Z3DType(SLLONG)		 Z3DSLLong;
+	typedef Z4DType(SLLONG)		 Z4DSLLong;
+#	define Z_SLLONG			 Z_SUFFIX_LL
+#	define Z_SLLONG_VALUE_TYPE	 Z_VALUE_TYPE_SLLONG
+#	define Z_SLLONG_FIXED_VALUE_TYPE Z_TYPE_FIXED_VALUE_TYPE(SLLONG)
+#	define Z_SLLONG_VALUE_FORMAT	 Z_TYPE_VALUE_FORMAT	(SLLONG)
+#	define Z_SLLONG_ENDIANNESS	 Z_TYPE_ENDIANNESS	(SLLONG)
+#	define Z_SLLONG_SIZE		 Z_TYPE_SIZE		(SLLONG)
+#	define Z_SLLONG_MINIMUM		 Z_TYPE_MINIMUM		(SLLONG)
+#	define Z_SLLONG_MAXIMUM		 Z_TYPE_MAXIMUM		(SLLONG)
+
+#	define Z_LLONG
+
+#endif
+
+#if Z_LANGUAGE_HAS_TYPE(C, FLOAT)
+
+#	define Z_FLOAT_FIXED_VALUE_TYPE	   Z_FLOATING_POINT_FIXED_VALUE_TYPE(FLOAT)
+
+	typedef float			   zfloat;
+	typedef Z2DType(FLOAT)		   Z2DFloat;
+	typedef Z3DType(FLOAT)		   Z3DFloat;
+	typedef Z4DType(FLOAT)		   Z4DFloat;
+#	define Z_FLOAT			   Z_SUFFIX_F
+#	define Z_FLOAT_VALUE_TYPE	   Z_VALUE_TYPE_FLOAT
+#	define Z_FLOAT_VALUE_FORMAT	   Z_TYPE_VALUE_FORMAT	     (FLOAT)
+#	define Z_FLOAT_BITS		   Z_TYPE_BITS		     (FLOAT)
+#	define Z_FLOAT_SIZE		   Z_TYPE_SIZE		     (FLOAT)
+#	define Z_FLOAT_BIAS		   Z_TYPE_BIAS		     (FLOAT)
+#	define Z_FLOAT_DECIMAL_DIGITS	   Z_TYPE_DECIMAL_DIGITS     (FLOAT)
+#	define Z_FLOAT_SIGNIFICAND_OFFSET  Z_TYPE_SIGNIFICAND_OFFSET (FLOAT)
+#	define Z_FLOAT_SIGNIFICAND_BITS	   Z_TYPE_SIGNIFICAND_BITS   (FLOAT)
+#	define Z_FLOAT_SIGNIFICAND_DIGITS  Z_TYPE_SIGNIFICAND_DIGITS (FLOAT)
+#	define Z_FLOAT_EXPONENT_OFFSET	   Z_TYPE_EXPONENT_OFFSET    (FLOAT)
+#	define Z_FLOAT_EXPONENT_BITS	   Z_TYPE_EXPONENT_BITS	     (FLOAT)
+#	define Z_FLOAT_EXPONENT_RADIX	   Z_TYPE_EXPONENT_RADIX     (FLOAT)
+#	define Z_FLOAT_EXPONENT_MINIMUM	   Z_TYPE_EXPONENT_MINIMUM   (FLOAT)
+#	define Z_FLOAT_EXPONENT_MAXIMUM	   Z_TYPE_EXPONENT_MAXIMUM   (FLOAT)
+#	define Z_FLOAT_EXPONENT_10_MINIMUM Z_TYPE_EXPONENT_10_MINIMUM(FLOAT)
+#	define Z_FLOAT_EXPONENT_10_MAXIMUM Z_TYPE_EXPONENT_10_MAXIMUM(FLOAT)
+#	define Z_FLOAT_SIGN_OFFSET	   Z_TYPE_SIGN_OFFSET	     (FLOAT)
+#	define Z_FLOAT_SIGN_BITS	   Z_TYPE_SIGN_BITS	     (FLOAT)
+#	define Z_FLOAT_EPSILON		   Z_TYPE_EPSILON	     (FLOAT)
+#	define Z_FLOAT_MINIMUM		   Z_TYPE_MINIMUM	     (FLOAT)
+#	define Z_FLOAT_MAXIMUM		   Z_TYPE_MAXIMUM	     (FLOAT)
+#	define Z_FLOAT_INFINITY		   Z_TYPE_INFINITY	     (FLOAT)
+#	define Z_FLOAT_NAN		   Z_TYPE_NAN		     (FLOAT)
+
+#endif
+
+#if Z_LANGUAGE_HAS_TYPE(C, DOUBLE)
+
+#	define Z_DOUBLE_FIXED_VALUE_TYPE    Z_FLOATING_POINT_FIXED_VALUE_TYPE(DOUBLE)
+
+	typedef double			    zdouble;
+	typedef Z2DType(DOUBLE)		    Z2DDouble;
+	typedef Z3DType(DOUBLE)		    Z3DDouble;
+	typedef Z4DType(DOUBLE)		    Z4DDouble;
+#	define Z_DOUBLE			    Z_SAME
+#	define Z_DOUBLE_VALUE_TYPE	    Z_VALUE_TYPE_DOUBLE
+#	define Z_DOUBLE_VALUE_FORMAT	    Z_TYPE_VALUE_FORMAT	      (DOUBLE)
+#	define Z_DOUBLE_BITS		    Z_TYPE_BITS		      (DOUBLE)
+#	define Z_DOUBLE_SIZE		    Z_TYPE_SIZE		      (DOUBLE)
+#	define Z_DOUBLE_BIAS		    Z_TYPE_BIAS		      (DOUBLE)
+#	define Z_DOUBLE_DECIMAL_DIGITS	    Z_TYPE_DECIMAL_DIGITS     (DOUBLE)
+#	define Z_DOUBLE_SIGNIFICAND_OFFSET  Z_TYPE_SIGNIFICAND_OFFSET (DOUBLE)
+#	define Z_DOUBLE_SIGNIFICAND_BITS    Z_TYPE_SIGNIFICAND_BITS   (DOUBLE)
+#	define Z_DOUBLE_SIGNIFICAND_DIGITS  Z_TYPE_SIGNIFICAND_DIGITS (DOUBLE)
+#	define Z_DOUBLE_EXPONENT_OFFSET	    Z_TYPE_EXPONENT_OFFSET    (DOUBLE)
+#	define Z_DOUBLE_EXPONENT_BITS	    Z_TYPE_EXPONENT_BITS      (DOUBLE)
+#	define Z_DOUBLE_EXPONENT_RADIX	    Z_TYPE_EXPONENT_RADIX     (DOUBLE)
+#	define Z_DOUBLE_EXPONENT_MINIMUM    Z_TYPE_EXPONENT_MINIMUM   (DOUBLE)
+#	define Z_DOUBLE_EXPONENT_MAXIMUM    Z_TYPE_EXPONENT_MAXIMUM   (DOUBLE)
+#	define Z_DOUBLE_EXPONENT_10_MINIMUM Z_TYPE_EXPONENT_10_MINIMUM(DOUBLE)
+#	define Z_DOUBLE_EXPONENT_10_MAXIMUM Z_TYPE_EXPONENT_10_MAXIMUM(DOUBLE)
+#	define Z_DOUBLE_SIGN_OFFSET	    Z_TYPE_SIGN_OFFSET	      (DOUBLE)
+#	define Z_DOUBLE_SIGN_BITS	    Z_TYPE_SIGN_BITS	      (DOUBLE)
+#	define Z_DOUBLE_EPSILON		    Z_TYPE_EPSILON	      (DOUBLE)
+#	define Z_DOUBLE_MINIMUM		    Z_TYPE_MINIMUM	      (DOUBLE)
+#	define Z_DOUBLE_MAXIMUM		    Z_TYPE_MAXIMUM	      (DOUBLE)
+#	define Z_DOUBLE_INFINITY	    Z_TYPE_INFINITY	      (DOUBLE)
+#	define Z_DOUBLE_NAN		    Z_TYPE_NAN		      (DOUBLE)
+
+#endif
+
+#if Z_LANGUAGE_HAS_TYPE(C, LDOUBLE) || Z_LANGUAGE_HAS_TYPE(CPP, LDOUBLE)
+
+#	define Z_LDOUBLE_FIXED_VALUE_TYPE    Z_FLOATING_POINT_FIXED_VALUE_TYPE(LDOUBLE)
+
+	typedef long double		     zldouble;
+	typedef Z2DType(LDOUBLE)	     Z2DLDouble;
+	typedef Z3DType(LDOUBLE)	     Z3DLDouble;
+	typedef Z4DType(LDOUBLE)	     Z4DLDouble;
+#	define Z_LDOUBLE		     Z_SUFFIX_L
+#	define Z_LDOUBLE_VALUE_TYPE	     Z_VALUE_TYPE_LDOUBLE
+#	define Z_LDOUBLE_VALUE_FORMAT	     Z_TYPE_VALUE_FORMAT       (LDOUBLE)
+#	define Z_LDOUBLE_BITS		     Z_TYPE_BITS	       (LDOUBLE)
+#	define Z_LDOUBLE_SIZE		     Z_TYPE_SIZE	       (LDOUBLE)
+#	define Z_LDOUBLE_BIAS		     Z_TYPE_BIAS	       (LDOUBLE)
+#	define Z_LDOUBLE_DECIMAL_DIGITS	     Z_TYPE_DECIMAL_DIGITS     (LDOUBLE)
+#	define Z_LDOUBLE_SIGNIFICAND_OFFSET  Z_TYPE_SIGNIFICAND_OFFSET (LDOUBLE)
+#	define Z_LDOUBLE_SIGNIFICAND_BITS    Z_TYPE_SIGNIFICAND_BITS   (LDOUBLE)
+#	define Z_LDOUBLE_SIGNIFICAND_DIGITS  Z_TYPE_SIGNIFICAND_DIGITS (LDOUBLE)
+#	define Z_LDOUBLE_EXPONENT_OFFSET     Z_TYPE_EXPONENT_OFFSET    (LDOUBLE)
+#	define Z_LDOUBLE_EXPONENT_BITS	     Z_TYPE_EXPONENT_BITS      (LDOUBLE)
+#	define Z_LDOUBLE_EXPONENT_RADIX	     Z_TYPE_EXPONENT_RADIX     (LDOUBLE)
+#	define Z_LDOUBLE_EXPONENT_MINIMUM    Z_TYPE_EXPONENT_MINIMUM   (LDOUBLE)
+#	define Z_LDOUBLE_EXPONENT_MAXIMUM    Z_TYPE_EXPONENT_MAXIMUM   (LDOUBLE)
+#	define Z_LDOUBLE_EXPONENT_10_MINIMUM Z_TYPE_EXPONENT_10_MINIMUM(LDOUBLE)
+#	define Z_LDOUBLE_EXPONENT_10_MAXIMUM Z_TYPE_EXPONENT_10_MAXIMUM(LDOUBLE)
+#	define Z_LDOUBLE_SIGN_OFFSET	     Z_TYPE_SIGN_OFFSET	       (LDOUBLE)
+#	define Z_LDOUBLE_SIGN_BITS	     Z_TYPE_SIGN_BITS	       (LDOUBLE)
+#	define Z_LDOUBLE_EPSILON	     Z_TYPE_EPSILON	       (LDOUBLE)
+#	define Z_LDOUBLE_MINIMUM	     Z_TYPE_MINIMUM	       (LDOUBLE)
+#	define Z_LDOUBLE_MAXIMUM	     Z_TYPE_MAXIMUM	       (LDOUBLE)
+#	define Z_LDOUBLE_INFINITY	     Z_TYPE_INFINITY	       (LDOUBLE)
+#	define Z_LDOUBLE_NAN		     Z_TYPE_NAN		       (LDOUBLE)
+
+#endif
+
+/* MARK: - Object size integral types */
+
+#define Z_USIZE_BITS		 Z_DATA_MODEL_BITS(SIZE)
+
+typedef ztype  (USIZE)		 zusize;
+typedef Z2DType(USIZE)		 Z2DUSize;
+typedef Z3DType(USIZE)		 Z3DUSize;
+typedef Z4DType(USIZE)		 Z4DUSize;
+#define Z_USIZE			 Z_TYPE			(USIZE)
+#define Z_USIZE_VALUE_TYPE	 Z_TYPE_VALUE_TYPE	(USIZE)
+#define Z_USIZE_FIXED_VALUE_TYPE Z_TYPE_FIXED_VALUE_TYPE(USIZE)
+#define Z_USIZE_VALUE_FORMAT	 Z_TYPE_VALUE_FORMAT	(USIZE)
+#define Z_USIZE_ENDIANNESS	 Z_TYPE_ENDIANNESS	(USIZE)
+#define Z_USIZE_SIZE		 Z_TYPE_SIZE		(USIZE)
+#define Z_USIZE_MINIMUM		 Z_TYPE_MINIMUM		(USIZE)
+#define Z_USIZE_MAXIMUM		 Z_TYPE_MAXIMUM		(USIZE)
+
+#define Z_SSIZE_BITS		 Z_DATA_MODEL_BITS(SIZE)
+
+typedef ztype  (SSIZE)		 zssize;
+typedef Z2DType(SSIZE)		 Z2DSSize;
+typedef Z3DType(SSIZE)		 Z3DSSize;
+typedef Z4DType(SSIZE)		 Z4DSSize;
+#define Z_SSIZE			 Z_TYPE			(SSIZE)
+#define Z_SSIZE_VALUE_TYPE	 Z_TYPE_VALUE_TYPE	(SSIZE)
+#define Z_SSIZE_FIXED_VALUE_TYPE Z_TYPE_FIXED_VALUE_TYPE(SSIZE)
+#define Z_SSIZE_VALUE_FORMAT	 Z_TYPE_VALUE_FORMAT	(SSIZE)
+#define Z_SSIZE_ENDIANNESS	 Z_TYPE_ENDIANNESS	(SSIZE)
+#define Z_SSIZE_SIZE		 Z_TYPE_SIZE		(SSIZE)
+#define Z_SSIZE_MINIMUM		 Z_TYPE_MINIMUM		(SSIZE)
+#define Z_SSIZE_MAXIMUM		 Z_TYPE_MAXIMUM		(SSIZE)
+
+/* MARK: - Maximum size integral types */
+
+#if defined(Z_UINT128)
+#	define Z_UINTMAX_BITS 128
+#elif defined(Z_UINT64)
+#	define Z_UINTMAX_BITS 64
+#elif defined(Z_ULLONG)
+#	define Z_UINTMAX_BITS Z_ULLONG_BITS
+#else
+#	define Z_UINTMAX_BITS Z_ULONG_BITS
+#endif
+
+typedef ztype  (UINTMAX)	   zuintmax;
+typedef Z2DType(UINTMAX)	   Z2DUIntMax;
+typedef Z3DType(UINTMAX)	   Z3DUIntMax;
+typedef Z4DType(UINTMAX)	   Z4DUIntMax;
+#define Z_UINTMAX		   Z_TYPE		  (UINTMAX)
+#define Z_UINTMAX_VALUE_TYPE	   Z_TYPE_VALUE_TYPE	  (UINTMAX)
+#define Z_UINTMAX_FIXED_VALUE_TYPE Z_TYPE_FIXED_VALUE_TYPE(UINTMAX)
+#define Z_UINTMAX_VALUE_FORMAT	   Z_TYPE_VALUE_FORMAT	  (UINTMAX)
+#define Z_UINTMAX_ENDIANNESS	   Z_TYPE_ENDIANNESS	  (UINTMAX)
+#define Z_UINTMAX_SIZE		   Z_TYPE_SIZE		  (UINTMAX)
+#define Z_UINTMAX_MINIMUM	   Z_TYPE_MINIMUM	  (UINTMAX)
+#define Z_UINTMAX_MAXIMUM	   Z_TYPE_MAXIMUM	  (UINTMAX)
+
+#if defined(Z_SINT128)
+#	define Z_SINTMAX_BITS 128
+#elif defined(Z_SINT64)
+#	define Z_SINTMAX_BITS 64
+#elif defined(Z_SLLONG)
+#	define Z_SINTMAX_BITS Z_SLLONG_BITS
+#else
+#	define Z_SINTMAX_BITS Z_SLONG_BITS
+#endif
+
+typedef ztype  (SINTMAX)	   zsintmax;
+typedef Z2DType(SINTMAX)	   Z2DSIntMax;
+typedef Z3DType(SINTMAX)	   Z3DSIntMax;
+typedef Z4DType(SINTMAX)	   Z4DSIntMax;
+#define Z_SINTMAX		   Z_TYPE		  (SINTMAX)
+#define Z_SINTMAX_VALUE_TYPE	   Z_TYPE_VALUE_TYPE	  (SINTMAX)
+#define Z_SINTMAX_FIXED_VALUE_TYPE Z_TYPE_FIXED_VALUE_TYPE(SINTMAX)
+#define Z_SINTMAX_VALUE_FORMAT	   Z_TYPE_VALUE_FORMAT	  (SINTMAX)
+#define Z_SINTMAX_ENDIANNESS	   Z_TYPE_ENDIANNESS	  (SINTMAX)
+#define Z_SINTMAX_SIZE		   Z_TYPE_SIZE		  (SINTMAX)
+#define Z_SINTMAX_MINIMUM	   Z_TYPE_MINIMUM	  (SINTMAX)
+#define Z_SINTMAX_MAXIMUM	   Z_TYPE_MAXIMUM	  (SINTMAX)
+
+#if Z_UINTMAX_BITS >= Z_SINTMAX_BITS
+
+	typedef zuintmax		 zintmax;
+#	define Z_INTMAX			 Z_UINTMAX
+#	define Z_INTMAX_VALUE_TYPE	 Z_UINTMAX_VALUE_TYPE
+#	define Z_INTMAX_FIXED_VALUE_TYPE Z_UINTMAX_FIXED_VALUE_TYPE
+#	define Z_INTMAX_VALUE_FORMAT	 Z_UINTMAX_VALUE_FORMAT
+#	define Z_INTMAX_ENDIANNESS	 Z_UINTMAX_ENDIANNESS
+#	define Z_INTMAX_BITS		 Z_UINTMAX_BITS
+#	define Z_INTMAX_SIZE		 Z_UINTMAX_SIZE
+
+#else
+
+	typedef zsintmax		 zintmax;
+#	define Z_INTMAX			 Z_SINTMAX
+#	define Z_INTMAX_VALUE_TYPE	 Z_SINTMAX_VALUE_TYPE
+#	define Z_INTMAX_FIXED_VALUE_TYPE Z_SINTMAX_FIXED_VALUE_TYPE
+#	define Z_INTMAX_VALUE_FORMAT	 Z_SINTMAX_VALUE_FORMAT
+#	define Z_INTMAX_ENDIANNESS	 Z_SINTMAX_ENDIANNESS
+#	define Z_INTMAX_BITS		 Z_SINTMAX_BITS
+#	define Z_INTMAX_SIZE		 Z_SINTMAX_SIZE
+
+#endif
+
+/* MARK: - Pointer size integral types */
+
+#define Z_POINTER_BITS		   Z_DATA_MODEL_BITS(POINTER)
+#define Z_POINTER_SIZE		   (Z_UINTPTR_BITS / 8)
+
+#define Z_UINTPTR_BITS		   Z_POINTER_BITS
+
+typedef ztype  (UINTPTR)	   zuintptr;
+typedef Z2DType(UINTPTR)	   Z2DUIntPtr;
+typedef Z3DType(UINTPTR)	   Z3DUIntPtr;
+typedef Z4DType(UINTPTR)	   Z4DUIntPtr;
+#define Z_UINTPTR		   Z_TYPE		  (UINTPTR)
+#define Z_UINTPTR_VALUE_TYPE	   Z_TYPE_VALUE_TYPE	  (UINTPTR)
+#define Z_UINTPTR_FIXED_VALUE_TYPE Z_TYPE_FIXED_VALUE_TYPE(UINTPTR)
+#define Z_UINTPTR_VALUE_FORMAT	   Z_TYPE_VALUE_FORMAT	  (UINTPTR)
+#define Z_UINTPTR_ENDIANNESS	   Z_TYPE_ENDIANNESS	  (UINTPTR)
+#define Z_UINTPTR_SIZE		   Z_TYPE_SIZE		  (UINTPTR)
+#define Z_UINTPTR_MINIMUM	   Z_TYPE_MINIMUM	  (UINTPTR)
+#define Z_UINTPTR_MAXIMUM	   Z_TYPE_MAXIMUM	  (UINTPTR)
+
+#define Z_SINTPTR_BITS		   Z_POINTER_BITS
+
+typedef ztype  (SINTPTR)	   zsintptr;
+typedef Z2DType(SINTPTR)	   Z2DSIntPtr;
+typedef Z3DType(SINTPTR)	   Z3DSIntPtr;
+typedef Z4DType(SINTPTR)	   Z4DSIntPtr;
+#define Z_SINTPTR		   Z_TYPE		  (SINTPTR)
+#define Z_SINTPTR_VALUE_TYPE	   Z_TYPE_VALUE_TYPE	  (SINTPTR)
+#define Z_SINTPTR_FIXED_VALUE_TYPE Z_TYPE_FIXED_VALUE_TYPE(SINTPTR)
+#define Z_SINTPTR_VALUE_FORMAT	   Z_TYPE_VALUE_FORMAT	  (SINTPTR)
+#define Z_SINTPTR_ENDIANNESS	   Z_TYPE_ENDIANNESS	  (SINTPTR)
+#define Z_SINTPTR_SIZE		   Z_TYPE_SIZE		  (SINTPTR)
+#define Z_SINTPTR_MINIMUM	   Z_TYPE_MINIMUM	  (SINTPTR)
+#define Z_SINTPTR_MAXIMUM	   Z_TYPE_MAXIMUM	  (SINTPTR)
+
+/* MARK: - Optimum maximum size integral types */
+
+#if Z_CPU_BITS(TOP_INTEGER) >= 128 && defined(Z_UINT128)
+#	define Z_UINTTOP_BITS 128
+
+#elif Z_CPU_BITS(TOP_INTEGER) >= 64 && defined(Z_UINT64)
+#	define Z_UINTTOP_BITS 64
+
+#elif Z_CPU_BITS(TOP_INTEGER) == 32
+#	define Z_UINTTOP_BITS 32
+
+#else
+#	define Z_UINTTOP_BITS 16
+#endif
+
+typedef ztype  (UINTTOP)	   zuinttop;
+typedef Z2DType(UINTTOP)	   Z2DUIntTop;
+typedef Z3DType(UINTTOP)	   Z3DUIntTop;
+typedef Z4DType(UINTTOP)	   Z4DUIntTop;
+#define Z_UINTTOP		   Z_TYPE		  (UINTTOP)
+#define Z_UINTTOP_VALUE_TYPE	   Z_TYPE_VALUE_TYPE	  (UINTTOP)
+#define Z_UINTTOP_FIXED_VALUE_TYPE Z_TYPE_FIXED_VALUE_TYPE(UINTTOP)
+#define Z_UINTTOP_VALUE_FORMAT	   Z_TYPE_VALUE_FORMAT	  (UINTTOP)
+#define Z_UINTTOP_ENDIANNESS	   Z_TYPE_ENDIANNESS	  (UINTTOP)
+#define Z_UINTTOP_SIZE		   Z_TYPE_SIZE		  (UINTTOP)
+#define Z_UINTTOP_MINIMUM	   Z_TYPE_MINIMUM	  (UINTTOP)
+#define Z_UINTTOP_MAXIMUM	   Z_TYPE_MAXIMUM	  (UINTTOP)
+
+#if Z_CPU_BITS(TOP_INTEGER) >= 128 && defined(Z_SINT128)
+#	define Z_SINTTOP_BITS 128
+
+#elif Z_CPU_BITS(TOP_INTEGER) >= 64 && defined(Z_SINT64)
+#	define Z_SINTTOP_BITS 64
+
+#elif Z_CPU_BITS(TOP_INTEGER) == 32
+#	define Z_SINTTOP_BITS 32
+
+#else
+#	define Z_SINTTOP_BITS 16
+#endif
+
+typedef ztype  (SINTTOP)	   zsinttop;
+typedef Z2DType(SINTTOP)	   Z2DSIntTop;
+typedef Z3DType(SINTTOP)	   Z3DSIntTop;
+typedef Z4DType(SINTTOP)	   Z4DSIntTop;
+#define Z_SINTTOP		   Z_TYPE		  (SINTTOP)
+#define Z_SINTTOP_VALUE_TYPE	   Z_TYPE_VALUE_TYPE	  (SINTTOP)
+#define Z_SINTTOP_FIXED_VALUE_TYPE Z_TYPE_FIXED_VALUE_TYPE(SINTTOP)
+#define Z_SINTTOP_VALUE_FORMAT	   Z_TYPE_VALUE_FORMAT	  (SINTTOP)
+#define Z_SINTTOP_ENDIANNESS	   Z_TYPE_ENDIANNESS	  (SINTTOP)
+#define Z_SINTTOP_SIZE		   Z_TYPE_SIZE		  (SINTTOP)
+#define Z_SINTTOP_MINIMUM	   Z_TYPE_MINIMUM	  (SINTTOP)
+#define Z_SINTTOP_MAXIMUM	   Z_TYPE_MAXIMUM	  (SINTTOP)
+
+#if Z_UINTTOP_BITS >= Z_SINTTOP_BITS
+
+	typedef zuinttop		 zinttop;
+#	define Z_INTTOP			 Z_UINTTOP
+#	define Z_INTTOP_VALUE_TYPE	 Z_UINTTOP_VALUE_TYPE
+#	define Z_INTTOP_FIXED_VALUE_TYPE Z_UINTTOP_FIXED_VALUE_TYPE
+#	define Z_INTTOP_VALUE_FORMAT	 Z_UINTTOP_VALUE_FORMAT
+#	define Z_INTTOP_ENDIANNESS	 Z_UINTTOP_ENDIANNESS
+#	define Z_INTTOP_BITS		 Z_UINTTOP_BITS
+#	define Z_INTTOP_SIZE		 Z_UINTTOP_SIZE
+
+#else
+
+	typedef zsinttop		 zinttop;
+#	define Z_INTTOP			 Z_SINTTOP
+#	define Z_INTTOP_VALUE_TYPE	 Z_SINTTOP_VALUE_TYPE
+#	define Z_INTTOP_FIXED_VALUE_TYPE Z_SINTTOP_FIXED_VALUE_TYPE
+#	define Z_INTTOP_VALUE_FORMAT	 Z_SINTTOP_VALUE_FORMAT
+#	define Z_INTTOP_ENDIANNESS	 Z_SINTTOP_ENDIANNESS
+#	define Z_INTTOP_BITS		 Z_SINTTOP_BITS
+#	define Z_INTTOP_SIZE		 Z_SINTTOP_SIZE
+
+#endif
+
+/* MARK: - Default types */
+
+typedef zuint8			   zboolean;
+typedef Z2DUInt8		   Z2DBoolean;
+typedef Z3DUInt8		   Z3DBoolean;
+typedef Z4DUInt8		   Z4DBoolean;
+#define Z_BOOLEAN_VALUE_TYPE	   Z_UINT8_VALUE_TYPE
+#define Z_BOOLEAN_FIXED_VALUE_TYPE Z_UINT8_FIXED_VALUE_TYPE
+#define Z_BOOLEAN_VALUE_FORMAT	   Z_UINT8_VALUE_FORMAT
+#define Z_BOOLEAN_BITS		   Z_UINT8_BITS
+#define Z_BOOLEAN_SIZE		   Z_UINT8_SIZE
+
+#if defined(Z_USE_NATURAL_UINT16)
+#	define Z_NATURAL_BITS 16
+
+#elif defined(Z_USE_NATURAL_UINT32)
+#	define Z_NATURAL_BITS 32
+
+#elif defined(Z_USE_NATURAL_UINT64) && defined(Z_UINT64)
+#	define Z_NATURAL_BITS 64
+
+#elif defined(Z_USE_NATURAL_UINT128) && defined(Z_UINT128)
+#	define Z_NATURAL_BITS 128
+#else
+#	define Z_NATURAL_BITS Z_ULONG_BITS
+#endif
+
+typedef ztype  (NATURAL)	   znatural;
+typedef Z2DType(NATURAL)	   Z2DNatural;
+typedef Z3DType(NATURAL)	   Z3DNatural;
+typedef Z4DType(NATURAL)	   Z4DNatural;
+#define Z_NATURAL		   Z_TYPE		  (NATURAL)
+#define Z_NATURAL_VALUE_TYPE	   Z_TYPE_VALUE_TYPE	  (NATURAL)
+#define Z_NATURAL_FIXED_VALUE_TYPE Z_TYPE_FIXED_VALUE_TYPE(NATURAL)
+#define Z_NATURAL_VALUE_FORMAT	   Z_TYPE_VALUE_FORMAT	  (NATURAL)
+#define Z_NATURAL_ENDIANNESS	   Z_TYPE_ENDIANNESS	  (NATURAL)
+#define Z_NATURAL_SIZE		   Z_TYPE_SIZE		  (NATURAL)
+#define Z_NATURAL_MINIMUM	   Z_TYPE_MINIMUM	  (NATURAL)
+#define Z_NATURAL_MAXIMUM	   Z_TYPE_MAXIMUM	  (NATURAL)
+
+#if defined(Z_USE_INTEGER_SINT16)
+#	define Z_INTEGER_BITS 16
+
+#elif defined(Z_USE_INTEGER_SINT32)
+#	define Z_INTEGER_BITS 32
+
+#elif defined(Z_USE_INTEGER_SINT64) && defined(Z_SINT64)
+#	define Z_INTEGER_BITS 64
+
+#elif defined(Z_USE_INTEGER_SINT128) && defined(Z_SINT128)
+#	define Z_INTEGER_BITS 128
+#else
+#	define Z_INTEGER_BITS Z_SLONG_BITS
+#endif
+
+typedef ztype  (INTEGER)	   zinteger;
+typedef Z2DType(INTEGER)	   Z2DInteger;
+typedef Z3DType(INTEGER)	   Z3DInteger;
+typedef Z4DType(INTEGER)	   Z4DInteger;
+#define Z_INTEGER		   Z_TYPE		  (INTEGER)
+#define Z_INTEGER_VALUE_TYPE	   Z_TYPE_VALUE_TYPE	  (INTEGER)
+#define Z_INTEGER_FIXED_VALUE_TYPE Z_TYPE_FIXED_VALUE_TYPE(INTEGER)
+#define Z_INTEGER_VALUE_FORMAT	   Z_TYPE_VALUE_FORMAT	  (INTEGER)
+#define Z_INTEGER_ENDIANNESS	   Z_TYPE_ENDIANNESS	  (INTEGER)
+#define Z_INTEGER_SIZE		   Z_TYPE_SIZE		  (INTEGER)
+#define Z_INTEGER_MINIMUM	   Z_TYPE_MINIMUM	  (INTEGER)
+#define Z_INTEGER_MAXIMUM	   Z_TYPE_MAXIMUM	  (INTEGER)
+
+#if defined(Z_USE_REAL_FLOAT16) && defined(Z_FLOAT16)
+#	define Z_REAL_FIXED_VALUE_TYPE Z_VALUE_TYPE_FLOAT16
+
+#elif defined(Z_USE_REAL_FLOAT32) && defined(Z_FLOAT32)
+#	define Z_REAL_FIXED_VALUE_TYPE Z_VALUE_TYPE_FLOAT32
+
+#elif defined(Z_USE_REAL_FLOAT64) && defined(Z_FLOAT64)
+#	define Z_REAL_FIXED_VALUE_TYPE Z_VALUE_TYPE_FLOAT64
+
+#elif defined(Z_USE_REAL_FLOAT128) && defined(Z_FLOAT128)
+#	define Z_REAL_FIXED_VALUE_TYPE Z_VALUE_TYPE_FLOAT128
+
+#elif defined(Z_USE_REAL_FLOAT80_X87) && defined(Z_FLOAT80_X87)
+#	define Z_REAL_FIXED_VALUE_TYPE Z_VALUE_TYPE_FLOAT80_X87
+
+#elif defined(Z_USE_REAL_FLOAT96_X87) && defined(Z_FLOAT96_X87)
+#	define Z_REAL_FIXED_VALUE_TYPE Z_VALUE_TYPE_FLOAT96_X87
+
+#elif defined(Z_USE_REAL_FLOAT128_X87) && defined(Z_FLOAT128_X87)
+#	define Z_REAL_FIXED_VALUE_TYPE Z_VALUE_TYPE_FLOAT128_X87
+
+#elif defined(Z_USE_REAL_FLOAT) && defined(Z_FLOAT)
+#	define Z_REAL_FIXED_VALUE_TYPE Z_FLOAT_FIXED_VALUE_TYPE
+
+#elif defined(Z_USE_REAL_LDOUBLE) && defined(Z_LDOUBLE)
+#	define Z_REAL_FIXED_VALUE_TYPE Z_DOUBLE_FIXED_VALUE_TYPE
+
+#elif defined(Z_DOUBLE)
+#	define Z_REAL_FIXED_VALUE_TYPE Z_DOUBLE_FIXED_VALUE_TYPE
+#endif
+
+#ifdef Z_REAL_FIXED_VALUE_TYPE
+
+	typedef ztype  (REAL)		  zreal;
+	typedef Z2DType(REAL)		  Z2DReal;
+	typedef Z3DType(REAL)		  Z3DReal;
+	typedef Z4DType(REAL)		  Z4DReal;
+	typedef Z2DReal			  Z2D;
+	typedef Z3DReal			  Z3D;
+	typedef Z4DReal			  Z4D;
+#	define Z_REAL			  Z_TYPE		    (REAL)
+#	define Z_REAL_VALUE_TYPE	  Z_TYPE_VALUE_TYPE	    (REAL)
+#	define Z_REAL_VALUE_FORMAT	  Z_TYPE_VALUE_FORMAT	    (REAL)
+#	define Z_REAL_BITS		  Z_TYPE_BITS		    (REAL)
+#	define Z_REAL_SIZE		  Z_TYPE_SIZE		    (REAL)
+#	define Z_REAL_BIAS		  Z_TYPE_BIAS		    (REAL)
+#	define Z_REAL_DECIMAL_DIGITS	  Z_TYPE_DECIMAL_DIGITS	    (REAL)
+#	define Z_REAL_SIGNIFICAND_OFFSET  Z_TYPE_SIGNIFICAND_OFFSET (REAL)
+#	define Z_REAL_SIGNIFICAND_BITS	  Z_TYPE_SIGNIFICAND_BITS   (REAL)
+#	define Z_REAL_SIGNIFICAND_DIGITS  Z_TYPE_SIGNIFICAND_DIGITS (REAL)
+#	define Z_REAL_EXPONENT_OFFSET	  Z_TYPE_EXPONENT_OFFSET    (REAL)
+#	define Z_REAL_EXPONENT_BITS	  Z_TYPE_EXPONENT_BITS	    (REAL)
+#	define Z_REAL_EXPONENT_RADIX	  Z_TYPE_EXPONENT_RADIX	    (REAL)
+#	define Z_REAL_EXPONENT_MINIMUM	  Z_TYPE_EXPONENT_MINIMUM   (REAL)
+#	define Z_REAL_EXPONENT_MAXIMUM	  Z_TYPE_EXPONENT_MAXIMUM   (REAL)
+#	define Z_REAL_EXPONENT_10_MINIMUM Z_TYPE_EXPONENT_10_MINIMUM(REAL)
+#	define Z_REAL_EXPONENT_10_MAXIMUM Z_TYPE_EXPONENT_10_MAXIMUM(REAL)
+#	define Z_REAL_SIGN_OFFSET	  Z_TYPE_SIGN_OFFSET	    (REAL)
+#	define Z_REAL_SIGN_BITS		  Z_TYPE_SIGN_BITS	    (REAL)
+#	define Z_REAL_EPSILON		  Z_TYPE_EPSILON	    (REAL)
+#	define Z_REAL_MINIMUM		  Z_TYPE_MINIMUM	    (REAL)
+#	define Z_REAL_MAXIMUM		  Z_TYPE_MAXIMUM	    (REAL)
+#	define Z_REAL_INFINITY		  Z_TYPE_INFINITY	    (REAL)
+#	define Z_REAL_NAN		  Z_TYPE_NAN		    (REAL)
+
+#endif
+
+/* MARK: - Status type */
+
+typedef zsint ZStatus;
+
+/* MARK: - Range types */
+
+typedef struct {zuint8	index, size;} ZRangeUInt8;
+typedef struct {zuint16 index, size;} ZRangeUInt16;
+typedef struct {zuint32 index, size;} ZRangeUInt32;
+
+#ifdef Z_UINT64
+	typedef struct {zuint64 index, size;} ZRangeUInt64;
+#endif
+
+#ifdef Z_UINT128
+	typedef struct {zuint128 index, size;} ZRangeUInt128;
+#endif
+
+#define ZRangeType(TYPE) Z_APPEND_##TYPE##_FixedType(ZRange)
+
+typedef ZRangeType(UCHAR ) ZRangeUChar;
+typedef ZRangeType(USHORT) ZRangeUShort;
+typedef ZRangeType(UINT	 ) ZRangeUInt;
+typedef ZRangeType(ULONG ) ZRangeULong;
+
+#ifdef Z_ULLONG
+	typedef ZRangeType(ULLONG) ZRangeULLong;
+#else
+	typedef ZRangeULong ZRangeULLong;
+#endif
+
+typedef ZRangeType(USIZE  ) ZRangeUSize;
+typedef ZRangeType(UINTMAX) ZRangeUIntMax;
+typedef ZRangeType(UINTPTR) ZRangeUIntPtr;
+typedef ZRangeType(UINTTOP) ZRangeUIntTop;
+typedef ZRangeType(NATURAL) ZRangeNatural;
+typedef ZRangeUSize	    ZRange;
+
+/* MARK: - Value component access types */
+
+Z_DEFINE_STRICT_UNION (
+	zuint8 value_uint8;
+	zsint8 value_sint8;
+) Z8Bit;
+
+Z_DEFINE_STRICT_UNION_BEGIN
+	zuint16 value_uint16;
+	zsint16 value_sint16;
+	zuint8	array_uint8[2];
+	zsint8	array_sint8[2];
+
+	struct {Z_ENDIANIZED_MEMBERS(16, 2) (
+		zuint8 index1,
+		zuint8 index0
+	)} values_uint8;
+
+	struct {Z_ENDIANIZED_MEMBERS(16, 2) (
+		zsint8 index1,
+		zsint8 index0
+	)} values_sint8;
+Z_DEFINE_STRICT_UNION_END Z16Bit;
+
+Z_DEFINE_STRICT_UNION_BEGIN
+	zuint32 value_uint32;
+	zsint32 value_sint32;
+	zuint16 array_uint16[2];
+	zsint16 array_sint16[2];
+	zuint8	array_uint8 [4];
+	zsint8	array_sint8 [4];
+
+	struct {Z_ENDIANIZED_MEMBERS(32, 2) (
+		zuint16 index1,
+		zuint16 index0
+	)} values_uint16;
+
+	struct {Z_ENDIANIZED_MEMBERS(32, 2) (
+		zsint16 index1,
+		zsint16 index0
+	)} values_sint16;
+
+	struct {Z_ENDIANIZED_MEMBERS(32, 4) (
+		zuint8 index3,
+		zuint8 index2,
+		zuint8 index1,
+		zuint8 index0
+	)} values_uint8;
+
+	struct {Z_ENDIANIZED_MEMBERS(32, 4) (
+		zsint8 index3,
+		zsint8 index2,
+		zsint8 index1,
+		zsint8 index0
+	)} values_sint8;
+Z_DEFINE_STRICT_UNION_END Z32Bit;
+
+Z_DEFINE_STRICT_UNION_BEGIN
+	zuint32 array_uint32[2];
+	zsint32 array_sint32[2];
+	zuint16 array_uint16[4];
+	zsint16 array_sint16[4];
+	zuint8	array_uint8 [8];
+	zsint8	array_sint8 [8];
+
+	struct {Z_ENDIANIZED_MEMBERS(64, 2) (
+		zuint32 index1,
+		zuint32 index0
+	)} values_uint32;
+
+	struct {Z_ENDIANIZED_MEMBERS(64, 2) (
+		zsint32 index1,
+		zsint32 index0
+	)} values_sint32;
+
+	struct {Z_ENDIANIZED_MEMBERS(64, 4) (
+		zuint16 index3,
+		zuint16 index2,
+		zuint16 index1,
+		zuint16 index0
+	)} values_uint16;
+
+	struct {Z_ENDIANIZED_MEMBERS(64, 4) (
+		zsint16 index3,
+		zsint16 index2,
+		zsint16 index1,
+		zsint16 index0
+	)} values_sint16;
+
+	struct {Z_ENDIANIZED_MEMBERS(64, 8) (
+		zuint8 index7,
+		zuint8 index6,
+		zuint8 index5,
+		zuint8 index4,
+		zuint8 index3,
+		zuint8 index2,
+		zuint8 index1,
+		zuint8 index0
+	)} values_uint8;
+
+	struct {Z_ENDIANIZED_MEMBERS(64, 8) (
+		zsint8 index7,
+		zsint8 index6,
+		zsint8 index5,
+		zsint8 index4,
+		zsint8 index3,
+		zsint8 index2,
+		zsint8 index1,
+		zsint8 index0
+	)} values_sint8;
+
+#	ifdef Z_UINT64
+		zuint64 value_uint64;
+#	endif
+
+#	ifdef Z_SINT64
+		zsint64 value_sint64;
+#	endif
+Z_DEFINE_STRICT_UNION_END Z64Bit;
+
+Z_DEFINE_STRICT_UNION_BEGIN
+	zuint32 array_uint32[ 4];
+	zsint32 array_sint32[ 4];
+	zuint16 array_uint16[ 8];
+	zsint16 array_sint16[ 8];
+	zuint8	array_uint8 [16];
+	zsint8	array_sint8 [16];
+
+	struct {Z_ENDIANIZED_MEMBERS(128, 4) (
+		zuint32 index3,
+		zuint32 index2,
+		zuint32 index1,
+		zuint32 index0
+	)} values_uint32;
+
+	struct {Z_ENDIANIZED_MEMBERS(128, 4) (
+		zsint32 index3,
+		zsint32 index2,
+		zsint32 index1,
+		zsint32 index0
+	)} values_sint32;
+
+	struct {Z_ENDIANIZED_MEMBERS(128, 8) (
+		zuint16 index7,
+		zuint16 index6,
+		zuint16 index5,
+		zuint16 index4,
+		zuint16 index3,
+		zuint16 index2,
+		zuint16 index1,
+		zuint16 index0
+	)} values_uint16;
+
+	struct {Z_ENDIANIZED_MEMBERS(128, 8) (
+		zsint16 index7,
+		zsint16 index6,
+		zsint16 index5,
+		zsint16 index4,
+		zsint16 index3,
+		zsint16 index2,
+		zsint16 index1,
+		zsint16 index0
+	)} values_sint16;
+
+	struct {Z_ENDIANIZED_MEMBERS(128, 16) (
+		zuint8 index15,
+		zuint8 index14,
+		zuint8 index13,
+		zuint8 index12,
+		zuint8 index11,
+		zuint8 index10,
+		zuint8 index09,
+		zuint8 index08,
+		zuint8 index07,
+		zuint8 index06,
+		zuint8 index05,
+		zuint8 index04,
+		zuint8 index03,
+		zuint8 index02,
+		zuint8 index01,
+		zuint8 index00
+	)} values_uint8;
+
+	struct {Z_ENDIANIZED_MEMBERS(128, 16) (
+		zsint8 index15,
+		zsint8 index14,
+		zsint8 index13,
+		zsint8 index12,
+		zsint8 index11,
+		zsint8 index10,
+		zsint8 index09,
+		zsint8 index08,
+		zsint8 index07,
+		zsint8 index06,
+		zsint8 index05,
+		zsint8 index04,
+		zsint8 index03,
+		zsint8 index02,
+		zsint8 index01,
+		zsint8 index00
+	)} values_sint8;
+
+#	ifdef Z_UINT128
+		zuint128 value_uint128;
+#	endif
+
+#	ifdef Z_SINT128
+		zsint128 value_sint128;
+#	endif
+
+#	ifdef Z_UINT64
+		zuint64 array_uint64[2];
+
+		struct {Z_ENDIANIZED_MEMBERS(128, 2) (
+			zuint64 index1,
+			zuint64 index0
+		)} values_uint64;
+#	endif
+
+#	ifdef Z_SINT64
+		zsint64 array_sint64[2];
+
+		struct {Z_ENDIANIZED_MEMBERS(128, 2) (
+			zsint64 index1,
+			zsint64 index0
+		)} values_sint64;
+#	endif
+Z_DEFINE_STRICT_UNION_END Z128Bit;
+
+/* MARK: - Pointer type-casting type */
+
+Z_DEFINE_STRICT_UNION_BEGIN
+	void (* pointer_function)(void);
+
+	zuint8*	      pointer_uint8;
+	Z2DUInt8*     pointer_2d_uint8;
+	Z3DUInt8*     pointer_3d_uint8;
+	Z4DUInt8*     pointer_4d_uint8;
+	ZRangeUInt8*  pointer_range_uint8;
+
+	zsint8*	      pointer_sint8;
+	Z2DSInt8*     pointer_2d_sint8;
+	Z3DSInt8*     pointer_3d_sint8;
+	Z4DSInt8*     pointer_4d_sint8;
+
+	zuint16*      pointer_uint16;
+	Z2DUInt16*    pointer_2d_uint16;
+	Z3DUInt16*    pointer_3d_uint16;
+	Z4DUInt16*    pointer_4d_uint16;
+	ZRangeUInt16* pointer_range_uint16;
+
+	zsint16*      pointer_sint16;
+	Z2DSInt16*    pointer_2d_sint16;
+	Z3DSInt16*    pointer_3d_sint16;
+	Z4DSInt16*    pointer_4d_sint16;
+
+	zuint32*      pointer_uint32;
+	Z2DUInt32*    pointer_2d_uint32;
+	Z3DUInt32*    pointer_3d_uint32;
+	Z4DUInt32*    pointer_4d_uint32;
+	ZRangeUInt32* pointer_range_uint32;
+
+	zsint32*      pointer_sint32;
+	Z2DSInt32*    pointer_2d_sint32;
+	Z3DSInt32*    pointer_3d_sint32;
+	Z4DSInt32*    pointer_4d_sint32;
+
+#	ifdef Z_UINT64
+		zuint64*      pointer_uint64;
+		Z2DUInt64*    pointer_2d_uint64;
+		Z3DUInt64*    pointer_3d_uint64;
+		Z4DUInt64*    pointer_4d_uint64;
+		ZRangeUInt64* pointer_range_uint64;
+#	endif
+
+#	ifdef Z_SINT64
+		zsint64*   pointer_sint64;
+		Z2DSInt64* pointer_2d_sint64;
+		Z3DSInt64* pointer_3d_sint64;
+		Z4DSInt64* pointer_4d_sint64;
+#	endif
+
+#	ifdef Z_UINT128
+		zuint128*      pointer_uint128;
+		Z2DUInt128*    pointer_2d_uint128;
+		Z3DUInt128*    pointer_3d_uint128;
+		Z4DUInt128*    pointer_4d_uint128;
+		ZRangeUInt128* pointer_range_uint128;
+#	endif
+
+#	ifdef Z_SINT128
+		zsint128*   pointer_sint128;
+		Z2DSInt128* pointer_2d_sint128;
+		Z3DSInt128* pointer_3d_sint128;
+		Z4DSInt128* pointer_4d_sint128;
+#	endif
+
+#	ifdef Z_FLOAT16
+		zfloat16*   pointer_float16;
+		Z2DFloat16* pointer_2d_float16;
+		Z3DFloat16* pointer_3d_float16;
+		Z4DFloat16* pointer_4d_float16;
+#	endif
+
+#	ifdef Z_FLOAT32
+		zfloat32*   pointer_float32;
+		Z2DFloat32* pointer_2d_float32;
+		Z3DFloat32* pointer_3d_float32;
+		Z4DFloat32* pointer_4d_float32;
+#	endif
+
+#	ifdef Z_FLOAT64
+		zfloat64*   pointer_float64;
+		Z2DFloat64* pointer_2d_float64;
+		Z3DFloat64* pointer_3d_float64;
+		Z4DFloat64* pointer_4d_float64;
+#	endif
+
+#	ifdef Z_FLOAT128
+		zfloat128*   pointer_float128;
+		Z2DFloat128* pointer_2d_float128;
+		Z3DFloat128* pointer_3d_float128;
+		Z4DFloat128* pointer_4d_float128;
+#	endif
+
+#	ifdef Z_FLOAT80_X87
+		zfloat80_x87*	pointer_float80_x87;
+		Z2DFloat80_x87* pointer_2d_float80_x87;
+		Z3DFloat80_x87* pointer_3d_float80_x87;
+		Z4DFloat80_x87* pointer_4d_float80_x87;
+#	endif
+
+#	ifdef Z_FLOAT96_X87
+		zfloat96_x87*	pointer_float96_x87;
+		Z2DFloat96_x87* pointer_2d_float96_x87;
+		Z3DFloat96_x87* pointer_3d_float96_x87;
+		Z4DFloat96_x87* pointer_4d_float96_x87;
+#	endif
+
+#	ifdef Z_FLOAT128_X87
+		zfloat128_x87*	 pointer_float128_x87;
+		Z2DFloat128_x87* pointer_2d_float128_x87;
+		Z3DFloat128_x87* pointer_3d_float128_x87;
+		Z4DFloat128_x87* pointer_4d_float128_x87;
+#	endif
+
+	zchar*	      pointer_char;
+
+	zuchar*	      pointer_uchar;
+	Z2DUChar*     pointer_2d_uchar;
+	Z3DUChar*     pointer_3d_uchar;
+	Z4DUChar*     pointer_4d_uchar;
+	ZRangeUChar*  pointer_range_uchar;
+
+	zschar*	      pointer_schar;
+	Z2DSChar*     pointer_2d_schar;
+	Z3DSChar*     pointer_3d_schar;
+	Z4DSChar*     pointer_4d_schar;
+
+	zushort*      pointer_ushort;
+	Z2DUShort*    pointer_2d_ushort;
+	Z3DUShort*    pointer_3d_ushort;
+	Z4DUShort*    pointer_4d_ushort;
+	ZRangeUShort* pointer_range_ushort;
+
+	zsshort*      pointer_sshort;
+	Z2DSShort*    pointer_2d_sshort;
+	Z3DSShort*    pointer_3d_sshort;
+	Z4DSShort*    pointer_4d_sshort;
+
+	zuint*	      pointer_uint;
+	Z2DUInt*      pointer_2d_uint;
+	Z3DUInt*      pointer_3d_uint;
+	Z4DUInt*      pointer_4d_uint;
+	ZRangeUInt*   pointer_range_uint;
+
+	zsint*	      pointer_sint;
+	Z2DSInt*      pointer_2d_sint;
+	Z3DSInt*      pointer_3d_sint;
+	Z4DSInt*      pointer_4d_sint;
+
+	zulong*	      pointer_ulong;
+	Z2DULong*     pointer_2d_ulong;
+	Z3DULong*     pointer_3d_ulong;
+	Z4DULong*     pointer_4d_ulong;
+	ZRangeULong*  pointer_range_ulong;
+
+	zslong*	      pointer_slong;
+	Z2DSLong*     pointer_2d_slong;
+	Z3DSLong*     pointer_3d_slong;
+	Z4DSLong*     pointer_4d_slong;
+
+#	ifdef Z_ULLONG
+		zullong*      pointer_ullong;
+		Z2DULLong*    pointer_2d_ullong;
+		Z3DULLong*    pointer_3d_ullong;
+		Z4DULLong*    pointer_4d_ullong;
+		ZRangeULLong* pointer_range_ullong;
+#	endif
+
+#	ifdef Z_SLLONG
+		zsllong*   pointer_sllong;
+		Z2DSLLong* pointer_2d_sllong;
+		Z3DSLLong* pointer_3d_sllong;
+		Z4DSLLong* pointer_4d_sllong;
+#	endif
+
+#	ifdef Z_FLOAT
+		zfloat*	  pointer_float;
+		Z2DFloat* pointer_2d_float;
+		Z3DFloat* pointer_3d_float;
+		Z4DFloat* pointer_4d_float;
+#	endif
+
+#	ifdef Z_DOUBLE
+		zdouble*   pointer_double;
+		Z2DDouble* pointer_2d_double;
+		Z3DDouble* pointer_3d_double;
+		Z4DDouble* pointer_4d_double;
+#	endif
+
+#	ifdef Z_LDOUBLE
+		zldouble*   pointer_ldouble;
+		Z2DLDouble* pointer_2d_ldouble;
+		Z3DLDouble* pointer_3d_ldouble;
+		Z4DLDouble* pointer_4d_ldouble;
+#	endif
+
+	zusize*	       pointer_usize;
+	Z2DUSize*      pointer_2d_usize;
+	Z3DUSize*      pointer_3d_usize;
+	Z4DUSize*      pointer_4d_usize;
+	ZRangeUSize*   pointer_range_usize;
+
+	zssize*	       pointer_ssize;
+	Z2DSSize*      pointer_2d_ssize;
+	Z3DSSize*      pointer_3d_ssize;
+	Z4DSSize*      pointer_4d_ssize;
+
+	zuintmax*      pointer_uintmax;
+	Z2DUIntMax*    pointer_2d_uintmax;
+	Z3DUIntMax*    pointer_3d_uintmax;
+	Z4DUIntMax*    pointer_4d_uintmax;
+	ZRangeUIntMax* pointer_range_uintmax;
+
+	zsintmax*      pointer_sintmax;
+	Z2DSIntMax*    pointer_2d_sintmax;
+	Z3DSIntMax*    pointer_3d_sintmax;
+	Z4DSIntMax*    pointer_4d_sintmax;
+
+	zintmax*       pointer_intmax;
+
+	zuintptr*      pointer_uintptr;
+	Z2DUIntPtr*    pointer_2d_uintptr;
+	Z3DUIntPtr*    pointer_3d_uintptr;
+	Z4DUIntPtr*    pointer_4d_uintptr;
+	ZRangeUIntPtr* pointer_range_uintptr;
+
+	zsintptr*      pointer_sintptr;
+	Z2DSIntPtr*    pointer_2d_sintptr;
+	Z3DSIntPtr*    pointer_3d_sintptr;
+	Z4DSIntPtr*    pointer_4d_sintptr;
+
+	zuinttop*      pointer_uinttop;
+	Z2DUIntTop*    pointer_2d_uinttop;
+	Z3DUIntTop*    pointer_3d_uinttop;
+	Z4DUIntTop*    pointer_4d_uinttop;
+	ZRangeUIntTop* pointer_range_uinttop;
+
+	zsinttop*      pointer_sinttop;
+	Z2DSIntTop*    pointer_2d_sinttop;
+	Z3DSIntTop*    pointer_3d_sinttop;
+	Z4DSIntTop*    pointer_4d_sinttop;
+
+	zinttop*       pointer_inttop;
+
+	zboolean*      pointer_boolean;
+	Z2DBoolean*    pointer_2d_boolean;
+	Z3DBoolean*    pointer_3d_boolean;
+	Z4DBoolean*    pointer_4d_boolean;
+
+	znatural*      pointer_natural;
+	Z2DNatural*    pointer_2d_natural;
+	Z3DNatural*    pointer_3d_natural;
+	Z4DNatural*    pointer_4d_natural;
+	ZRangeNatural* pointer_range_natural;
+
+	zinteger*      pointer_integer;
+	Z2DInteger*    pointer_2d_integer;
+	Z3DInteger*    pointer_3d_integer;
+	Z4DInteger*    pointer_4d_integer;
+
+#	ifdef Z_REAL
+		zreal*	 pointer_real;
+		Z2DReal* pointer_2d_real;
+		Z3DReal* pointer_3d_real;
+		Z4DReal* pointer_4d_real;
+#	endif
+
+	ZStatus* pointer_status;
+
+	ZRange*	 pointer_range;
+
+	Z8Bit*	 pointer_8bit;
+	Z16Bit*  pointer_16bit;
+	Z32Bit*  pointer_32bit;
+	Z64Bit*  pointer_64bit;
+	Z128Bit* pointer_128bit;
+
+	void*	 pointer;
+	zuintptr value_uintptr;
+	zsintptr value_sintptr;
+
+#	ifdef Z_EXTENSION_POINTER
+		Z_EXTENSION_POINTER
+#	endif
+Z_DEFINE_STRICT_UNION_END ZPointer;
+
+#endif /* _Z_types_base_H_ */