iob shim

.ccls-cache/@@home@anon@Documents@Code@minecraftconsoles/@home@anon@msvc@VC@Tools@MSVC@14.44.35207@include@concurrencysal.h

@@ -0,0 +1,394 @@
+/***
+*concurrencysal.h - markers for documenting the concurrent semantics of APIs
+*
+*       Copyright (c) Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*       This file contains macros for Concurrency SAL annotations. Definitions
+*       starting with _Internal are low level macros that are subject to change.
+*       Users should not use those low level macros directly.
+*       [ANSI]
+*
+*       [Public]
+*
+****/
+
+#ifndef CONCURRENCYSAL_H
+#define CONCURRENCYSAL_H
+
+#pragma once
+
+#ifdef  __cplusplus // [
+extern "C" {
+#endif  // ]
+
+#if !defined(__midl) && defined(_PREFAST_) && !defined(_SDV_)
+
+__ANNOTATION(SAL_guarded_by(__deferTypecheck void *));
+__ANNOTATION(SAL_write_guarded_by(__deferTypecheck void *));
+__ANNOTATION(SAL_requires_lock_held(__deferTypecheck void *));
+__ANNOTATION(SAL_requires_exclusive_lock_held(__deferTypecheck void *));
+__ANNOTATION(SAL_requires_shared_lock_held(__deferTypecheck void *));
+__ANNOTATION(SAL_requires_lock_not_held(__deferTypecheck void *));
+__ANNOTATION(SAL_requires_no_locks_held(void));
+__ANNOTATION(SAL_set_lock_count_to_zero(__deferTypecheck void *));
+__ANNOTATION(SAL_set_lock_count_to_one(__deferTypecheck void *));
+__ANNOTATION(SAL_acquires_lock(__deferTypecheck void *));
+__ANNOTATION(SAL_acquires_exclusive_lock(__deferTypecheck void *));
+__ANNOTATION(SAL_acquires_shared_lock(__deferTypecheck void *));
+__ANNOTATION(SAL_releases_lock(__deferTypecheck void *));
+__ANNOTATION(SAL_releases_exclusive_lock(__deferTypecheck void *));
+__ANNOTATION(SAL_releases_shared_lock(__deferTypecheck void *));
+__ANNOTATION(SAL_ignore_lock_match(__deferTypecheck void *));
+__ANNOTATION(SAL_has_lock_property(__AuToQuOtE __In_impl_ char *));
+__ANNOTATION(SAL_has_lock_level(__AuToQuOtE __In_impl_ char *));
+__ANNOTATION(SAL_lock_level_order(__deferTypecheck void *, __deferTypecheck void *));
+__ANNOTATION(SAL_no_competing_thread(void));
+__ANNOTATION(SAL_set_same_lock(__deferTypecheck void *, __deferTypecheck void *));
+
+/*
+ * pre-defined global system locks
+ */
+extern int _Global_interlock_;
+extern int _Global_cancel_spin_lock_;
+extern int _Global_critical_region_;
+
+/*
+ * Annotation identifiers
+ */
+#define _Internal_create_CSAL_identifier_(id) const char id[] = "";
+
+_Internal_create_CSAL_identifier_(_Lock_kind_mutex_)
+_Internal_create_CSAL_identifier_(_Lock_kind_event_)
+_Internal_create_CSAL_identifier_(_Lock_kind_semaphore_)
+_Internal_create_CSAL_identifier_(_Lock_kind_spin_lock_)
+_Internal_create_CSAL_identifier_(_Lock_kind_critical_section_)
+
+/*
+ * data protection
+ */
+#define _Guarded_by_(lock) _SAL2_Source_(_Guarded_by_, (lock), _SA_annotes1(SAL_guarded_by,lock))
+#define _Write_guarded_by_(lock) _SAL2_Source_(_Write_guarded_by_, (lock), _SA_annotes1(SAL_write_guarded_by,lock))
+#define _Interlocked_ _Guarded_by_(_Global_interlock_)
+
+/*
+ * interlocked operand used in interlocked instructions
+ */
+#ifndef _Interlocked_operand_
+#define _Interlocked_operand_ _SAL2_Source_(_Interlocked_operand_, (), _Pre_ _SA_annotes0(SAL_interlocked))
+#endif
+
+/*
+ * caller/callee locking contracts
+ */
+#define _Requires_lock_held_(lock)  _SAL2_Source_(_Requires_lock_held_, (lock), _Pre_ _SA_annotes1(SAL_requires_lock_held,lock))
+#define _Requires_exclusive_lock_held_(lock)  _SAL2_Source_(_Requires_exclusive_lock_held_, (lock), _Pre_ _SA_annotes1(SAL_requires_exclusive_lock_held,lock))
+#define _Requires_shared_lock_held_(lock)  _SAL2_Source_(_Requires_shared_lock_held_, (lock), _Pre_ _SA_annotes1(SAL_requires_shared_lock_held,lock))
+
+#define _Requires_lock_not_held_(lock)  _SAL2_Source_(_Requires_lock_not_held_, (lock), _Pre_ _SA_annotes1(SAL_requires_lock_not_held,lock))
+#define _Requires_no_locks_held_  _SAL2_Source_(_Requires_no_locks_held_, (), _Pre_ _SA_annotes0(SAL_requires_no_locks_held))
+
+/*
+ * acquire/release locking side effects
+ */
+#define _Acquires_lock_(lock)  _SAL2_Source_(_Acquires_lock_, (lock), _Post_ _SA_annotes1(SAL_acquires_lock,lock))
+#define _Acquires_exclusive_lock_(lock)  _SAL2_Source_(_Acquires_exclusive_lock_, (lock), _Post_ _SA_annotes1(SAL_acquires_exclusive_lock,lock))
+#define _Acquires_shared_lock_(lock)  _SAL2_Source_(_Acquires_shared_lock_, (lock), _Post_ _SA_annotes1(SAL_acquires_shared_lock,lock))
+
+#define _Releases_lock_(lock)  _SAL2_Source_(_Releases_lock_, (lock), _Post_ _SA_annotes1(SAL_releases_lock,lock))
+#define _Releases_exclusive_lock_(lock)  _SAL2_Source_(_Releases_exclusive_lock_, (lock), _Post_ _SA_annotes1(SAL_releases_exclusive_lock,lock))
+#define _Releases_shared_lock_(lock)  _SAL2_Source_(_Releases_shared_lock_, (lock), _Post_ _SA_annotes1(SAL_releases_shared_lock,lock))
+
+/*
+ * acquire/release locking side effects for non-reentrant locks
+ */
+#define _Acquires_nonreentrant_lock_(lock) \
+     _SAL2_Source_(_Acquires_nonreentrant_lock_, (lock), \
+    _Requires_lock_not_held_(lock) \
+    _Acquires_lock_(lock))
+
+#define _Releases_nonreentrant_lock_(lock) \
+     _SAL2_Source_(_Releases_nonreentrant_lock_, (lock), \
+    _Requires_lock_held_(lock) \
+    _Releases_lock_(lock))
+
+#define _Post_same_lock_(a,b)  _SAL2_Source_(_Post_same_lock_, (a,b), _Post_ _SA_annotes2(SAL_set_same_lock,a,b))
+
+/*
+ * lock level
+ */
+#define _Create_lock_level_(level) _Internal_create_CSAL_identifier_(level)
+
+#define _Has_lock_level_(level)  _SAL2_Source_(_Has_lock_level_, (level), _SA_annotes1(SAL_has_lock_level,#level))
+
+#define _Internal_lock_level_order_(a,b)  _SAL2_Source_(_Internal_lock_level_order_, (a,b), _SA_annotes2(SAL_lock_level_order,a,b))
+#define _Csalcat1_(x,y) x##y
+#define _Csalcat2_(x,y) _Csalcat1_(x,y)
+
+#define _Lock_level_order_(a,b) \
+    extern _Internal_lock_level_order_(a,b) void _Sal_order_##a##_##b(_In_z_ const char*a, _In_z_ const char*b); \
+    static __inline void CSALCAT2(CSAL_LockOrder,__COUNTER__)(void){_Sal_order_##a##_##b(#a,#b);}
+
+/*
+ * threading context
+ */
+#define _No_competing_thread_  _SAL2_Source_(_No_competing_thread_, (), _Pre_ _SA_annotes0(SAL_no_competing_thread))
+
+/*
+ * refinement and suppression
+ */
+extern _Acquires_lock_(*plock) void _Internal_acquires_lock_(void* plock);
+extern _Releases_lock_(*plock) void _Internal_releases_lock_(void* plock);
+
+#define _Internal_set_lock_count_to_zero_(lock)  _SAL2_Source_(Internal_set_lock_count_to_zero_, (lock), _Post_ _SA_annotes1(SAL_set_lock_count_to_zero,lock))
+#define _Internal_set_lock_count_to_one_(lock)  _SAL2_Source_(_Internal_set_lock_count_to_one_, (lock), _Post_ _SA_annotes1(SAL_set_lock_count_to_one,lock))
+
+extern _Internal_set_lock_count_to_one_(*plock) void _Internal_lock_held_(void* plock);
+extern _Internal_set_lock_count_to_zero_(*plock) void _Internal_lock_not_held_(void* plock);
+extern _Post_same_lock_(*plock1, *plock2) void _Internal_same_lock_(void* plock1, void* plock2);
+
+#define _Analysis_assume_lock_acquired_(lock)  _Internal_acquires_lock_((void*)(&(lock)))
+#define _Analysis_assume_lock_released_(lock)  _Internal_releases_lock_((void*)(&(lock)))
+
+#define _Analysis_assume_lock_held_(lock) _Internal_lock_held_((void*)(&(lock)))
+#define _Analysis_assume_lock_not_held_(lock) _Internal_lock_not_held_((void*)(&(lock)))
+#define _Analysis_assume_same_lock_(lock1, lock2) _Internal_same_lock_((void*)(&(lock1)), (void*)(&(lock2)))
+
+/*
+ * _Function_ignore_lock_checking_ may be deprecated in future versions of SAL
+ */
+#define _Function_ignore_lock_checking_(lock)  _SAL2_Source_(_Function_ignore_lock_checking_, (lock), _Pre_ _SA_annotes1(SAL_ignore_lock_match,lock))
+extern _Function_ignore_lock_checking_(*plock) void _Internal_suppress_lock_checking_(void* plock);
+
+/*
+ * _Analysis_suppress_lock_checking_ may be deprecated in future versions of SAL
+ */
+#define _Analysis_suppress_lock_checking_(lock) _Internal_suppress_lock_checking_((void*)(&(lock)));
+
+#define _Benign_race_begin_ __pragma(warning(push)) __pragma(warning(disable:26100 26101 26150 26130 26180 26131 26181 28112))
+#define _Benign_race_end_ __pragma(warning(pop))
+
+#define _No_competing_thread_begin_ __pragma(warning(push)) __pragma(warning(disable:26100 26101 26150 26101 26151 26110 26160 26130 26180 26131 26181 28112))
+#define _No_competing_thread_end_ __pragma(warning(pop))
+
+/*
+ * lock kinds
+ */
+#define _Has_lock_kind_(kind)  _SAL2_Source_(_Has_lock_kind_, (kind), _SA_annotes1(SAL_has_lock_property,#kind))
+
+/*
+ * smart locks (RAII lock wrappers)
+ */
+#ifdef __cplusplus
+} // extern "C"
+
+extern "C++"
+{
+    template<class _SmartLockType> _Acquires_lock_(_smartLock) void _Internal_acquires_smart_lock_(const _SmartLockType& _smartLock);
+    template<class _SmartLockType> _Releases_lock_(_smartLock) void _Internal_releases_smart_lock_(const _SmartLockType& _smartLock);
+} // extern "C++"
+
+#define _Analysis_assume_smart_lock_acquired_(lock) _Internal_acquires_smart_lock_((lock))
+#define _Analysis_assume_smart_lock_released_(lock) _Internal_releases_smart_lock_((lock))
+
+extern "C" {
+#endif
+
+/*
+ * move semantics
+ */
+#define _Internal_swap_lock_ 0
+
+#define _Detaches_lock_(detached, lock) _Post_same_lock_(_Internal_swap_lock_, (lock)) _Post_same_lock_((detached), _Internal_swap_lock_)
+#define _Moves_lock_(target, source) _Post_same_lock_(_Internal_swap_lock_, (source)) _Post_same_lock_((target), _Internal_swap_lock_)
+#define _Replaces_lock_(target, source) _Post_same_lock_(_Internal_swap_lock_, (target)) _Post_same_lock_((target), (source)) _Releases_lock_(_Internal_swap_lock_)
+#define _Swaps_locks_(left, right) _Post_same_lock_(_Internal_swap_lock_, (left)) _Post_same_lock_((left), (right)) _Post_same_lock_((right), _Internal_swap_lock_)
+
+/*
+ * Old spelling
+ * Note: the old version may be deprecated in the future!!!
+ */
+extern int __system_interlock;
+extern int __system_cancel_spinlock;
+extern int __system_critical_region;
+
+#define __guarded_by(lock) _SAL1_1_Source_(__guarded_by, (lock), _SA_annotes1(SAL_guarded_by,lock))
+#define __write_guarded_by(lock) _SAL1_1_Source_(__write_guarded_by, (lock), _SA_annotes1(SAL_write_guarded_by,lock))
+#define __interlocked __guarded_by(_Global_interlock_)
+
+/*
+ * caller/callee locking contracts
+ */
+#define __requires_lock_held(lock) _SAL1_1_Source_(__requires_lock_held, (lock), __pre _SA_annotes1(SAL_requires_lock_held,lock))
+#define __requires_exclusive_lock_held(lock) _SAL1_1_Source_(__requires_exclusive_lock_held, (lock), __pre _SA_annotes1(SAL_requires_exclusive_lock_held,lock))
+#define __requires_shared_lock_held(lock) _SAL1_1_Source_(__requires_shared_lock_held, (lock), __pre _SA_annotes1(SAL_requires_shared_lock_held,lock))
+
+#define __requires_lock_not_held(lock) _SAL1_1_Source_(__requires_lock_not_held, (lock), __pre _SA_annotes1(SAL_requires_lock_not_held,lock))
+#define __requires_no_locks_held _SAL1_1_Source_(__requires_no_locks_held, (), __pre _SA_annotes0(SAL_requires_no_locks_held))
+
+/*
+ * acquire/release locking side effects
+ */
+#define __acquires_lock(lock) _SAL1_1_Source_(__acquires_lock, (lock), __post _SA_annotes1(SAL_acquires_lock,lock))
+#define __acquires_exclusive_lock(lock) _SAL1_1_Source_(__acquires_exclusive_lock, (lock), __post _SA_annotes1(SAL_acquires_exclusive_lock,lock))
+#define __acquires_shared_lock(lock) _SAL1_1_Source_(__acquires_shared_lock, (lock), __post _SA_annotes1(SAL_acquires_shared_lock,lock))
+
+#define __releases_lock(lock) _SAL1_1_Source_(__releases_lock, (lock), __post _SA_annotes1(SAL_releases_lock,lock))
+#define __releases_exclusive_lock(lock) _SAL1_1_Source_(__releases_exclusive_lock, (lock),__post _SA_annotes1(SAL_releases_exclusive_lock,lock))
+#define __releases_shared_lock(lock) _SAL1_1_Source_(__releases_shared_lock, (lock), __post _SA_annotes1(SAL_releases_shared_lock,lock))
+
+/*
+ * lock properties
+ * The following kind options are supported:
+ * __has_lock_property(MUTEX)
+ * __has_lock_property(EVENT)
+ * __has_lock_property(SEMAPHORE)
+ * __has_lock_property(OTHER_HANDLE)
+ * __has_lock_property(REENTRANT)
+ * __has_lock_property(NON_REENTRANT)
+ */
+#define __has_lock_property(kind) _SAL1_1_Source_(__has_lock_property, (kind), _SA_annotes1(SAL_has_lock_property,#kind))
+
+/*
+ * lock level
+ */
+#define __declare_lock_level(level) _Internal_create_CSAL_identifier_(level)
+#define __has_lock_level(level) _SAL1_1_Source_(__has_lock_level, (level), _SA_annotes1(SAL_has_lock_level,#level))
+
+#define __internal_lock_level_order(a,b) _SAL1_1_Source_(__internal_lock_level_order, (a,b), _SA_annotes2(SAL_lock_level_order,#a,#b))
+#define CSALCAT1(x,y) x##y
+#define CSALCAT2(x,y) CSALCAT1(x,y)
+
+#define __lock_level_order(a,b) \
+    extern __internal_lock_level_order(a,b) void __sal_order_##a##_##b(__in_z char*a, __in_z char*b); \
+    static __inline void CSALCAT2(CSAL_LockOrder,__COUNTER__)(void){__sal_order_##a##_##b(#a,#b);}
+
+/*
+ * threading context
+ */
+#define __no_competing_thread _SAL1_1_Source_(__no_competing_thread, (), __pre _SA_annotes0(SAL_no_competing_thread))
+
+/*
+ * refinement and suppression
+ */
+extern __acquires_lock(*plock) void __internal_acquires_lock(void* plock);
+extern __releases_lock(*plock) void __internal_releases_lock(void* plock);
+
+#define __analysis_assume_lock_acquired(lock) __internal_acquires_lock((void*)(&(lock)))
+#define __analysis_assume_lock_released(lock) __internal_releases_lock((void*)(&(lock)))
+
+#define __function_ignore_lock_checking(lock) _SAL1_1_Source_(__function_ignore_lock_cleanup, (lock), __pre _SA_annotes1(SAL_ignore_lock_match,lock))
+extern __function_ignore_lock_checking(*plock) void __internal_suppress_lock_checking(void* plock);
+
+#define __analysis_suppress_lock_checking(lock) __internal_suppress_lock_checking((void*)(&(lock)));
+
+#define BENIGN_RACE_BEGIN __pragma(warning(push)) __pragma(warning(disable:26100 26150 26130 26180 26131 26181))
+#define BENIGN_RACE_END __pragma(warning(pop))
+
+#define NO_COMPETING_THREAD_BEGIN __pragma(warning(push)) __pragma(warning(disable:26100 26150 26101 26151 26110 26160 26130 26180 26131 26181))
+#define NO_COMPETING_THREAD_END __pragma(warning(pop))
+
+#else
+
+#ifndef _Interlocked_operand_
+#define _Interlocked_operand_
+#endif
+
+#define _Guarded_by_(lock)
+#define _Write_guarded_by_(lock)
+#define _Interlocked_
+#define _Requires_lock_held_(lock)
+#define _Requires_exclusive_lock_held_(lock)
+#define _Requires_shared_lock_held_(lock)
+#define _Requires_lock_not_held_(lock)
+#define _Requires_no_locks_held_
+#define _Acquires_lock_(lock)
+#define _Acquires_exclusive_lock_(lock)
+#define _Acquires_shared_lock_(lock)
+#define _Releases_lock_(lock)
+#define _Releases_exclusive_lock_(lock)
+#define _Releases_shared_lock_(lock)
+#define _Acquires_nonreentrant_lock_(lock)
+#define _Releases_nonreentrant_lock_(lock)
+
+#define _Post_same_lock_(lock1,lock2)
+
+#define _Internal_set_lock_count_(lock, count)
+
+#define _Create_lock_level_(level)
+#define _Has_lock_level_(level)
+#define _Internal_lock_level_order_(a,b)
+#define _Csalcat1_(x,y)
+#define _Csalcat2_(x,y)
+#define _Lock_level_order_(a,b)
+#define _No_competing_thread_
+#define _Analysis_assume_lock_acquired_(lock)
+#define _Analysis_assume_lock_released_(lock)
+#define _Analysis_assume_lock_held_(lock)
+#define _Analysis_assume_lock_not_held_(lock)
+#define _Analysis_assume_same_lock_(lock1, lock2)
+#define _Function_ignore_lock_checking_(lock)
+#define _Analysis_suppress_lock_checking_(lock)
+
+#define _Benign_race_begin_ __pragma(warning(push))
+#define _Benign_race_end_ __pragma(warning(pop))
+
+#define _No_competing_thread_begin_ __pragma(warning(push))
+#define _No_competing_thread_end_ __pragma(warning(pop))
+
+#define _Has_lock_kind_(kind)
+
+#ifdef __cplusplus
+#define _Analysis_assume_smart_lock_acquired_(lock)
+#define _Analysis_assume_smart_lock_released_(lock)
+#endif
+
+#define _Detaches_lock_(detached, lock)
+#define _Moves_lock_(target, source)
+#define _Replaces_lock_(target, source)
+#define _Swaps_locks_(left, right)
+
+/*
+ * Old spelling: will be deprecated
+ */
+#define __guarded_by(lock)
+#define __write_guarded_by(lock)
+#define __interlocked
+#define __requires_lock_held(lock)
+#define __requires_exclusive_lock_held(lock)
+#define __requires_shared_lock_held(lock)
+#define __requires_lock_not_held(lock)
+#define __requires_no_locks_held
+#define __acquires_lock(lock)
+#define __acquires_exclusive_lock(lock)
+#define __acquires_shared_lock(lock)
+#define __releases_lock(lock)
+#define __releases_exclusive_lock(lock)
+#define __releases_shared_lock(lock)
+
+#define __has_lock_property(kind)
+#define __declare_lock_level(level)
+#define __has_lock_level(level)
+#define __internal_lock_level_order(a,b)
+#define CSALCAT1(x,y)
+#define CSALCAT2(x,y)
+#define __lock_level_order(a,b)
+#define __no_competing_thread
+#define __analysis_assume_lock_acquired(lock)
+#define __analysis_assume_lock_released(lock)
+#define __function_ignore_lock_checking(lock)
+#define __analysis_suppress_lock_checking(lock)
+
+#define BENIGN_RACE_BEGIN __pragma(warning(push))
+#define BENIGN_RACE_END __pragma(warning(pop))
+
+#define NO_COMPETING_THREAD_BEGIN __pragma(warning(push))
+#define NO_COMPETING_THREAD_END __pragma(warning(pop))
+
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // CONCURRENCYSAL_H

.ccls-cache/@@home@anon@Documents@Code@minecraftconsoles/@home@anon@msvc@VC@Tools@MSVC@14.44.35207@include@limits.h

@@ -0,0 +1,76 @@
+//
+// limits.h
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// The C Standard Library <limits.h> header.
+//
+#pragma once
+#define _INC_LIMITS
+
+#include <vcruntime.h>
+
+#pragma warning(push)
+#pragma warning(disable: _VCRUNTIME_DISABLED_WARNINGS)
+
+_CRT_BEGIN_C_HEADER
+
+#define CHAR_BIT      8
+#define SCHAR_MIN   (-128)
+#define SCHAR_MAX     127
+#define UCHAR_MAX     0xff
+
+#ifndef _CHAR_UNSIGNED
+    #define CHAR_MIN    SCHAR_MIN
+    #define CHAR_MAX    SCHAR_MAX
+#else
+    #define CHAR_MIN    0
+    #define CHAR_MAX    UCHAR_MAX
+#endif
+
+#define MB_LEN_MAX    5
+#define SHRT_MIN    (-32768)
+#define SHRT_MAX      32767
+#define USHRT_MAX     0xffff
+#define INT_MIN     (-2147483647 - 1)
+#define INT_MAX       2147483647
+#define UINT_MAX      0xffffffff
+#define LONG_MIN    (-2147483647L - 1)
+#define LONG_MAX      2147483647L
+#define ULONG_MAX     0xffffffffUL
+#define LLONG_MAX     9223372036854775807i64
+#define LLONG_MIN   (-9223372036854775807i64 - 1)
+#define ULLONG_MAX    0xffffffffffffffffui64
+
+#define _I8_MIN     (-127i8 - 1)
+#define _I8_MAX       127i8
+#define _UI8_MAX      0xffui8
+
+#define _I16_MIN    (-32767i16 - 1)
+#define _I16_MAX      32767i16
+#define _UI16_MAX     0xffffui16
+
+#define _I32_MIN    (-2147483647i32 - 1)
+#define _I32_MAX      2147483647i32
+#define _UI32_MAX     0xffffffffui32
+
+#define _I64_MIN    (-9223372036854775807i64 - 1)
+#define _I64_MAX      9223372036854775807i64
+#define _UI64_MAX     0xffffffffffffffffui64
+
+#ifndef SIZE_MAX
+    // SIZE_MAX definition must match exactly with stdint.h for modules support.
+    #ifdef _WIN64
+        #define SIZE_MAX 0xffffffffffffffffui64
+    #else
+        #define SIZE_MAX 0xffffffffui32
+    #endif
+#endif
+
+#ifndef RSIZE_MAX
+    #define RSIZE_MAX (SIZE_MAX >> 1)
+#endif
+
+_CRT_END_C_HEADER
+
+#pragma warning(pop) // _VCRUNTIME_DISABLED_WARNINGS

.ccls-cache/@@home@anon@Documents@Code@minecraftconsoles/@home@anon@msvc@VC@Tools@MSVC@14.44.35207@include@vadefs.h

@@ -0,0 +1,208 @@
+//
+// vadefs.h
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Definitions of macro helpers used by <stdarg.h>.  This is the topmost header
+// in the CRT header lattice, and is always the first CRT header to be included,
+// explicitly or implicitly.  Therefore, this header also has several definitions
+// that are used throughout the CRT.
+//
+#pragma once
+#define _INC_VADEFS
+
+#define _CRT_PACKING 8
+#pragma pack(push, _CRT_PACKING)
+
+// C4339: '__type_info_node': use of undefined type detected in CLR meta-data (/Wall)
+#ifndef _VCRUNTIME_DISABLED_WARNING_4339
+    #ifdef _M_CEE_PURE
+        #define _VCRUNTIME_DISABLED_WARNING_4339 4339
+    #else
+        #define _VCRUNTIME_DISABLED_WARNING_4339
+    #endif
+#endif
+
+// C4412: function signature contains type '<typename>';
+//        C++ objects are unsafe to pass between pure code and mixed or native. (/Wall)
+#ifndef _VCRUNTIME_DISABLED_WARNING_4412
+    #ifdef _M_CEE_PURE
+        #define _VCRUNTIME_DISABLED_WARNING_4412 4412
+    #else
+        #define _VCRUNTIME_DISABLED_WARNING_4412
+    #endif
+#endif
+
+// Use _VCRUNTIME_EXTRA_DISABLED_WARNINGS to add additional warning suppressions to VCRuntime headers.
+#ifndef _VCRUNTIME_EXTRA_DISABLED_WARNINGS
+    #define _VCRUNTIME_EXTRA_DISABLED_WARNINGS
+#endif
+
+// C4514: unreferenced inline function has been removed (/Wall)
+// C4820: '<typename>' : 'N' bytes padding added after data member (/Wall)
+#ifndef _VCRUNTIME_DISABLED_WARNINGS
+    #define _VCRUNTIME_DISABLED_WARNINGS _VCRUNTIME_DISABLED_WARNING_4339 _VCRUNTIME_DISABLED_WARNING_4412 4514 4820 _VCRUNTIME_EXTRA_DISABLED_WARNINGS
+#endif
+
+#pragma warning(push)
+#pragma warning(disable: _VCRUNTIME_DISABLED_WARNINGS)
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if !defined _W64
+#define _W64
+#endif
+
+#ifndef _UINTPTR_T_DEFINED
+    #define _UINTPTR_T_DEFINED
+    #ifdef _WIN64
+        typedef unsigned __int64  uintptr_t;
+    #else
+        typedef unsigned int uintptr_t;
+    #endif
+#endif
+
+#ifndef _VA_LIST_DEFINED
+    #define _VA_LIST_DEFINED
+    #ifdef _M_CEE_PURE
+        typedef System::ArgIterator va_list;
+    #else
+        typedef char* va_list;
+    #endif
+#endif
+
+#ifdef __cplusplus
+    #define _ADDRESSOF(v) (&const_cast<char&>(reinterpret_cast<const volatile char&>(v)))
+#else
+    #define _ADDRESSOF(v) (&(v))
+#endif
+
+#if (defined _M_ARM || defined _M_HYBRID_X86_ARM64) && !defined _M_CEE_PURE
+    #define _VA_ALIGN       4
+    #define _SLOTSIZEOF(t)  ((sizeof(t) + _VA_ALIGN - 1) & ~(_VA_ALIGN - 1))
+    #define _APALIGN(t,ap)  (((va_list)0 - (ap)) & (__alignof(t) - 1))
+#elif (defined _M_ARM64 || defined _M_ARM64EC) && !defined _M_CEE_PURE
+    #define _VA_ALIGN       8
+    #define _SLOTSIZEOF(t)  ((sizeof(t) + _VA_ALIGN - 1) & ~(_VA_ALIGN - 1))
+    #define _APALIGN(t,ap)  (((va_list)0 - (ap)) & (__alignof(t) - 1))
+#else
+    #define _SLOTSIZEOF(t)  (sizeof(t))
+    #define _APALIGN(t,ap)  (__alignof(t))
+#endif
+
+#if defined _M_CEE_PURE || (defined _M_CEE && !defined _M_ARM && !defined _M_ARM64)
+
+    void  __cdecl __va_start(va_list*, ...);
+    void* __cdecl __va_arg(va_list*, ...);
+    void  __cdecl __va_end(va_list*);
+
+    #define __crt_va_start_a(ap, v) ((void)(__va_start(&ap, _ADDRESSOF(v), _SLOTSIZEOF(v), __alignof(v), _ADDRESSOF(v))))
+    #define __crt_va_arg(ap, t)     (*(t *)__va_arg(&ap, _SLOTSIZEOF(t), _APALIGN(t,ap), (t*)0))
+    #define __crt_va_end(ap)        ((void)(__va_end(&ap)))
+
+#elif defined _M_IX86 && !defined _M_HYBRID_X86_ARM64
+
+    #define _INTSIZEOF(n)          ((sizeof(n) + sizeof(int) - 1) & ~(sizeof(int) - 1))
+
+    #define __crt_va_start_a(ap, v) ((void)(ap = (va_list)_ADDRESSOF(v) + _INTSIZEOF(v)))
+    #define __crt_va_arg(ap, t)     (*(t*)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)))
+    #define __crt_va_end(ap)        ((void)(ap = (va_list)0))
+
+#elif defined _M_ARM
+
+    #ifdef __cplusplus
+        void __cdecl __va_start(va_list*, ...);
+        #define __crt_va_start_a(ap, v) ((void)(__va_start(&ap, _ADDRESSOF(v), _SLOTSIZEOF(v), _ADDRESSOF(v))))
+    #else
+        #define __crt_va_start_a(ap, v) ((void)(ap = (va_list)_ADDRESSOF(v) + _SLOTSIZEOF(v)))
+    #endif
+
+    #define __crt_va_arg(ap, t) (*(t*)((ap += _SLOTSIZEOF(t) + _APALIGN(t,ap)) - _SLOTSIZEOF(t)))
+    #define __crt_va_end(ap)    ((void)(ap = (va_list)0))
+
+#elif defined _M_HYBRID_X86_ARM64
+    void __cdecl __va_start(va_list*, ...);
+    #define __crt_va_start_a(ap,v) ((void)(__va_start(&ap, _ADDRESSOF(v), _SLOTSIZEOF(v), __alignof(v), _ADDRESSOF(v))))
+    #define __crt_va_arg(ap, t)    (*(t*)((ap += _SLOTSIZEOF(t)) - _SLOTSIZEOF(t)))
+    #define __crt_va_end(ap)       ((void)(ap = (va_list)0))
+
+#elif defined _M_ARM64
+
+    void __cdecl __va_start(va_list*, ...);
+
+    #define __crt_va_start_a(ap,v) ((void)(__va_start(&ap, _ADDRESSOF(v), _SLOTSIZEOF(v), __alignof(v), _ADDRESSOF(v))))
+    #define __crt_va_arg(ap, t)                                                 \
+       ((sizeof(t) > (2 * sizeof(__int64)))                                   \
+           ? **(t**)((ap += sizeof(__int64)) - sizeof(__int64))               \
+           : *(t*)((ap += _SLOTSIZEOF(t) + _APALIGN(t,ap)) - _SLOTSIZEOF(t)))
+    #define __crt_va_end(ap)       ((void)(ap = (va_list)0))
+
+#elif defined _M_ARM64EC
+    void __cdecl __va_start(va_list*, ...);
+    //take the ARM64 va_start (for now)
+    #define __crt_va_start_a(ap,v) ((void)(__va_start(&ap, _ADDRESSOF(v), _SLOTSIZEOF(v), __alignof(v), _ADDRESSOF(v))))
+    //a hybrid va arg, to account for the shift in calling convention, with the alignment of ARM64
+    #define __crt_va_arg(ap, t)                                               \
+        ((sizeof(t) > sizeof(__int64) || (sizeof(t) & (sizeof(t) - 1)) != 0) \
+            ? **(t**)((ap += sizeof(__int64)) - sizeof(__int64))             \
+            : *(t*)((ap += _SLOTSIZEOF(t) + _APALIGN(t,ap)) - _SLOTSIZEOF(t)))
+    #define __crt_va_end(ap)        ((void)(ap = (va_list)0))
+
+#elif defined _M_X64
+
+    void __cdecl __va_start(va_list* , ...);
+
+    #define __crt_va_start_a(ap, x) ((void)(__va_start(&ap, x)))
+    #define __crt_va_arg(ap, t)                                               \
+        ((sizeof(t) > sizeof(__int64) || (sizeof(t) & (sizeof(t) - 1)) != 0) \
+            ? **(t**)((ap += sizeof(__int64)) - sizeof(__int64))             \
+            :  *(t* )((ap += sizeof(__int64)) - sizeof(__int64)))
+    #define __crt_va_end(ap)        ((void)(ap = (va_list)0))
+
+#endif
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#if defined __cplusplus && !defined _CRT_NO_VA_START_VALIDATION
+    extern "C++"
+    {
+        template <typename _Ty>
+        struct __vcrt_va_list_is_reference
+        {
+            enum : bool { __the_value = false };
+        };
+
+        template <typename _Ty>
+        struct __vcrt_va_list_is_reference<_Ty&>
+        {
+            enum : bool { __the_value = true };
+        };
+
+        template <typename _Ty>
+        struct __vcrt_va_list_is_reference<_Ty&&>
+        {
+            enum : bool { __the_value = true };
+        };
+
+        template <typename _Ty>
+        struct __vcrt_assert_va_start_is_not_reference
+        {
+            static_assert(!__vcrt_va_list_is_reference<_Ty>::__the_value,
+                "va_start argument must not have reference type and must not be parenthesized");
+        };
+    } // extern "C++"
+
+    #define __crt_va_start(ap, x) ((void)(__vcrt_assert_va_start_is_not_reference<decltype(x)>(), __crt_va_start_a(ap, x)))
+
+#else // ^^^ __cplusplus ^^^ // vvv !__cplusplus vvv //
+
+    #define __crt_va_start(ap, x) __crt_va_start_a(ap, x)
+
+#endif
+
+#pragma warning(pop) // _VCRUNTIME_DISABLED_WARNINGS
+#pragma pack(pop)

.ccls-cache/@@home@anon@Documents@Code@minecraftconsoles/@home@anon@msvc@VC@Tools@MSVC@14.44.35207@include@vcruntime.h

@@ -0,0 +1,416 @@
+//
+// vcruntime.h
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Declarations used throughout the VCRuntime library.
+//
+#pragma once
+//
+// Note on use of "deprecate":
+//
+// Various places in this header and other headers use
+// __declspec(deprecate) or macros that have the term DEPRECATE in them.
+// We use "deprecate" here ONLY to signal the compiler to emit a warning
+// about these items. The use of "deprecate" should NOT be taken to imply
+// that any standard committee has deprecated these functions from the
+// relevant standards.  In fact, these functions are NOT deprecated from
+// the standard.
+//
+// Full details can be found in our documentation by searching for
+// "Security Enhancements in the CRT".
+//
+#ifndef _VCRUNTIME_H
+#define _VCRUNTIME_H
+
+#ifndef _VCRT_COMPILER_PREPROCESSOR
+// Many VCRuntime headers avoid exposing their contents to non-compilers like
+// the Windows resource compiler and Qt's meta-object compiler (moc).
+#if defined(RC_INVOKED) || defined(Q_MOC_RUN)
+#define _VCRT_COMPILER_PREPROCESSOR 0
+#else
+#define _VCRT_COMPILER_PREPROCESSOR 1
+#endif
+#endif // _VCRT_COMPILER_PREPROCESSOR
+
+#ifndef _UCRT
+    #define _UCRT
+#endif
+
+// The _CRTIMP macro is not used in the VCRuntime or the CoreCRT anymore, but
+// there is a lot of existing code that declares CRT functions using this macro,
+// and if we remove its definition, we break that existing code.  It is thus
+// defined here only for compatibility.
+#ifndef _CRTIMP
+    #define _VCRT_DEFINED_CRTIMP
+    #if defined CRTDLL && defined _CRTBLD
+        #define _CRTIMP __declspec(dllexport)
+    #else
+        #ifdef _DLL
+            #define _CRTIMP __declspec(dllimport)
+        #else
+            #define _CRTIMP
+        #endif
+    #endif
+#endif
+
+#include <sal.h>
+#include <vadefs.h>
+
+#pragma warning(push)
+#pragma warning(disable: _VCRUNTIME_DISABLED_WARNINGS)
+
+// All C headers have a common prologue and epilogue, to enclose the header in
+// an extern "C" declaration when the header is #included in a C++ translation
+// unit and to push/pop the packing.
+#if defined __cplusplus
+
+    #define _CRT_BEGIN_C_HEADER            \
+        __pragma(pack(push, _CRT_PACKING)) \
+        extern "C" {
+
+    #define _CRT_END_C_HEADER \
+        }                     \
+        __pragma(pack(pop))
+
+#elif defined __midl
+
+    #define _CRT_BEGIN_C_HEADER                         \
+        cpp_quote("__pragma(pack(push, _CRT_PACKING))") \
+        cpp_quote("extern \"C\" {")
+
+    #define _CRT_END_C_HEADER            \
+        cpp_quote("}")                   \
+        cpp_quote("__pragma(pack(pop))")
+
+#else
+
+    #define _CRT_BEGIN_C_HEADER            \
+        __pragma(pack(push, _CRT_PACKING))
+
+    #define _CRT_END_C_HEADER \
+        __pragma(pack(pop))
+
+#endif
+
+_CRT_BEGIN_C_HEADER
+
+
+
+#ifndef _HAS_EXCEPTIONS // Predefine as 0 to disable exceptions
+    #ifdef _KERNEL_MODE
+        #define _HAS_EXCEPTIONS 0
+    #else
+        #define _HAS_EXCEPTIONS 1
+    #endif /* _KERNEL_MODE */
+#endif /* _HAS_EXCEPTIONS */
+
+
+
+#define _CRT_STRINGIZE_(x) #x
+#define _CRT_STRINGIZE(x) _CRT_STRINGIZE_(x)
+
+#define _CRT_WIDE_(s) L ## s
+#define _CRT_WIDE(s) _CRT_WIDE_(s)
+
+#define _CRT_CONCATENATE_(a, b) a ## b
+#define _CRT_CONCATENATE(a, b)  _CRT_CONCATENATE_(a, b)
+
+#define _CRT_UNPARENTHESIZE_(...) __VA_ARGS__
+#define _CRT_UNPARENTHESIZE(...)  _CRT_UNPARENTHESIZE_ __VA_ARGS__
+
+#ifndef _VCRTIMP
+    #if defined _CRTIMP && !defined _VCRT_DEFINED_CRTIMP
+        #define _VCRTIMP _CRTIMP
+    #elif defined _VCRT_BUILD && defined CRTDLL && !defined _VCRT_SAT_1
+        #define _VCRTIMP __declspec(dllexport)
+    #else
+        #define _VCRTIMP
+    #endif
+#endif
+
+#ifndef _MRTIMP
+    #if defined MRTDLL && defined _CRTBLD && !defined _M_CEE_PURE
+        #define _MRTIMP __declspec(dllexport)
+    #else
+        #define _MRTIMP
+    #endif
+#endif
+
+// Definitions of calling conventions used code sometimes compiled as managed
+#if defined _M_CEE_PURE || defined MRTDLL
+    #define __CLRCALL_OR_CDECL __clrcall
+    #define __CLR_OR_THIS_CALL __clrcall
+#else
+    #define __CLRCALL_OR_CDECL __cdecl
+    #define __CLR_OR_THIS_CALL
+#endif
+
+#ifdef _M_CEE_PURE
+    #define __CLRCALL_PURE_OR_CDECL __clrcall
+#else
+    #define __CLRCALL_PURE_OR_CDECL __cdecl
+#endif
+
+#define __CRTDECL __CLRCALL_PURE_OR_CDECL
+
+// Definitions of common __declspecs
+#define _VCRT_NOALIAS __declspec(noalias)
+#define _VCRT_RESTRICT __declspec(restrict)
+#define _VCRT_ALLOCATOR __declspec(allocator)
+
+#if defined _M_CEE && defined _M_X64
+    #define _VCRT_JIT_INTRINSIC __declspec(jitintrinsic)
+#else
+    #define _VCRT_JIT_INTRINSIC
+#endif
+
+#ifdef __midl
+    #define _VCRT_ALIGN(x)
+#else
+    #define _VCRT_ALIGN(x) __declspec(align(x))
+#endif
+
+#ifndef _CONST_RETURN
+    #ifdef __cplusplus
+        #define _CRT_CONST_CORRECT_OVERLOADS
+        #define _CONST_RETURN  const
+    #else
+      #define _CONST_RETURN
+    #endif
+#endif
+
+// For backwards compatibility
+#define _WConst_return _CONST_RETURN
+
+// Definitions of common types
+#ifdef _WIN64
+    typedef unsigned __int64 size_t;
+    typedef __int64          ptrdiff_t;
+    typedef __int64          intptr_t;
+#else
+    typedef unsigned int     size_t;
+    typedef int              ptrdiff_t;
+    typedef int              intptr_t;
+#endif
+
+#if defined __cplusplus
+    typedef bool  __vcrt_bool;
+#elif defined __midl
+    // MIDL understands neither bool nor _Bool.  Use char as a best-fit
+    // replacement (the differences won't matter in practice).
+    typedef char __vcrt_bool;
+#else
+    typedef _Bool __vcrt_bool;
+#endif
+
+// Indicate that these common types are defined
+#ifndef _SIZE_T_DEFINED
+    #define _SIZE_T_DEFINED
+#endif
+
+#ifndef _PTRDIFF_T_DEFINED
+    #define _PTRDIFF_T_DEFINED
+#endif
+
+#ifndef _INTPTR_T_DEFINED
+    #define _INTPTR_T_DEFINED
+#endif
+
+// Provide a typedef for wchar_t for use under /Zc:wchar_t-
+#ifndef _WCHAR_T_DEFINED
+    #define _WCHAR_T_DEFINED
+    typedef unsigned short wchar_t;
+#endif
+
+#ifndef NULL
+    #ifdef __cplusplus
+        #define NULL 0
+    #else
+        #define NULL ((void *)0)
+    #endif
+#endif
+
+#if defined _M_X64 || defined _M_ARM || defined _M_ARM64
+    #define _UNALIGNED __unaligned
+#else
+    #define _UNALIGNED
+#endif
+
+#if defined _M_ARM64EC
+    #define __security_check_cookie __security_check_cookie_arm64ec
+#endif
+
+#ifdef __cplusplus
+    extern "C++"
+    {
+        template <typename _CountofType, size_t _SizeOfArray>
+        char (*__countof_helper(_UNALIGNED _CountofType (&_Array)[_SizeOfArray]))[_SizeOfArray];
+
+        #define __crt_countof(_Array) (sizeof(*__countof_helper(_Array)) + 0)
+    }
+#else
+    #define __crt_countof(_Array) (sizeof(_Array) / sizeof(_Array[0]))
+#endif
+
+#if defined(_M_IX86) && defined(_CRT_LEGACY_X86_FLT_EXCEPTIONS) && !defined(_M_CEE_PURE)
+    #pragma comment(lib, "legacy_x86_flt_exceptions")
+#endif
+
+#ifdef __cplusplus
+    #if defined(_MSVC_LANG) && _MSVC_LANG > __cplusplus
+        #define _STL_LANG _MSVC_LANG
+    #else  // ^^^ language mode is _MSVC_LANG / language mode is __cplusplus vvv
+        #define _STL_LANG __cplusplus
+    #endif // ^^^ language mode is larger of _MSVC_LANG and __cplusplus ^^^
+#else  // ^^^ determine compiler's C++ mode / no C++ support vvv
+    #define _STL_LANG 0L
+#endif // ^^^ no C++ support ^^^
+
+#ifndef _HAS_CXX17
+    #if _STL_LANG > 201402L
+        #define _HAS_CXX17 1
+    #else
+        #define _HAS_CXX17 0
+    #endif
+#endif // _HAS_CXX17
+
+#ifndef _HAS_CXX20
+    #if _HAS_CXX17 && _STL_LANG > 201703L
+        #define _HAS_CXX20 1
+    #else
+        #define _HAS_CXX20 0
+    #endif
+#endif // _HAS_CXX20
+
+#ifndef _HAS_CXX23
+    #if _HAS_CXX20 && _STL_LANG > 202002L
+        #define _HAS_CXX23 1
+    #else
+        #define _HAS_CXX23 0
+    #endif
+#endif // _HAS_CXX23
+
+#ifndef _HAS_CXX26
+    #if _HAS_CXX23 && _STL_LANG > 202302L
+        #define _HAS_CXX26 1
+    #else
+        #define _HAS_CXX26 0
+    #endif
+#endif // _HAS_CXX26
+
+#undef _STL_LANG
+
+#if _HAS_CXX20 && !_HAS_CXX17
+    #error _HAS_CXX20 must imply _HAS_CXX17.
+#endif
+
+#if _HAS_CXX23 && !_HAS_CXX20
+    #error _HAS_CXX23 must imply _HAS_CXX20.
+#endif
+
+#if _HAS_CXX26 && !_HAS_CXX23
+    #error _HAS_CXX26 must imply _HAS_CXX23.
+#endif
+
+// [[nodiscard]] attributes on STL functions
+#ifndef _HAS_NODISCARD
+    #ifndef __has_cpp_attribute
+        #define _HAS_NODISCARD 0
+    #elif __has_cpp_attribute(nodiscard) >= 201603L // TRANSITION, VSO#939899 (need toolset update)
+        #define _HAS_NODISCARD 1
+    #else
+        #define _HAS_NODISCARD 0
+    #endif
+#endif // _HAS_NODISCARD
+
+#if _HAS_NODISCARD
+    #define _NODISCARD [[nodiscard]]
+#else // ^^^ CAN HAZ [[nodiscard]] / NO CAN HAZ [[nodiscard]] vvv
+    #define _NODISCARD
+#endif // _HAS_NODISCARD
+
+#pragma push_macro("msvc")
+#pragma push_macro("constexpr")
+#undef msvc
+#undef constexpr
+
+// Determine if we should use [[msvc::constexpr]] to allow for "extended constexpr"
+// in Visual C++.
+#ifndef _MSVC_CONSTEXPR
+    #ifdef _MSVC_CONSTEXPR_ATTRIBUTE
+        #define _MSVC_CONSTEXPR [[msvc::constexpr]]
+    #else
+        #define _MSVC_CONSTEXPR
+    #endif
+#endif
+
+#pragma pop_macro("constexpr")
+#pragma pop_macro("msvc")
+
+#ifdef _BUILD_STD_MODULE
+    #define _VCRT_EXPORT_STD export
+#else // ^^^ defined(_BUILD_STD_MODULE) / !defined(_BUILD_STD_MODULE) vvv
+    #define _VCRT_EXPORT_STD
+#endif // ^^^ !defined(_BUILD_STD_MODULE) ^^^
+
+// See note on use of "deprecate" at the top of this file
+#define _CRT_DEPRECATE_TEXT(_Text) __declspec(deprecated(_Text))
+
+#if defined _CRT_SECURE_NO_DEPRECATE && !defined _CRT_SECURE_NO_WARNINGS
+    #define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#ifndef _CRT_INSECURE_DEPRECATE
+    #ifdef _CRT_SECURE_NO_WARNINGS
+        #define _CRT_INSECURE_DEPRECATE(_Replacement)
+    #else
+        #define _CRT_INSECURE_DEPRECATE(_Replacement) _CRT_DEPRECATE_TEXT(    \
+            "This function or variable may be unsafe. Consider using "        \
+            #_Replacement                                                     \
+            " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " \
+            "See online help for details.")
+    #endif
+#endif
+
+#if defined _CRT_SECURE_DEPRECATE_MEMORY && !defined _CRT_SECURE_WARNINGS_MEMORY
+    #define _CRT_SECURE_WARNINGS_MEMORY
+#endif
+
+#ifndef _CRT_INSECURE_DEPRECATE_MEMORY
+    #ifndef _CRT_SECURE_WARNINGS_MEMORY
+        #define _CRT_INSECURE_DEPRECATE_MEMORY(_Replacement)
+    #else
+        #define _CRT_INSECURE_DEPRECATE_MEMORY(_Replacement) \
+            _CRT_INSECURE_DEPRECATE(_Replacement)
+    #endif
+#endif
+
+#if !defined _M_CEE && !defined __midl
+    void __cdecl __security_init_cookie(void);
+
+    #if defined(_M_IX86)
+        void __fastcall __security_check_cookie(_In_ uintptr_t _StackCookie);
+        __declspec(noreturn) void __cdecl __report_gsfailure(void);
+    #elif defined(_M_ARM64EC)
+        void __cdecl __security_check_cookie_arm64ec(_In_ uintptr_t _StackCookie);
+        __declspec(noreturn) void __cdecl __report_gsfailure(_In_ uintptr_t _StackCookie);
+    #else
+        void __cdecl __security_check_cookie(_In_ uintptr_t _StackCookie);
+        __declspec(noreturn) void __cdecl __report_gsfailure(_In_ uintptr_t _StackCookie);
+    #endif
+#endif
+
+extern uintptr_t __security_cookie;
+
+#ifndef _VCRT_BUILD
+    #define __vcrt_malloc_normal(_Size) malloc(_Size)
+    #define __vcrt_calloc_normal(_Count, _Size) calloc(_Count, _Size)
+    #define __vcrt_free_normal(_Memory) free(_Memory)
+#endif
+
+_CRT_END_C_HEADER
+
+#pragma warning(pop) // _VCRUNTIME_DISABLED_WARNINGS
+
+#endif // _VCRUNTIME_H

.ccls-cache/@@home@anon@Documents@Code@minecraftconsoles/@home@anon@msvc@VC@Tools@MSVC@14.44.35207@include@vcruntime_string.h

@@ -0,0 +1,113 @@
+//
+// vcruntime_string.h
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// <string.h> functionality that is implemented in the VCRuntime.
+//
+#pragma once
+
+#include <vcruntime.h>
+
+#pragma warning(push)
+#pragma warning(disable: _VCRUNTIME_DISABLED_WARNINGS)
+
+#ifndef __midl
+
+_CRT_BEGIN_C_HEADER
+
+
+
+_NODISCARD _Check_return_
+_VCRTIMP void _CONST_RETURN* __cdecl memchr(
+    _In_reads_bytes_opt_(_MaxCount) void const* _Buf,
+    _In_                            int         _Val,
+    _In_                            size_t      _MaxCount
+    );
+
+_NODISCARD _Check_return_
+int __cdecl memcmp(
+    _In_reads_bytes_(_Size) void const* _Buf1,
+    _In_reads_bytes_(_Size) void const* _Buf2,
+    _In_                    size_t      _Size
+    );
+
+_CRT_INSECURE_DEPRECATE_MEMORY(memcpy_s)
+_Post_equal_to_(_Dst)
+_At_buffer_(
+    (unsigned char*)_Dst,
+    _Iter_,
+    _Size,
+    _Post_satisfies_(((unsigned char*)_Dst)[_Iter_] == ((unsigned char*)_Src)[_Iter_])
+)
+void* __cdecl memcpy(
+    _Out_writes_bytes_all_(_Size) void* _Dst,
+    _In_reads_bytes_(_Size)       void const* _Src,
+    _In_                          size_t      _Size
+    );
+
+_CRT_INSECURE_DEPRECATE_MEMORY(memmove_s)
+_VCRTIMP void* __cdecl memmove(
+    _Out_writes_bytes_all_opt_(_Size) void*       _Dst,
+    _In_reads_bytes_opt_(_Size)       void const* _Src,
+    _In_                              size_t      _Size
+    );
+
+_Post_equal_to_(_Dst)
+_At_buffer_(
+    (unsigned char*)_Dst,
+    _Iter_,
+    _Size,
+    _Post_satisfies_(((unsigned char*)_Dst)[_Iter_] == _Val)
+)
+void* __cdecl memset(
+    _Out_writes_bytes_all_(_Size) void*  _Dst,
+    _In_                          int    _Val,
+    _In_                          size_t _Size
+    );
+
+_NODISCARD _Check_return_
+_VCRTIMP char _CONST_RETURN* __cdecl strchr(
+    _In_z_ char const* _Str,
+    _In_   int         _Val
+    );
+
+_NODISCARD _Check_return_
+_VCRTIMP char _CONST_RETURN* __cdecl strrchr(
+    _In_z_ char const* _Str,
+    _In_   int         _Ch
+    );
+
+_NODISCARD _Check_return_ _Ret_maybenull_
+_VCRTIMP char _CONST_RETURN* __cdecl strstr(
+    _In_z_ char const* _Str,
+    _In_z_ char const* _SubStr
+    );
+
+_NODISCARD _Check_return_
+_When_(return != NULL, _Ret_range_(_Str, _Str + _String_length_(_Str) - 1))
+_VCRTIMP wchar_t _CONST_RETURN* __cdecl wcschr(
+    _In_z_ wchar_t const* _Str,
+    _In_   wchar_t        _Ch
+    );
+
+_NODISCARD _Check_return_
+_VCRTIMP wchar_t _CONST_RETURN* __cdecl wcsrchr(
+    _In_z_ wchar_t const* _Str,
+    _In_   wchar_t        _Ch
+    );
+
+_NODISCARD _Check_return_ _Ret_maybenull_
+_When_(return != NULL, _Ret_range_(_Str, _Str + _String_length_(_Str) - 1))
+_VCRTIMP wchar_t _CONST_RETURN* __cdecl wcsstr(
+    _In_z_ wchar_t const* _Str,
+    _In_z_ wchar_t const* _SubStr
+    );
+
+
+
+_CRT_END_C_HEADER
+
+#endif // __midl
+
+#pragma warning(pop) // _VCRUNTIME_DISABLED_WARNINGS

.ccls-cache/@@home@anon@Documents@Code@minecraftconsoles/@home@anon@msvc@Windows Kits@10@Include@10.0.26100.0@ucrt@corecrt_io.h

@@ -0,0 +1,572 @@
+//
+// corecrt_io.h
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// This file declares the low-level I/O and file handling functionality.  These
+// declarations are split out to support the Windows build.
+//
+#pragma once
+
+#include <corecrt_share.h>
+#include <corecrt_wio.h>
+
+#pragma warning(push)
+#pragma warning(disable: _UCRT_DISABLED_WARNINGS)
+_UCRT_DISABLE_CLANG_WARNINGS
+
+_CRT_BEGIN_C_HEADER
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Types
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+#ifdef _USE_32BIT_TIME_T
+    #define _finddata_t     _finddata32_t
+    #define _finddatai64_t  _finddata32i64_t
+#else
+    #define _finddata_t     _finddata64i32_t
+    #define _finddatai64_t  __finddata64_t
+#endif
+
+struct _finddata32_t
+{
+    unsigned    attrib;
+    __time32_t  time_create;    // -1 for FAT file systems
+    __time32_t  time_access;    // -1 for FAT file systems
+    __time32_t  time_write;
+    _fsize_t    size;
+    char        name[260];
+};
+
+struct _finddata32i64_t
+{
+    unsigned    attrib;
+    __time32_t  time_create;    // -1 for FAT file systems
+    __time32_t  time_access;    // -1 for FAT file systems
+    __time32_t  time_write;
+    __int64     size;
+    char        name[260];
+};
+
+struct _finddata64i32_t
+{
+    unsigned    attrib;
+    __time64_t  time_create;    // -1 for FAT file systems
+    __time64_t  time_access;    // -1 for FAT file systems
+    __time64_t  time_write;
+    _fsize_t    size;
+    char        name[260];
+};
+
+struct __finddata64_t
+{
+    unsigned    attrib;
+    __time64_t  time_create;    // -1 for FAT file systems
+    __time64_t  time_access;    // -1 for FAT file systems
+    __time64_t  time_write;
+    __int64     size;
+    char        name[260];
+};
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Macros
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+// File attribute constants for the _findfirst() family of functions
+#define _A_NORMAL 0x00 // Normal file - No read/write restrictions
+#define _A_RDONLY 0x01 // Read only file
+#define _A_HIDDEN 0x02 // Hidden file
+#define _A_SYSTEM 0x04 // System file
+#define _A_SUBDIR 0x10 // Subdirectory
+#define _A_ARCH   0x20 // Archive file
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Functions
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+#ifdef _USE_32BIT_TIME_T
+    #define _findfirst      _findfirst32
+    #define _findnext       _findnext32
+    #define _findfirsti64   _findfirst32i64
+    #define _findnexti64     _findnext32i64
+#else
+    #define _findfirst      _findfirst64i32
+    #define _findnext       _findnext64i32
+    #define _findfirsti64   _findfirst64
+    #define _findnexti64    _findnext64
+#endif
+
+#if _CRT_FUNCTIONS_REQUIRED
+
+    _Check_return_
+    _ACRTIMP int __cdecl _access(
+        _In_z_ char const* _FileName,
+        _In_   int         _AccessMode
+        );
+
+    _Check_return_wat_
+    _ACRTIMP errno_t __cdecl _access_s(
+        _In_z_ char const* _FileName,
+        _In_   int         _AccessMode
+        );
+
+    _Check_return_
+    _ACRTIMP int __cdecl _chmod(
+        _In_z_ char const* _FileName,
+        _In_   int         _Mode
+        );
+
+    _Check_return_
+    _ACRTIMP int __cdecl _chsize(
+        _In_ int  _FileHandle,
+        _In_ long _Size
+        );
+
+    _Check_return_wat_
+    _ACRTIMP errno_t __cdecl _chsize_s(
+        _In_ int     _FileHandle,
+        _In_ __int64 _Size
+        );
+
+    _Check_return_opt_
+    _ACRTIMP int __cdecl _close(
+        _In_ int _FileHandle
+        );
+
+    _Check_return_opt_
+    _ACRTIMP int __cdecl _commit(
+        _In_ int _FileHandle
+        );
+
+    _Check_return_ _CRT_INSECURE_DEPRECATE(_sopen_s)
+    _ACRTIMP int __cdecl _creat(
+        _In_z_ char const* _FileName,
+        _In_   int         _PermissionMode
+        );
+
+    _Check_return_
+    _ACRTIMP int __cdecl _dup(
+        _In_ int _FileHandle
+        );
+
+    _Check_return_
+    _ACRTIMP int __cdecl _dup2(
+        _In_ int _FileHandleSrc,
+        _In_ int _FileHandleDst
+        );
+
+    _Check_return_
+    _ACRTIMP int __cdecl _eof(
+        _In_ int _FileHandle
+        );
+
+    _Check_return_
+    _ACRTIMP long __cdecl _filelength(
+        _In_ int _FileHandle
+        );
+
+    _Success_(return != -1)
+    _Check_return_
+    _ACRTIMP intptr_t __cdecl _findfirst32(
+        _In_z_ char const*           _FileName,
+        _Out_  struct _finddata32_t* _FindData
+        );
+
+    _Success_(return != -1)
+    _Check_return_
+    _ACRTIMP int __cdecl _findnext32(
+        _In_  intptr_t              _FindHandle,
+        _Out_ struct _finddata32_t* _FindData
+        );
+
+    _Check_return_opt_
+    _ACRTIMP int __cdecl _findclose(
+        _In_ intptr_t _FindHandle
+        );
+
+    _ACRTIMP intptr_t __cdecl _get_osfhandle(
+            _In_ int _FileHandle
+            );
+
+    _Check_return_
+    _ACRTIMP int __cdecl _isatty(
+        _In_ int _FileHandle
+        );
+
+    _ACRTIMP int __cdecl _locking(
+            _In_ int  _FileHandle,
+            _In_ int  _LockMode,
+            _In_ long _NumOfBytes
+            );
+
+    _Check_return_opt_
+    _ACRTIMP long __cdecl _lseek(
+        _In_ int  _FileHandle,
+        _In_ long _Offset,
+        _In_ int  _Origin
+        );
+
+    _Success_(return == 0)
+    _Check_return_wat_
+    _ACRTIMP errno_t __cdecl _mktemp_s(
+        _Inout_updates_z_(_Size) char*  _TemplateName,
+        _In_                     size_t _Size
+        );
+
+    __DEFINE_CPP_OVERLOAD_SECURE_FUNC_0_0(
+        errno_t, _mktemp_s,
+        _Prepost_z_ char, _TemplateName
+        )
+
+    _Success_(return != 0)
+    _Check_return_ __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_0(
+        char *, __RETURN_POLICY_DST, _ACRTIMP, _mktemp,
+        _Inout_z_, char, _TemplateName
+        )
+
+    _ACRTIMP int __cdecl _open_osfhandle(
+        _In_ intptr_t _OSFileHandle,
+        _In_ int      _Flags
+        );
+
+    #ifdef _CRT_USE_WINAPI_FAMILY_DESKTOP_APP
+        _Success_(return != -1)
+        _Check_return_
+        _DCRTIMP int __cdecl _pipe(
+            _Out_writes_(2)    int*         _PtHandles,
+            _In_               unsigned int _PipeSize,
+            _In_               int          _TextMode
+            );
+    #endif
+
+    _Success_(return != -1)
+    _Check_return_
+    _ACRTIMP int __cdecl _read(
+        _In_                              int          _FileHandle,
+        _Out_writes_bytes_(_MaxCharCount) void*        _DstBuf,
+        _In_                              unsigned int _MaxCharCount
+        );
+
+    _ACRTIMP int __cdecl remove(
+        _In_z_ char const* _FileName
+        );
+
+    _Check_return_
+    _ACRTIMP int __cdecl rename(
+        _In_z_ char const* _OldFilename,
+        _In_z_ char const* _NewFilename
+        );
+
+    _ACRTIMP int __cdecl _unlink(
+        _In_z_ char const* _FileName
+        );
+
+    _Check_return_
+    _ACRTIMP int __cdecl _setmode(
+        _In_ int _FileHandle,
+        _In_ int _Mode
+        );
+
+    _Check_return_
+    _ACRTIMP long __cdecl _tell(
+        _In_ int _FileHandle
+        );
+
+    _CRT_INSECURE_DEPRECATE(_umask_s)
+    _ACRTIMP int __cdecl _umask(
+        _In_ int _Mode
+        );
+
+    _Check_return_wat_
+    _ACRTIMP errno_t __cdecl _umask_s(
+        _In_  int  _NewMode,
+        _Out_ int* _OldMode
+        );
+
+    _ACRTIMP int __cdecl _write(
+        _In_                            int          _FileHandle,
+        _In_reads_bytes_(_MaxCharCount) void const*  _Buf,
+        _In_                            unsigned int _MaxCharCount
+        );
+
+    _Check_return_
+    _ACRTIMP __int64 __cdecl _filelengthi64(
+        _In_ int _FileHandle
+        );
+
+    _Success_(return != -1)
+    _Check_return_
+    _ACRTIMP intptr_t __cdecl _findfirst32i64(
+        _In_z_ char const*              _FileName,
+        _Out_  struct _finddata32i64_t* _FindData
+        );
+
+    _Success_(return != -1)
+    _Check_return_
+    _ACRTIMP intptr_t __cdecl _findfirst64i32(
+        _In_z_ char const*              _FileName,
+        _Out_  struct _finddata64i32_t* _FindData
+        );
+
+    _Success_(return != -1)
+    _Check_return_
+    _ACRTIMP intptr_t __cdecl _findfirst64(
+        _In_z_ char const*            _FileName,
+        _Out_  struct __finddata64_t* _FindData
+        );
+
+    _Success_(return != -1)
+    _Check_return_
+    _ACRTIMP int __cdecl _findnext32i64(
+        _In_  intptr_t                 _FindHandle,
+        _Out_ struct _finddata32i64_t* _FindData
+        );
+
+    _Success_(return != -1)
+    _Check_return_
+    _ACRTIMP int __cdecl _findnext64i32(
+        _In_  intptr_t                 _FindHandle,
+        _Out_ struct _finddata64i32_t* _FindData
+        );
+
+    _Success_(return != -1)
+    _Check_return_
+    _ACRTIMP int __cdecl _findnext64(
+        _In_  intptr_t               _FindHandle,
+        _Out_ struct __finddata64_t* _FindData
+        );
+
+    _Check_return_opt_
+    _ACRTIMP __int64 __cdecl _lseeki64(
+        _In_ int     _FileHandle,
+        _In_ __int64 _Offset,
+        _In_ int     _Origin
+        );
+
+    _Check_return_
+    _ACRTIMP __int64 __cdecl _telli64(
+        _In_ int _FileHandle
+        );
+
+    _Check_return_wat_
+    _ACRTIMP errno_t __cdecl _sopen_s(
+        _Out_  int*        _FileHandle,
+        _In_z_ char const* _FileName,
+        _In_   int         _OpenFlag,
+        _In_   int         _ShareFlag,
+        _In_   int         _PermissionMode
+        );
+
+    _Check_return_
+    _ACRTIMP errno_t __cdecl _sopen_s_nolock(
+        _Out_  int*        _FileHandle,
+        _In_z_ char const* _FileName,
+        _In_   int         _OpenFlag,
+        _In_   int         _ShareFlag,
+        _In_   int         _PermissionMode
+        );
+
+    _ACRTIMP errno_t __cdecl _sopen_dispatch(
+        _In_z_ char const* _FileName,
+        _In_   int         _OFlag,
+        _In_   int         _ShFlag,
+        _In_   int         _PMode,
+        _Out_  int*        _PFileHandle,
+        _In_   int         _BSecure
+        );
+
+
+
+    #ifdef __cplusplus
+
+        // These function do not validate pmode; use _sopen_s instead.
+        extern "C++" _Check_return_ _CRT_INSECURE_DEPRECATE(_sopen_s)
+        inline int __CRTDECL _open(
+            _In_z_ char const* const _FileName,
+            _In_   int         const _OFlag,
+            _In_   int         const _PMode = 0
+            )
+        {
+            int _FileHandle;
+            // Last parameter passed as 0 because we don't want to validate pmode from _open
+            errno_t const _Result = _sopen_dispatch(_FileName, _OFlag, _SH_DENYNO, _PMode, &_FileHandle, 0);
+            return _Result ? -1 : _FileHandle;
+        }
+
+        extern "C++" _Check_return_ _CRT_INSECURE_DEPRECATE(_sopen_s)
+        inline int __CRTDECL _sopen(
+            _In_z_ char const* const _FileName,
+            _In_   int         const _OFlag,
+            _In_   int         const _ShFlag,
+            _In_   int         const _PMode = 0
+            )
+        {
+            int _FileHandle;
+            // Last parameter passed as 0 because we don't want to validate pmode from _sopen
+            errno_t const _Result = _sopen_dispatch(_FileName, _OFlag, _ShFlag, _PMode, &_FileHandle, 0);
+            return _Result ? -1 : _FileHandle;
+        }
+
+    #else
+
+        _Check_return_ _CRT_INSECURE_DEPRECATE(_sopen_s)
+        _ACRTIMP int __cdecl _open(
+            _In_z_ char const* _FileName,
+            _In_   int         _OpenFlag,
+            ...);
+
+        _Check_return_ _CRT_INSECURE_DEPRECATE(_sopen_s)
+        _ACRTIMP int __cdecl _sopen(
+            _In_z_ char const* _FileName,
+            _In_   int         _OpenFlag,
+            _In_   int         _ShareFlag,
+            ...);
+
+    #endif
+
+
+
+    #if defined(_CRT_INTERNAL_NONSTDC_NAMES) && _CRT_INTERNAL_NONSTDC_NAMES
+        // Suppress warnings about double deprecation
+        #pragma warning(push)
+        #pragma warning(disable: 4141)
+
+        _Check_return_ _CRT_NONSTDC_DEPRECATE(_access)
+        _ACRTIMP int __cdecl access(
+            _In_z_ char const* _FileName,
+            _In_   int         _AccessMode
+            );
+
+        _Check_return_ _CRT_NONSTDC_DEPRECATE(_chmod)
+        _ACRTIMP int __cdecl chmod(
+            _In_z_ char const* _FileName,
+            _In_   int         _AccessMode
+            );
+
+        _Check_return_ _CRT_NONSTDC_DEPRECATE(_chsize)
+        _ACRTIMP int __cdecl chsize(
+            _In_ int  _FileHandle,
+            _In_ long _Size
+            );
+
+        _Check_return_opt_ _CRT_NONSTDC_DEPRECATE(_close)
+        _ACRTIMP int __cdecl close(
+            _In_ int _FileHandle
+        );
+
+        _Check_return_ _CRT_NONSTDC_DEPRECATE(_creat) _CRT_INSECURE_DEPRECATE(_sopen_s)
+        _ACRTIMP int __cdecl creat(
+            _In_z_ char const* _FileName,
+            _In_   int         _PermissionMode
+            );
+
+        _Check_return_ _CRT_NONSTDC_DEPRECATE(_dup)
+        _ACRTIMP int __cdecl dup(
+            _In_ int _FileHandle
+            );
+
+        _Check_return_ _CRT_NONSTDC_DEPRECATE(_dup2)
+        _ACRTIMP int __cdecl dup2(
+            _In_ int _FileHandleSrc,
+            _In_ int _FileHandleDst
+            );
+
+        _Check_return_ _CRT_NONSTDC_DEPRECATE(_eof)
+        _ACRTIMP int __cdecl eof(
+            _In_ int _FileHandle
+            );
+
+        _Check_return_ _CRT_NONSTDC_DEPRECATE(_filelength)
+        _ACRTIMP long __cdecl filelength(
+            _In_ int _FileHandle
+            );
+
+        _Check_return_ _CRT_NONSTDC_DEPRECATE(_isatty)
+        _ACRTIMP int __cdecl isatty(
+            _In_ int _FileHandle
+            );
+
+        _Check_return_ _CRT_NONSTDC_DEPRECATE(_locking)
+        _ACRTIMP int __cdecl locking(
+            _In_ int  _FileHandle,
+            _In_ int  _LockMode,
+            _In_ long _NumOfBytes
+            );
+
+        _Check_return_opt_ _CRT_NONSTDC_DEPRECATE(_lseek)
+        _ACRTIMP long __cdecl lseek(
+            _In_ int  _FileHandle,
+            _In_ long _Offset,
+            _In_ int  _Origin
+            );
+
+        _Success_(return != 0)
+        _CRT_NONSTDC_DEPRECATE(_mktemp) _CRT_INSECURE_DEPRECATE(_mktemp_s)
+        _ACRTIMP char * __cdecl mktemp(
+            _Inout_z_ char* _TemplateName
+            );
+
+        _Check_return_ _CRT_NONSTDC_DEPRECATE(_open) _CRT_INSECURE_DEPRECATE(_sopen_s)
+        _ACRTIMP int __cdecl open(
+            _In_z_ char const* _FileName,
+            _In_   int         _OpenFlag,
+            ...);
+
+        _Success_(return != -1)
+        _CRT_NONSTDC_DEPRECATE(_read)
+        _ACRTIMP int __cdecl read(
+            _In_                              int          _FileHandle,
+            _Out_writes_bytes_(_MaxCharCount) void*        _DstBuf,
+            _In_                              unsigned int _MaxCharCount
+            );
+
+        _Check_return_ _CRT_NONSTDC_DEPRECATE(_setmode)
+        _ACRTIMP int __cdecl setmode(
+            _In_ int _FileHandle,
+            _In_ int _Mode
+            );
+
+        _CRT_NONSTDC_DEPRECATE(_sopen) _CRT_INSECURE_DEPRECATE(_sopen_s)
+        _ACRTIMP int __cdecl sopen(
+            _In_ char const* _FileName,
+            _In_ int         _OpenFlag,
+            _In_ int         _ShareFlag,
+            ...);
+
+        _Check_return_ _CRT_NONSTDC_DEPRECATE(_tell)
+        _ACRTIMP long __cdecl tell(
+            _In_ int _FileHandle
+            );
+
+        _CRT_NONSTDC_DEPRECATE(_umask) _CRT_INSECURE_DEPRECATE(_umask_s)
+        _ACRTIMP int __cdecl umask(
+            _In_ int _Mode
+            );
+
+        _CRT_NONSTDC_DEPRECATE(_unlink)
+        _ACRTIMP int __cdecl unlink(
+            _In_z_ char const* _FileName
+            );
+
+        _Check_return_ _CRT_NONSTDC_DEPRECATE(_write)
+        _ACRTIMP int __cdecl write(
+            _In_                            int          _FileHandle,
+            _In_reads_bytes_(_MaxCharCount) void const*  _Buf,
+            _In_                            unsigned int _MaxCharCount
+            );
+
+        #pragma warning(pop)
+    #endif // _CRT_INTERNAL_NONSTDC_NAMES
+#endif // _CRT_FUNCTIONS_REQUIRED
+
+_CRT_END_C_HEADER
+_UCRT_RESTORE_CLANG_WARNINGS
+#pragma warning(pop) // _UCRT_DISABLED_WARNINGS

.ccls-cache/@@home@anon@Documents@Code@minecraftconsoles/@home@anon@msvc@Windows Kits@10@Include@10.0.26100.0@ucrt@corecrt_malloc.h

@@ -0,0 +1,234 @@
+//
+// corecrt_malloc.h
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// The memory allocation library.  These pieces of the allocation library are
+// shared by both <stdlib.h> and <malloc.h>.
+//
+#pragma once
+
+#include <corecrt.h>
+
+#pragma warning(push)
+#pragma warning(disable: _UCRT_DISABLED_WARNINGS)
+_UCRT_DISABLE_CLANG_WARNINGS
+
+_CRT_BEGIN_C_HEADER
+
+
+
+#if defined _DEBUG && defined _CRTDBG_MAP_ALLOC
+    #pragma push_macro("_aligned_free")
+    #pragma push_macro("_aligned_malloc")
+    #pragma push_macro("_aligned_msize")
+    #pragma push_macro("_aligned_offset_malloc")
+    #pragma push_macro("_aligned_offset_realloc")
+    #pragma push_macro("_aligned_offset_recalloc")
+    #pragma push_macro("_aligned_realloc")
+    #pragma push_macro("_aligned_recalloc")
+    #pragma push_macro("_expand")
+    #pragma push_macro("_freea")
+    #pragma push_macro("_msize")
+    #pragma push_macro("_recalloc")
+    #pragma push_macro("calloc")
+    #pragma push_macro("free")
+    #pragma push_macro("malloc")
+    #pragma push_macro("realloc")
+
+    #undef _aligned_free
+    #undef _aligned_malloc
+    #undef _aligned_msize
+    #undef _aligned_offset_malloc
+    #undef _aligned_offset_realloc
+    #undef _aligned_offset_recalloc
+    #undef _aligned_realloc
+    #undef _aligned_recalloc
+    #undef _expand
+    #undef _freea
+    #undef _msize
+    #undef _recalloc
+    #undef calloc
+    #undef free
+    #undef malloc
+    #undef realloc
+#endif
+
+_Check_return_ _Ret_maybenull_ _Post_writable_byte_size_(_Count * _Size)
+_ACRTIMP _CRTALLOCATOR _CRTRESTRICT
+void* __cdecl _calloc_base(
+    _In_ size_t _Count,
+    _In_ size_t _Size
+    );
+
+_Check_return_ _Ret_maybenull_ _Post_writable_byte_size_(_Count * _Size)
+_ACRTIMP _CRT_JIT_INTRINSIC _CRTALLOCATOR _CRTRESTRICT _CRT_HYBRIDPATCHABLE
+void* __cdecl calloc(
+    _In_ _CRT_GUARDOVERFLOW size_t _Count,
+    _In_ _CRT_GUARDOVERFLOW size_t _Size
+    );
+
+_Check_return_
+_ACRTIMP int __cdecl _callnewh(
+    _In_ size_t _Size
+    );
+
+_Check_return_ _Ret_maybenull_ _Post_writable_byte_size_(_Size)
+_ACRTIMP _CRTALLOCATOR _CRT_HYBRIDPATCHABLE
+void* __cdecl _expand(
+    _Pre_notnull_           void*  _Block,
+    _In_ _CRT_GUARDOVERFLOW size_t _Size
+    );
+
+_ACRTIMP
+void __cdecl _free_base(
+    _Pre_maybenull_ _Post_invalid_ void* _Block
+    );
+
+_ACRTIMP _CRT_HYBRIDPATCHABLE
+void __cdecl free(
+    _Pre_maybenull_ _Post_invalid_ void* _Block
+    );
+
+_Check_return_ _Ret_maybenull_ _Post_writable_byte_size_(_Size)
+_ACRTIMP _CRTALLOCATOR _CRTRESTRICT
+void* __cdecl _malloc_base(
+    _In_ size_t _Size
+    );
+
+_Check_return_ _Ret_maybenull_ _Post_writable_byte_size_(_Size)
+_ACRTIMP _CRTALLOCATOR _CRT_JIT_INTRINSIC _CRTRESTRICT _CRT_HYBRIDPATCHABLE
+void* __cdecl malloc(
+    _In_ _CRT_GUARDOVERFLOW size_t _Size
+    );
+
+_Check_return_
+_ACRTIMP
+size_t __cdecl _msize_base(
+    _Pre_notnull_ void* _Block
+    ) _CRT_NOEXCEPT;
+
+_Check_return_
+_ACRTIMP _CRT_HYBRIDPATCHABLE
+size_t __cdecl _msize(
+    _Pre_notnull_ void* _Block
+    );
+
+_Success_(return != 0) _Check_return_ _Ret_maybenull_ _Post_writable_byte_size_(_Size)
+_ACRTIMP _CRTALLOCATOR _CRTRESTRICT
+void* __cdecl _realloc_base(
+    _Pre_maybenull_ _Post_invalid_  void*  _Block,
+    _In_                            size_t _Size
+    );
+
+_Success_(return != 0) _Check_return_ _Ret_maybenull_ _Post_writable_byte_size_(_Size)
+_ACRTIMP _CRTALLOCATOR _CRTRESTRICT _CRT_HYBRIDPATCHABLE
+void* __cdecl realloc(
+    _Pre_maybenull_ _Post_invalid_ void*  _Block,
+    _In_ _CRT_GUARDOVERFLOW        size_t _Size
+    );
+
+_Success_(return != 0) _Check_return_ _Ret_maybenull_ _Post_writable_byte_size_(_Count * _Size)
+_ACRTIMP _CRTALLOCATOR _CRTRESTRICT
+void* __cdecl _recalloc_base(
+    _Pre_maybenull_ _Post_invalid_ void*  _Block,
+    _In_                           size_t _Count,
+    _In_                           size_t _Size
+    );
+
+_Success_(return != 0) _Check_return_ _Ret_maybenull_ _Post_writable_byte_size_(_Count * _Size)
+_ACRTIMP _CRTALLOCATOR _CRTRESTRICT
+void* __cdecl _recalloc(
+    _Pre_maybenull_ _Post_invalid_ void*  _Block,
+    _In_ _CRT_GUARDOVERFLOW        size_t _Count,
+    _In_ _CRT_GUARDOVERFLOW        size_t _Size
+    );
+
+_ACRTIMP
+void __cdecl _aligned_free(
+    _Pre_maybenull_ _Post_invalid_ void* _Block
+    );
+
+_Check_return_ _Ret_maybenull_ _Post_writable_byte_size_(_Size)
+_ACRTIMP _CRTALLOCATOR _CRTRESTRICT
+void* __cdecl _aligned_malloc(
+    _In_ _CRT_GUARDOVERFLOW size_t _Size,
+    _In_                    size_t _Alignment
+    );
+
+_Check_return_ _Ret_maybenull_ _Post_writable_byte_size_(_Size)
+_ACRTIMP _CRTALLOCATOR _CRTRESTRICT
+void* __cdecl _aligned_offset_malloc(
+    _In_ _CRT_GUARDOVERFLOW size_t _Size,
+    _In_                    size_t _Alignment,
+    _In_                    size_t _Offset
+    );
+
+_Check_return_
+_ACRTIMP
+size_t __cdecl _aligned_msize(
+    _Pre_notnull_ void*  _Block,
+    _In_          size_t _Alignment,
+    _In_          size_t _Offset
+    );
+
+_Success_(return != 0) _Check_return_ _Ret_maybenull_ _Post_writable_byte_size_(_Size)
+_ACRTIMP _CRTALLOCATOR _CRTRESTRICT
+void* __cdecl _aligned_offset_realloc(
+    _Pre_maybenull_ _Post_invalid_ void*  _Block,
+    _In_ _CRT_GUARDOVERFLOW        size_t _Size,
+    _In_                           size_t _Alignment,
+    _In_                           size_t _Offset
+    );
+
+_Success_(return != 0) _Check_return_ _Ret_maybenull_ _Post_writable_byte_size_(_Count * _Size)
+_ACRTIMP _CRTALLOCATOR _CRTRESTRICT
+void* __cdecl _aligned_offset_recalloc(
+    _Pre_maybenull_ _Post_invalid_ void*  _Block,
+    _In_ _CRT_GUARDOVERFLOW        size_t _Count,
+    _In_ _CRT_GUARDOVERFLOW        size_t _Size,
+    _In_                           size_t _Alignment,
+    _In_                           size_t _Offset
+    );
+
+_Success_(return != 0) _Check_return_ _Ret_maybenull_ _Post_writable_byte_size_(_Size)
+_ACRTIMP _CRTALLOCATOR _CRTRESTRICT
+void* __cdecl _aligned_realloc(
+    _Pre_maybenull_ _Post_invalid_ void*  _Block,
+    _In_ _CRT_GUARDOVERFLOW        size_t _Size,
+    _In_                           size_t _Alignment
+    );
+
+_Success_(return != 0) _Check_return_ _Ret_maybenull_ _Post_writable_byte_size_(_Count * _Size)
+_ACRTIMP _CRTALLOCATOR _CRTRESTRICT
+void* __cdecl _aligned_recalloc(
+    _Pre_maybenull_ _Post_invalid_ void*  _Block,
+    _In_ _CRT_GUARDOVERFLOW        size_t _Count,
+    _In_ _CRT_GUARDOVERFLOW        size_t _Size,
+    _In_                           size_t _Alignment
+    );
+
+#if defined _DEBUG && defined _CRTDBG_MAP_ALLOC
+    #pragma pop_macro("realloc")
+    #pragma pop_macro("malloc")
+    #pragma pop_macro("free")
+    #pragma pop_macro("calloc")
+    #pragma pop_macro("_recalloc")
+    #pragma pop_macro("_msize")
+    #pragma pop_macro("_freea")
+    #pragma pop_macro("_expand")
+    #pragma pop_macro("_aligned_recalloc")
+    #pragma pop_macro("_aligned_realloc")
+    #pragma pop_macro("_aligned_offset_recalloc")
+    #pragma pop_macro("_aligned_offset_realloc")
+    #pragma pop_macro("_aligned_offset_malloc")
+    #pragma pop_macro("_aligned_msize")
+    #pragma pop_macro("_aligned_malloc")
+    #pragma pop_macro("_aligned_free")
+#endif
+
+
+
+_CRT_END_C_HEADER
+_UCRT_RESTORE_CLANG_WARNINGS
+#pragma warning(pop) // _UCRT_DISABLED_WARNINGS

.ccls-cache/@@home@anon@Documents@Code@minecraftconsoles/@home@anon@msvc@Windows Kits@10@Include@10.0.26100.0@ucrt@corecrt_memcpy_s.h

@@ -0,0 +1,95 @@
+//
+// corecrt_memcpy_s.h
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Inline definitions of memcpy_s and memmove_s
+//
+#pragma once
+
+#include <corecrt.h>
+#include <errno.h>
+#include <vcruntime_string.h>
+
+#pragma warning(push)
+#pragma warning(disable: _UCRT_DISABLED_WARNINGS)
+_UCRT_DISABLE_CLANG_WARNINGS
+
+_CRT_BEGIN_C_HEADER
+
+#ifndef _CRT_MEMCPY_S_INLINE
+    #define _CRT_MEMCPY_S_INLINE static __inline
+#endif
+
+#define _CRT_MEMCPY_S_VALIDATE_RETURN_ERRCODE(expr, errorcode)                 \
+    {                                                                          \
+        int _Expr_val=!!(expr);                                                \
+        if (!(_Expr_val))                                                      \
+        {                                                                      \
+            errno = errorcode;                                                 \
+            _invalid_parameter_noinfo();                                       \
+            return errorcode;                                                  \
+        }                                                                      \
+    }
+
+#if !defined RC_INVOKED && !defined __midl && __STDC_WANT_SECURE_LIB__
+
+    // TRANSITION OS-58345186: this function should have external linkage.
+    _Success_(return == 0)
+    _Check_return_opt_
+    _CRT_MEMCPY_S_INLINE errno_t __CRTDECL memcpy_s(
+        _Out_writes_bytes_to_opt_(_DestinationSize, _SourceSize) void*       const _Destination,
+        _In_                                                     rsize_t     const _DestinationSize,
+        _In_reads_bytes_opt_(_SourceSize)                        void const* const _Source,
+        _In_                                                     rsize_t     const _SourceSize
+        )
+    {
+        if (_SourceSize == 0)
+        {
+            return 0;
+        }
+
+        _CRT_MEMCPY_S_VALIDATE_RETURN_ERRCODE(_Destination != NULL, EINVAL);
+        if (_Source == NULL || _DestinationSize < _SourceSize)
+        {
+            memset(_Destination, 0, _DestinationSize);
+
+            _CRT_MEMCPY_S_VALIDATE_RETURN_ERRCODE(_Source != NULL,                 EINVAL);
+            _CRT_MEMCPY_S_VALIDATE_RETURN_ERRCODE(_DestinationSize >= _SourceSize, ERANGE);
+
+            // Unreachable, but required to suppress /analyze warnings:
+            return EINVAL;
+        }
+        memcpy(_Destination, _Source, _SourceSize);
+        return 0;
+    }
+
+    // TRANSITION OS-58345186: this function should have external linkage.
+    _Check_return_wat_
+    _CRT_MEMCPY_S_INLINE errno_t __CRTDECL memmove_s(
+        _Out_writes_bytes_to_opt_(_DestinationSize, _SourceSize) void*       const _Destination,
+        _In_                                                     rsize_t     const _DestinationSize,
+        _In_reads_bytes_opt_(_SourceSize)                        void const* const _Source,
+        _In_                                                     rsize_t     const _SourceSize
+        )
+    {
+        if (_SourceSize == 0)
+        {
+            return 0;
+        }
+
+        _CRT_MEMCPY_S_VALIDATE_RETURN_ERRCODE(_Destination != NULL,            EINVAL);
+        _CRT_MEMCPY_S_VALIDATE_RETURN_ERRCODE(_Source != NULL,                 EINVAL);
+        _CRT_MEMCPY_S_VALIDATE_RETURN_ERRCODE(_DestinationSize >= _SourceSize, ERANGE);
+
+        memmove(_Destination, _Source, _SourceSize);
+        return 0;
+    }
+
+#endif
+
+#undef _CRT_MEMCPY_S_VALIDATE_RETURN_ERRCODE
+
+_UCRT_RESTORE_CLANG_WARNINGS
+#pragma warning(pop) // _UCRT_DISABLED_WARNINGS
+_CRT_END_C_HEADER

.ccls-cache/@@home@anon@Documents@Code@minecraftconsoles/@home@anon@msvc@Windows Kits@10@Include@10.0.26100.0@ucrt@corecrt_memory.h

@@ -0,0 +1,122 @@
+//
+// corecrt_memory.h
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// The buffer (memory) manipulation library.  These declarations are split out
+// so that they may be included by both <string.h> and <memory.h>.  <string.h>
+// does not include <memory.h> to avoid introducing conflicts with other user
+// headers named <memory.h>.
+//
+#pragma once
+
+#include <corecrt.h>
+#include <corecrt_memcpy_s.h>
+#include <vcruntime_string.h>
+
+#pragma warning(push)
+#pragma warning(disable: _UCRT_DISABLED_WARNINGS)
+_UCRT_DISABLE_CLANG_WARNINGS
+
+#ifndef __midl
+
+_CRT_BEGIN_C_HEADER
+
+
+
+_Check_return_
+_ACRTIMP int __cdecl _memicmp(
+    _In_reads_bytes_opt_(_Size) void const* _Buf1,
+    _In_reads_bytes_opt_(_Size) void const* _Buf2,
+    _In_                        size_t      _Size
+    );
+
+_Check_return_
+_ACRTIMP int __cdecl _memicmp_l(
+    _In_reads_bytes_opt_(_Size) void const* _Buf1,
+    _In_reads_bytes_opt_(_Size) void const* _Buf2,
+    _In_                        size_t      _Size,
+    _In_opt_                    _locale_t   _Locale
+    );
+
+
+
+#if !defined RC_INVOKED && __STDC_WANT_SECURE_LIB__
+
+    #if defined __cplusplus && _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_MEMORY
+    extern "C++"
+    {
+        template <size_t _Size, typename _DstType>
+        inline typename _CrtEnableIf<(_Size > 1), void *>::_Type __cdecl memcpy(
+            _DstType (&_Dst)[_Size],
+            _In_reads_bytes_opt_(_SrcSize) void const* _Src,
+            _In_                           size_t      _SrcSize
+            ) _CRT_SECURE_CPP_NOTHROW
+        {
+            return memcpy_s(_Dst, _Size * sizeof(_DstType), _Src, _SrcSize) == 0 ? _Dst : 0;
+        }
+    }
+    #endif
+
+    #if defined __cplusplus && _CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES_MEMORY
+    extern "C++"
+    {
+        template <size_t _Size, typename _DstType>
+        inline errno_t __CRTDECL memcpy_s(
+            _DstType (&_Dst)[_Size],
+            _In_reads_bytes_opt_(_SrcSize) void const* _Src,
+            _In_                           rsize_t     _SrcSize
+            ) _CRT_SECURE_CPP_NOTHROW
+        {
+            return memcpy_s(_Dst, _Size * sizeof(_DstType), _Src, _SrcSize);
+        }
+    }
+    #endif
+
+#endif // !defined RC_INVOKED && __STDC_WANT_SECURE_LIB__
+
+
+
+#if defined(_CRT_INTERNAL_NONSTDC_NAMES) && _CRT_INTERNAL_NONSTDC_NAMES
+
+    _CRT_NONSTDC_DEPRECATE(_memccpy)
+    _ACRTIMP void* __cdecl memccpy(
+        _Out_writes_bytes_opt_(_Size) void*       _Dst,
+        _In_reads_bytes_opt_(_Size)   void const* _Src,
+        _In_                          int         _Val,
+        _In_                          size_t      _Size
+        );
+
+    _Check_return_ _CRT_NONSTDC_DEPRECATE(_memicmp)
+    _ACRTIMP int __cdecl memicmp(
+        _In_reads_bytes_opt_(_Size) void const* _Buf1,
+        _In_reads_bytes_opt_(_Size) void const* _Buf2,
+        _In_                        size_t      _Size
+        );
+
+#endif // _CRT_INTERNAL_NONSTDC_NAMES
+
+
+
+#if defined __cplusplus
+
+    extern "C++" _Check_return_
+    inline void* __CRTDECL memchr(
+        _In_reads_bytes_opt_(_N) void*  _Pv,
+        _In_                     int    _C,
+        _In_                     size_t _N
+        )
+    {
+        void const* const _Pvc = _Pv;
+        return const_cast<void*>(memchr(_Pvc, _C, _N));
+    }
+
+#endif
+
+
+
+_CRT_END_C_HEADER
+
+#endif // !__midl
+_UCRT_RESTORE_CLANG_WARNINGS
+#pragma warning(pop) // _UCRT_DISABLED_WARNINGS

.ccls-cache/@@home@anon@Documents@Code@minecraftconsoles/@home@anon@msvc@Windows Kits@10@Include@10.0.26100.0@ucrt@corecrt_search.h

@@ -0,0 +1,218 @@
+//
+// corecrt_search.h
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Declarations of functions for sorting and searching.  These declarations are
+// split out so that they may be included by both <stdlib.h> and <search.h>.
+// <stdlib.h> does not include <search.h> to avoid introducing conflicts with
+// other user headers named <search.h>.
+//
+#pragma once
+
+#include <corecrt.h>
+#include <stddef.h>
+
+#pragma warning(push)
+#pragma warning(disable: _UCRT_DISABLED_WARNINGS)
+_UCRT_DISABLE_CLANG_WARNINGS
+
+_CRT_BEGIN_C_HEADER
+
+
+    typedef int (__cdecl* _CoreCrtSecureSearchSortCompareFunction)(void*, void const*, void const*);
+    typedef int (__cdecl* _CoreCrtNonSecureSearchSortCompareFunction)(void const*, void const*);
+
+
+#if __STDC_WANT_SECURE_LIB__
+
+    _Check_return_
+    _ACRTIMP void* __cdecl bsearch_s(
+        _In_                                               void const* _Key,
+        _In_reads_bytes_(_NumOfElements * _SizeOfElements) void const* _Base,
+        _In_                                               rsize_t     _NumOfElements,
+        _In_                                               rsize_t     _SizeOfElements,
+        _In_                   _CoreCrtSecureSearchSortCompareFunction _CompareFunction,
+        _In_opt_                                           void*       _Context
+        );
+
+    _ACRTIMP void __cdecl qsort_s(
+        _Inout_updates_bytes_(_NumOfElements * _SizeOfElements) void*   _Base,
+        _In_                                                    rsize_t _NumOfElements,
+        _In_                                                    rsize_t _SizeOfElements,
+        _In_                    _CoreCrtSecureSearchSortCompareFunction _CompareFunction,
+        _In_opt_                                                void*   _Context
+        );
+
+#endif // __STDC_WANT_SECURE_LIB__
+
+
+
+_Check_return_
+_ACRTIMP void* __cdecl bsearch(
+    _In_                                               void const* _Key,
+    _In_reads_bytes_(_NumOfElements * _SizeOfElements) void const* _Base,
+    _In_                                               size_t      _NumOfElements,
+    _In_                                               size_t      _SizeOfElements,
+    _In_                _CoreCrtNonSecureSearchSortCompareFunction _CompareFunction
+    );
+
+_ACRTIMP void __cdecl qsort(
+    _Inout_updates_bytes_(_NumOfElements * _SizeOfElements) void*  _Base,
+    _In_                                                    size_t _NumOfElements,
+    _In_                                                    size_t _SizeOfElements,
+    _In_                _CoreCrtNonSecureSearchSortCompareFunction _CompareFunction
+    );
+
+_Check_return_
+_ACRTIMP void* __cdecl _lfind_s(
+    _In_                                                  void const*   _Key,
+    _In_reads_bytes_((*_NumOfElements) * _SizeOfElements) void const*   _Base,
+    _Inout_                                               unsigned int* _NumOfElements,
+    _In_                                                  size_t        _SizeOfElements,
+    _In_                        _CoreCrtSecureSearchSortCompareFunction _CompareFunction,
+    _In_                                                  void*         _Context
+    );
+
+_Check_return_
+_ACRTIMP void* __cdecl _lfind(
+    _In_                                                  void const*   _Key,
+    _In_reads_bytes_((*_NumOfElements) * _SizeOfElements) void const*   _Base,
+    _Inout_                                               unsigned int* _NumOfElements,
+    _In_                                                  unsigned int  _SizeOfElements,
+    _In_                     _CoreCrtNonSecureSearchSortCompareFunction _CompareFunction
+    );
+
+_Check_return_
+_ACRTIMP void* __cdecl _lsearch_s(
+    _In_reads_bytes_(_SizeOfElements)                              void const*   _Key,
+    _Inout_updates_bytes_((*_NumOfElements + 1) * _SizeOfElements) void*         _Base,
+    _Inout_                                                        unsigned int* _NumOfElements,
+    _In_                                                           size_t        _SizeOfElements,
+    _In_                                 _CoreCrtSecureSearchSortCompareFunction _CompareFunction,
+    _In_                                                           void*         _Context
+    );
+
+_Check_return_
+_ACRTIMP void* __cdecl _lsearch(
+    _In_reads_bytes_(_SizeOfElements)                              void const*   _Key,
+    _Inout_updates_bytes_((*_NumOfElements + 1) * _SizeOfElements) void*         _Base,
+    _Inout_                                                        unsigned int* _NumOfElements,
+    _In_                                                           unsigned int  _SizeOfElements,
+    _In_                              _CoreCrtNonSecureSearchSortCompareFunction _CompareFunction
+    );
+
+
+
+// Managed search routines
+#if defined __cplusplus && defined _M_CEE
+extern "C++"
+{
+    typedef int (__clrcall* _CoreCrtMgdSecureSearchSortCompareFunction)(void*, void const*, void const*);
+    typedef int (__clrcall* _CoreCrtMgdNonSecureSearchSortCompareFunction)(void const*, void const*);
+
+    #if __STDC_WANT_SECURE_LIB__
+
+        _Check_return_
+        void* __clrcall bsearch_s(
+                _In_                                               void const* _Key,
+                _In_reads_bytes_(_NumOfElements * _SizeOfElements) void const* _Base,
+                _In_                                               rsize_t     _NumOfElements,
+                _In_                                               rsize_t     _SizeOfElements,
+                _In_                _CoreCrtMgdSecureSearchSortCompareFunction _CompareFunction,
+                _In_                                               void*       _Context);
+
+        void __clrcall qsort_s(
+                _Inout_updates_bytes_(_NumOfElements * _SizeOfElements) void*   _Base,
+                _In_                                                    rsize_t _NumOfElements,
+                _In_                                                    rsize_t _SizeOfElements,
+                _In_                 _CoreCrtMgdSecureSearchSortCompareFunction _CompareFunction,
+                _In_                                                    void*   _Context);
+
+    #endif // __STDC_WANT_SECURE_LIB__
+
+    _Check_return_
+    void* __clrcall bsearch(
+        _In_                                               void const* _Key,
+        _In_reads_bytes_(_NumOfElements * _SizeOfElements) void const* _Base,
+        _In_                                               size_t _NumOfElements,
+        _In_                                               size_t _SizeOfElements,
+        _In_        _CoreCrtMgdNonSecureSearchSortCompareFunction _CompareFunction
+        );
+
+    _Check_return_
+    void* __clrcall _lfind_s(
+        _In_                                               void const*   _Key,
+        _In_reads_bytes_(_NumOfElements * _SizeOfElements) void const*   _Base,
+        _Inout_                                            unsigned int* _NumOfElements,
+        _In_                                               size_t        _SizeOfElements,
+        _In_                  _CoreCrtMgdSecureSearchSortCompareFunction _CompareFunction,
+        _In_                                               void*         _Context
+        );
+
+    _Check_return_
+    void* __clrcall _lfind(
+        _In_                                                  void const*   _Key,
+        _In_reads_bytes_((*_NumOfElements) * _SizeOfElements) void const*   _Base,
+        _Inout_                                               unsigned int* _NumOfElements,
+        _In_                                                  unsigned int  _SizeOfElements,
+        _In_                  _CoreCrtMgdNonSecureSearchSortCompareFunction _CompareFunction
+        );
+
+    _Check_return_
+    void* __clrcall _lsearch_s(
+        _In_                                                  void const*   _Key,
+        _In_reads_bytes_((*_NumOfElements) * _SizeOfElements) void*         _Base,
+        _In_                                                  unsigned int* _NumOfElements,
+        _In_                                                  size_t        _SizeOfElements,
+        _In_                     _CoreCrtMgdSecureSearchSortCompareFunction _CompareFunction,
+        _In_                                                  void*         _Context
+        );
+
+    _Check_return_
+    void* __clrcall _lsearch(
+        _In_                                                       void const*   _Key,
+        _Inout_updates_bytes_((*_NumOfElements) * _SizeOfElements) void*         _Base,
+        _Inout_                                                    unsigned int* _NumOfElements,
+        _In_                                                       unsigned int  _SizeOfElements,
+        _In_                       _CoreCrtMgdNonSecureSearchSortCompareFunction _CompareFunction
+        );
+
+    void __clrcall qsort(
+        _Inout_updates_bytes_(_NumOfElements * _SizeOfElements) void*  _Base,
+        _In_                                                    size_t _NumOfElements,
+        _In_                                                    size_t _SizeOfElements,
+        _In_             _CoreCrtMgdNonSecureSearchSortCompareFunction _CompareFunction
+        );
+}
+#endif // defined __cplusplus && defined _M_CEE
+
+
+
+#if defined(_CRT_INTERNAL_NONSTDC_NAMES) && _CRT_INTERNAL_NONSTDC_NAMES
+
+    _Check_return_ _CRT_NONSTDC_DEPRECATE(_lfind)
+    _ACRTIMP void* __cdecl lfind(
+        _In_                                                  void const*   _Key,
+        _In_reads_bytes_((*_NumOfElements) * _SizeOfElements) void const*   _Base,
+        _Inout_                                               unsigned int* _NumOfElements,
+        _In_                                                  unsigned int  _SizeOfElements,
+        _In_                     _CoreCrtNonSecureSearchSortCompareFunction _CompareFunction
+        );
+
+    _Check_return_ _CRT_NONSTDC_DEPRECATE(_lsearch)
+    _ACRTIMP void* __cdecl lsearch(
+        _In_                                                       void const*   _Key,
+        _Inout_updates_bytes_((*_NumOfElements) * _SizeOfElements) void*         _Base,
+        _Inout_                                                    unsigned int* _NumOfElements,
+        _In_                                                       unsigned int  _SizeOfElements,
+        _In_                          _CoreCrtNonSecureSearchSortCompareFunction _CompareFunction
+        );
+
+#endif // _CRT_INTERNAL_NONSTDC_NAMES
+
+
+
+_CRT_END_C_HEADER
+_UCRT_RESTORE_CLANG_WARNINGS
+#pragma warning(pop) // _UCRT_DISABLED_WARNINGS

.ccls-cache/@@home@anon@Documents@Code@minecraftconsoles/@home@anon@msvc@Windows Kits@10@Include@10.0.26100.0@ucrt@corecrt_share.h

@@ -0,0 +1,33 @@
+//
+// corecrt_share.h
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Defines the file sharing modes for the sopen() family of functions.  These
+// declarations are split out to support the Windows build.
+//
+#pragma once
+
+#include <corecrt.h>
+
+#pragma warning(push)
+#pragma warning(disable: _UCRT_DISABLED_WARNINGS)
+_UCRT_DISABLE_CLANG_WARNINGS
+
+#define _SH_DENYRW      0x10    // deny read/write mode
+#define _SH_DENYWR      0x20    // deny write mode
+#define _SH_DENYRD      0x30    // deny read mode
+#define _SH_DENYNO      0x40    // deny none mode
+#define _SH_SECURE      0x80    // secure mode
+
+
+
+#if (defined _CRT_DECLARE_NONSTDC_NAMES && _CRT_DECLARE_NONSTDC_NAMES) || (!defined _CRT_DECLARE_NONSTDC_NAMES && !__STDC__)
+    #define SH_DENYRW _SH_DENYRW
+    #define SH_DENYWR _SH_DENYWR
+    #define SH_DENYRD _SH_DENYRD
+    #define SH_DENYNO _SH_DENYNO
+#endif
+
+_UCRT_RESTORE_CLANG_WARNINGS
+#pragma warning(pop) // _UCRT_DISABLED_WARNINGS

.ccls-cache/@@home@anon@Documents@Code@minecraftconsoles/@home@anon@msvc@Windows Kits@10@Include@10.0.26100.0@ucrt@corecrt_stdio_config.h

@@ -0,0 +1,131 @@
+//
+// corecrt_stdio_config.h
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Per-module <stdio.h> configuration.
+//
+#pragma once
+
+#include <corecrt.h>
+
+#pragma warning(push)
+#pragma warning(disable: _UCRT_DISABLED_WARNINGS)
+_UCRT_DISABLE_CLANG_WARNINGS
+
+_CRT_BEGIN_C_HEADER
+
+#if !defined _NO_CRT_STDIO_INLINE && !_CRT_FUNCTIONS_REQUIRED
+    #define _NO_CRT_STDIO_INLINE
+#endif
+
+#if defined _NO_CRT_STDIO_INLINE
+    #undef _CRT_STDIO_INLINE
+    #define _CRT_STDIO_INLINE
+#elif !defined _CRT_STDIO_INLINE
+    #define _CRT_STDIO_INLINE __inline
+#endif
+
+#if !defined RC_INVOKED // RC has no target architecture
+    #if defined _M_IX86
+        #define _CRT_INTERNAL_STDIO_SYMBOL_PREFIX "_"
+    #elif defined _M_X64 || defined _M_ARM || defined _M_ARM64
+        #define _CRT_INTERNAL_STDIO_SYMBOL_PREFIX ""
+    #else
+        #error Unsupported architecture
+    #endif
+#endif
+
+
+
+// Predefine _CRT_STDIO_ISO_WIDE_SPECIFIERS to use ISO-conforming behavior for
+// the wide string printf and scanf functions (%s, %c, and %[] specifiers).
+//
+// Predefine _CRT_STDIO_LEGACY_WIDE_SPECIFIERS to use VC++ 2013 and earlier behavior for
+// the wide string printf and scanf functions (%s, %c, and %[] specifiers).
+//
+// Predefine _CRT_STDIO_ARBITRARY_WIDE_SPECIFIERS when building code that does
+// not use these format specifiers without a length modifier and thus can be
+// used with either the legacy (default) or the conforming mode.  (This option
+// is intended for use by static libraries).
+#if !defined RC_INVOKED // _CRT_STDIO_LEGACY_WIDE_SPECIFIERS et al. are too long for rc
+    #if defined _CRT_STDIO_ISO_WIDE_SPECIFIERS
+        #if defined _CRT_STDIO_LEGACY_WIDE_SPECIFIERS
+            #error _CRT_STDIO_ISO_WIDE_SPECIFIERS and _CRT_STDIO_LEGACY_WIDE_SPECIFIERS cannot be defined together.
+        #endif
+
+        #if !defined _M_CEE_PURE
+            #pragma comment(lib, "iso_stdio_wide_specifiers")
+            #pragma comment(linker, "/include:" _CRT_INTERNAL_STDIO_SYMBOL_PREFIX "__PLEASE_LINK_WITH_iso_stdio_wide_specifiers.lib")
+        #endif
+    #elif defined _CRT_STDIO_LEGACY_WIDE_SPECIFIERS
+        #if !defined _M_CEE_PURE
+            #pragma comment(lib, "legacy_stdio_wide_specifiers")
+            #pragma comment(linker, "/include:" _CRT_INTERNAL_STDIO_SYMBOL_PREFIX "__PLEASE_LINK_WITH_legacy_stdio_wide_specifiers.lib")
+        #endif
+    #endif
+
+    #if defined __cplusplus && !defined _CRT_STDIO_ARBITRARY_WIDE_SPECIFIERS
+        #ifdef _CRT_STDIO_ISO_WIDE_SPECIFIERS
+            #pragma detect_mismatch("_CRT_STDIO_ISO_WIDE_SPECIFIERS", "1")
+        #else
+            #pragma detect_mismatch("_CRT_STDIO_ISO_WIDE_SPECIFIERS", "0")
+        #endif
+    #endif
+#endif
+
+// If we're compiling mixed managed code, make sure these inline functions are
+// compiled as native to ensure that there is only one instance of each of the
+// function-local static variables.
+#if defined _M_CEE && !defined _M_CEE_PURE
+    #pragma managed(push, off)
+#endif
+
+#if _CRT_FUNCTIONS_REQUIRED
+    // This function must not be inlined into callers to avoid ODR violations.  The
+    // static local variable has different names in C and in C++ translation units.
+    _Check_return_ _Ret_notnull_
+    _CRT_INLINE_PURE_SECURITYCRITICAL_ATTRIBUTE
+    __declspec(noinline) __inline unsigned __int64* __CRTDECL __local_stdio_printf_options(void)
+    {
+        static unsigned __int64 _OptionsStorage;
+        return &_OptionsStorage;
+    }
+
+    // This function must not be inlined into callers to avoid ODR violations.  The
+    // static local variable has different names in C and in C++ translation units.
+    _Check_return_ _Ret_notnull_
+    _CRT_INLINE_PURE_SECURITYCRITICAL_ATTRIBUTE
+    __declspec(noinline) __inline unsigned __int64* __CRTDECL __local_stdio_scanf_options(void)
+    {
+        static unsigned __int64 _OptionsStorage;
+        return &_OptionsStorage;
+    }
+#endif
+
+#if defined _M_CEE && !defined _M_CEE_PURE
+    #pragma managed(pop)
+#endif
+
+#define _CRT_INTERNAL_LOCAL_PRINTF_OPTIONS (*__local_stdio_printf_options())
+#define _CRT_INTERNAL_LOCAL_SCANF_OPTIONS  (*__local_stdio_scanf_options ())
+
+
+
+#define _CRT_INTERNAL_PRINTF_LEGACY_VSPRINTF_NULL_TERMINATION (1ULL << 0)
+#define _CRT_INTERNAL_PRINTF_STANDARD_SNPRINTF_BEHAVIOR       (1ULL << 1)
+#define _CRT_INTERNAL_PRINTF_LEGACY_WIDE_SPECIFIERS           (1ULL << 2)
+#define _CRT_INTERNAL_PRINTF_LEGACY_MSVCRT_COMPATIBILITY      (1ULL << 3)
+#define _CRT_INTERNAL_PRINTF_LEGACY_THREE_DIGIT_EXPONENTS     (1ULL << 4)
+#define _CRT_INTERNAL_PRINTF_STANDARD_ROUNDING                (1ULL << 5)
+
+
+#define _CRT_INTERNAL_SCANF_SECURECRT                   (1ULL << 0)
+#define _CRT_INTERNAL_SCANF_LEGACY_WIDE_SPECIFIERS      (1ULL << 1)
+#define _CRT_INTERNAL_SCANF_LEGACY_MSVCRT_COMPATIBILITY (1ULL << 2)
+
+
+
+_CRT_END_C_HEADER
+_UCRT_RESTORE_CLANG_WARNINGS
+#pragma warning(pop) // _UCRT_DISABLED_WARNINGS

.ccls-cache/@@home@anon@Documents@Code@minecraftconsoles/@home@anon@msvc@Windows Kits@10@Include@10.0.26100.0@ucrt@corecrt_wio.h

@@ -0,0 +1,270 @@
+//
+// corecrt_wio.h
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// This file declares the wide character (wchar_t) I/O functionality, shared by
+// <io.h> and <wchar.h>.
+//
+#pragma once
+
+#include <corecrt.h>
+#include <corecrt_share.h>
+
+#pragma warning(push)
+#pragma warning(disable: _UCRT_DISABLED_WARNINGS)
+_UCRT_DISABLE_CLANG_WARNINGS
+
+_CRT_BEGIN_C_HEADER
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Types
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+#ifdef _USE_32BIT_TIME_T
+    #define _wfinddata_t    _wfinddata32_t
+    #define _wfinddatai64_t _wfinddata32i64_t
+#else
+    #define _wfinddata_t    _wfinddata64i32_t
+    #define _wfinddatai64_t _wfinddata64_t
+#endif
+
+typedef unsigned long _fsize_t;
+
+struct _wfinddata32_t
+{
+    unsigned   attrib;
+    __time32_t time_create;    // -1 for FAT file systems
+    __time32_t time_access;    // -1 for FAT file systems
+    __time32_t time_write;
+    _fsize_t   size;
+    wchar_t    name[260];
+};
+
+struct _wfinddata32i64_t
+{
+    unsigned   attrib;
+    __time32_t time_create;    // -1 for FAT file systems
+    __time32_t time_access;    // -1 for FAT file systems
+    __time32_t time_write;
+    __int64    size;
+    wchar_t    name[260];
+};
+
+struct _wfinddata64i32_t
+{
+    unsigned   attrib;
+    __time64_t time_create;    // -1 for FAT file systems
+    __time64_t time_access;    // -1 for FAT file systems
+    __time64_t time_write;
+    _fsize_t   size;
+    wchar_t    name[260];
+};
+
+struct _wfinddata64_t
+{
+    unsigned   attrib;
+    __time64_t time_create;    // -1 for FAT file systems
+    __time64_t time_access;    // -1 for FAT file systems
+    __time64_t time_write;
+    __int64    size;
+    wchar_t    name[260];
+};
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Functions
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+#ifdef _USE_32BIT_TIME_T
+    #define _wfindfirst     _wfindfirst32
+    #define _wfindnext      _wfindnext32
+    #define _wfindfirsti64  _wfindfirst32i64
+    #define _wfindnexti64   _wfindnext32i64
+#else
+    #define _wfindfirst     _wfindfirst64i32
+    #define _wfindnext      _wfindnext64i32
+    #define _wfindfirsti64  _wfindfirst64
+    #define _wfindnexti64   _wfindnext64
+#endif
+
+_Check_return_
+_ACRTIMP int __cdecl _waccess(
+    _In_z_ wchar_t const* _FileName,
+    _In_   int            _AccessMode
+    );
+
+_Check_return_wat_
+_ACRTIMP errno_t __cdecl _waccess_s(
+    _In_z_ wchar_t const* _FileName,
+    _In_   int            _AccessMode
+    );
+
+_Check_return_
+_ACRTIMP int __cdecl _wchmod(
+    _In_z_ wchar_t const* _FileName,
+    _In_   int            _Mode
+    );
+
+_Check_return_ _CRT_INSECURE_DEPRECATE(_wsopen_s)
+_ACRTIMP int __cdecl _wcreat(
+    _In_z_ wchar_t const* _FileName,
+    _In_   int            _PermissionMode
+    );
+
+_Success_(return != -1)
+_Check_return_
+_ACRTIMP intptr_t __cdecl _wfindfirst32(
+    _In_z_ wchar_t const*         _FileName,
+    _Out_  struct _wfinddata32_t* _FindData
+    );
+
+_Success_(return != -1)
+_Check_return_
+_ACRTIMP int __cdecl _wfindnext32(
+    _In_  intptr_t               _FindHandle,
+    _Out_ struct _wfinddata32_t* _FindData
+    );
+
+_ACRTIMP int __cdecl _wunlink(
+    _In_z_ wchar_t const* _FileName
+    );
+
+_Check_return_
+_ACRTIMP int __cdecl _wrename(
+    _In_z_ wchar_t const* _OldFileName,
+    _In_z_ wchar_t const* _NewFileName
+    );
+
+_ACRTIMP errno_t __cdecl _wmktemp_s(
+    _Inout_updates_z_(_SizeInWords) wchar_t* _TemplateName,
+    _In_                            size_t   _SizeInWords
+    );
+
+__DEFINE_CPP_OVERLOAD_SECURE_FUNC_0_0(
+    errno_t, _wmktemp_s,
+    wchar_t, _TemplateName
+    )
+
+_Success_(return != 0)
+__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_0(
+    wchar_t*, __RETURN_POLICY_DST, _ACRTIMP, _wmktemp,
+    _Inout_z_, wchar_t, _TemplateName
+    )
+
+_Success_(return != -1)
+_Check_return_
+_ACRTIMP intptr_t __cdecl _wfindfirst32i64(
+    _In_z_ wchar_t const*            _FileName,
+    _Out_  struct _wfinddata32i64_t* _FindData
+    );
+
+_Success_(return != -1)
+_Check_return_
+_ACRTIMP intptr_t __cdecl _wfindfirst64i32(
+    _In_z_ wchar_t const*            _FileName,
+    _Out_  struct _wfinddata64i32_t* _FindData
+    );
+
+_Success_(return != -1)
+_Check_return_
+_ACRTIMP intptr_t __cdecl _wfindfirst64(
+    _In_z_ wchar_t const*         _FileName,
+    _Out_  struct _wfinddata64_t* _FindData
+    );
+
+_Success_(return != -1)
+_Check_return_
+_ACRTIMP int __cdecl _wfindnext32i64(
+    _In_  intptr_t                  _FindHandle,
+    _Out_ struct _wfinddata32i64_t* _FindData
+    );
+
+_Success_(return != -1)
+_Check_return_
+_ACRTIMP int __cdecl _wfindnext64i32(
+    _In_  intptr_t                  _FindHandle,
+    _Out_ struct _wfinddata64i32_t* _FindData
+    );
+
+_Success_(return != -1)
+_Check_return_
+_ACRTIMP int __cdecl _wfindnext64(
+    _In_  intptr_t               _FindHandle,
+    _Out_ struct _wfinddata64_t* _FindData
+    );
+
+_Check_return_wat_
+_ACRTIMP errno_t __cdecl _wsopen_s(
+    _Out_  int*           _FileHandle,
+    _In_z_ wchar_t const* _FileName,
+    _In_   int            _OpenFlag,
+    _In_   int            _ShareFlag,
+    _In_   int            _PermissionFlag
+    );
+
+_ACRTIMP errno_t __cdecl _wsopen_dispatch(
+    _In_z_ wchar_t const* _FileName,
+    _In_   int            _OFlag,
+    _In_   int            _ShFlag,
+    _In_   int            _PMode,
+    _Out_  int*           _PFileHandle,
+    _In_   int            _BSecure
+    );
+
+
+
+#if defined __cplusplus
+
+    // These functions do not validate pmode; use _wsopen_s instead.
+    extern "C++" _Check_return_ _CRT_INSECURE_DEPRECATE(_wsopen_s)
+    inline int __CRTDECL _wopen(
+        _In_z_ wchar_t const* _FileName,
+        _In_   int            _OFlag,
+        _In_   int            _PMode = 0
+        )
+    {
+        int _FileHandle;
+        // Last parameter passed as 0 because we don't want to validate pmode from _open
+        errno_t const _Result = _wsopen_dispatch(_FileName, _OFlag, _SH_DENYNO, _PMode, &_FileHandle, 0);
+        return _Result ? -1 : _FileHandle;
+    }
+
+    extern "C++" _Check_return_ _CRT_INSECURE_DEPRECATE(_wsopen_s)
+    inline int __CRTDECL _wsopen(
+        _In_z_ wchar_t const* _FileName,
+        _In_   int            _OFlag,
+        _In_   int            _ShFlag,
+        _In_   int            _PMode = 0
+        )
+    {
+        int _FileHandle;
+        // Last parameter passed as 0 because we don't want to validate pmode from _sopen
+        errno_t const _Result = _wsopen_dispatch(_FileName, _OFlag, _ShFlag, _PMode, &_FileHandle, 0);
+        return _Result ? -1 : _FileHandle;
+    }
+
+
+#else
+
+    _Check_return_ _CRT_INSECURE_DEPRECATE(_wsopen_s)
+    _ACRTIMP int __cdecl _wopen(
+        _In_z_ wchar_t const* _FileName,
+        _In_   int            _OpenFlag,
+        ...);
+
+    _Check_return_ _CRT_INSECURE_DEPRECATE(_wsopen_s)
+    _ACRTIMP int __cdecl _wsopen(
+        _In_z_ wchar_t const* _FileName,
+        _In_   int            _OpenFlag,
+        _In_   int            _ShareFlag,
+        ...);
+
+#endif
+
+_CRT_END_C_HEADER
+_UCRT_RESTORE_CLANG_WARNINGS
+#pragma warning(pop) // _UCRT_DISABLED_WARNINGS

.ccls-cache/@@home@anon@Documents@Code@minecraftconsoles/@home@anon@msvc@Windows Kits@10@Include@10.0.26100.0@ucrt@corecrt_wstdlib.h

@@ -0,0 +1,481 @@
+//
+// corecrt_wstdlib.h
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// This file declares the wide character (wchar_t) C Standard Library functions
+// that are declared by both <stdlib.h> and <wchar.h>.
+//
+#pragma once
+
+#include <corecrt.h>
+
+#pragma warning(push)
+#pragma warning(disable: _UCRT_DISABLED_WARNINGS)
+_UCRT_DISABLE_CLANG_WARNINGS
+
+_CRT_BEGIN_C_HEADER
+
+
+
+// Maximum number of elements, including null terminator (and negative sign
+// where appropriate), needed for integer-to-string conversions for several
+// bases and integer types.
+#define _MAX_ITOSTR_BASE16_COUNT   (8  + 1)
+#define _MAX_ITOSTR_BASE10_COUNT   (1 + 10 + 1)
+#define _MAX_ITOSTR_BASE8_COUNT    (11 + 1)
+#define _MAX_ITOSTR_BASE2_COUNT    (32 + 1)
+
+#define _MAX_LTOSTR_BASE16_COUNT   (8  + 1)
+#define _MAX_LTOSTR_BASE10_COUNT   (1 + 10 + 1)
+#define _MAX_LTOSTR_BASE8_COUNT    (11 + 1)
+#define _MAX_LTOSTR_BASE2_COUNT    (32 + 1)
+
+#define _MAX_ULTOSTR_BASE16_COUNT  (8  + 1)
+#define _MAX_ULTOSTR_BASE10_COUNT  (10 + 1)
+#define _MAX_ULTOSTR_BASE8_COUNT   (11 + 1)
+#define _MAX_ULTOSTR_BASE2_COUNT   (32 + 1)
+
+#define _MAX_I64TOSTR_BASE16_COUNT (16 + 1)
+#define _MAX_I64TOSTR_BASE10_COUNT (1 + 19 + 1)
+#define _MAX_I64TOSTR_BASE8_COUNT  (22 + 1)
+#define _MAX_I64TOSTR_BASE2_COUNT  (64 + 1)
+
+#define _MAX_U64TOSTR_BASE16_COUNT (16 + 1)
+#define _MAX_U64TOSTR_BASE10_COUNT (20 + 1)
+#define _MAX_U64TOSTR_BASE8_COUNT  (22 + 1)
+#define _MAX_U64TOSTR_BASE2_COUNT  (64 + 1)
+
+
+#if _CRT_FUNCTIONS_REQUIRED
+
+    _Success_(return == 0)
+    _Check_return_wat_
+    _ACRTIMP errno_t __cdecl _itow_s(
+        _In_                         int      _Value,
+        _Out_writes_z_(_BufferCount) wchar_t* _Buffer,
+        _In_                         size_t   _BufferCount,
+        _In_                         int      _Radix
+        );
+
+    __DEFINE_CPP_OVERLOAD_SECURE_FUNC_1_1(
+        errno_t, _itow_s,
+        _In_ int,     _Value,
+             wchar_t, _Buffer,
+        _In_ int,     _Radix
+        )
+
+    __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_1_1(
+        wchar_t*, __RETURN_POLICY_DST, _ACRTIMP, _itow,
+        _In_                    int,     _Value,
+        _Pre_notnull_ _Post_z_, wchar_t, _Buffer,
+        _In_                    int,     _Radix
+        )
+
+    _Success_(return == 0)
+    _Check_return_wat_
+    _ACRTIMP errno_t __cdecl _ltow_s(
+        _In_                         long     _Value,
+        _Out_writes_z_(_BufferCount) wchar_t* _Buffer,
+        _In_                         size_t   _BufferCount,
+        _In_                         int      _Radix
+        );
+
+    __DEFINE_CPP_OVERLOAD_SECURE_FUNC_1_1(
+        errno_t, _ltow_s,
+        _In_ long,    _Value,
+             wchar_t, _Buffer,
+        _In_ int,     _Radix
+        )
+
+    __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_1_1(
+        wchar_t*, __RETURN_POLICY_DST, _ACRTIMP, _ltow,
+        _In_                    long,    _Value,
+        _Pre_notnull_ _Post_z_, wchar_t, _Buffer,
+        _In_                    int,     _Radix
+        )
+
+    _Check_return_wat_
+    _ACRTIMP errno_t __cdecl _ultow_s(
+        _In_                         unsigned long _Value,
+        _Out_writes_z_(_BufferCount) wchar_t*      _Buffer,
+        _In_                         size_t        _BufferCount,
+        _In_                         int           _Radix
+        );
+
+    __DEFINE_CPP_OVERLOAD_SECURE_FUNC_1_1(
+        errno_t, _ultow_s,
+        _In_ unsigned long, _Value,
+             wchar_t,       _Buffer,
+        _In_ int,           _Radix
+        )
+
+    __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_1_1(
+        wchar_t*, __RETURN_POLICY_DST, _ACRTIMP, _ultow,
+        _In_                    unsigned long, _Value,
+        _Pre_notnull_ _Post_z_, wchar_t,       _Buffer,
+        _In_                    int,           _Radix
+        )
+
+    _Check_return_
+    _ACRTIMP double __cdecl wcstod(
+        _In_z_                   wchar_t const* _String,
+        _Out_opt_ _Deref_post_z_ wchar_t**      _EndPtr
+        );
+
+    _Check_return_
+    _ACRTIMP double __cdecl _wcstod_l(
+        _In_z_                   wchar_t const* _String,
+        _Out_opt_ _Deref_post_z_ wchar_t**      _EndPtr,
+        _In_opt_                 _locale_t      _Locale
+        );
+
+    _Check_return_
+    _ACRTIMP long __cdecl wcstol(
+        _In_z_                   wchar_t const* _String,
+        _Out_opt_ _Deref_post_z_ wchar_t**      _EndPtr,
+        _In_                     int            _Radix
+        );
+
+    _Check_return_
+    _ACRTIMP long __cdecl _wcstol_l(
+        _In_z_                   wchar_t const* _String,
+        _Out_opt_ _Deref_post_z_ wchar_t**      _EndPtr,
+        _In_                     int            _Radix,
+        _In_opt_                 _locale_t      _Locale
+        );
+
+    _Check_return_
+    _ACRTIMP long long __cdecl wcstoll(
+        _In_z_                   wchar_t const* _String,
+        _Out_opt_ _Deref_post_z_ wchar_t**      _EndPtr,
+        _In_                     int            _Radix
+        );
+
+    _Check_return_
+    _ACRTIMP long long __cdecl _wcstoll_l(
+        _In_z_                   wchar_t const* _String,
+        _Out_opt_ _Deref_post_z_ wchar_t**      _EndPtr,
+        _In_                     int            _Radix,
+        _In_opt_                 _locale_t      _Locale
+        );
+
+    _Check_return_
+    _ACRTIMP unsigned long __cdecl wcstoul(
+        _In_z_                   wchar_t const* _String,
+        _Out_opt_ _Deref_post_z_ wchar_t**      _EndPtr,
+        _In_                     int            _Radix
+        );
+
+    _Check_return_
+    _ACRTIMP unsigned long __cdecl _wcstoul_l(
+        _In_z_                   wchar_t const* _String,
+        _Out_opt_ _Deref_post_z_ wchar_t**      _EndPtr,
+        _In_                     int            _Radix,
+        _In_opt_                 _locale_t      _Locale
+        );
+
+    _Check_return_
+    _ACRTIMP unsigned long long __cdecl wcstoull(
+        _In_z_                   wchar_t const* _String,
+        _Out_opt_ _Deref_post_z_ wchar_t**      _EndPtr,
+        _In_                     int            _Radix
+        );
+
+    _Check_return_
+    _ACRTIMP unsigned long long __cdecl _wcstoull_l(
+        _In_z_                   wchar_t const* _String,
+        _Out_opt_ _Deref_post_z_ wchar_t**      _EndPtr,
+        _In_                     int            _Radix,
+        _In_opt_                 _locale_t      _Locale
+        );
+
+    _Check_return_
+    _ACRTIMP long double __cdecl wcstold(
+        _In_z_                   wchar_t const* _String,
+        _Out_opt_ _Deref_post_z_ wchar_t**      _EndPtr
+        );
+
+    _Check_return_
+    _ACRTIMP long double __cdecl _wcstold_l(
+        _In_z_                   wchar_t const* _String,
+        _Out_opt_ _Deref_post_z_ wchar_t**      _EndPtr,
+        _In_opt_                 _locale_t      _Locale
+        );
+
+    _Check_return_
+    _ACRTIMP float __cdecl wcstof(
+        _In_z_                   wchar_t const* _String,
+        _Out_opt_ _Deref_post_z_ wchar_t**      _EndPtr
+        );
+
+    _Check_return_
+    _ACRTIMP float __cdecl _wcstof_l(
+        _In_z_                   wchar_t const* _String,
+        _Out_opt_ _Deref_post_z_ wchar_t**      _EndPtr,
+        _In_opt_                 _locale_t      _Locale
+        );
+
+    _Check_return_
+    _ACRTIMP double __cdecl _wtof(
+        _In_z_ wchar_t const* _String
+        );
+
+    _Check_return_
+    _ACRTIMP double __cdecl _wtof_l(
+        _In_z_   wchar_t const* _String,
+        _In_opt_ _locale_t      _Locale
+        );
+
+    _Check_return_
+    _ACRTIMP int __cdecl _wtoi(
+        _In_z_ wchar_t const* _String
+        );
+
+    _Check_return_
+    _ACRTIMP int __cdecl _wtoi_l(
+        _In_z_   wchar_t const* _String,
+        _In_opt_ _locale_t      _Locale
+        );
+
+    _Check_return_
+    _ACRTIMP long __cdecl _wtol(
+        _In_z_ wchar_t const* _String
+        );
+
+    _Check_return_
+    _ACRTIMP long __cdecl _wtol_l(
+        _In_z_   wchar_t const* _String,
+        _In_opt_ _locale_t      _Locale
+        );
+
+    _Check_return_
+    _ACRTIMP long long __cdecl _wtoll(
+        _In_z_ wchar_t const* _String
+        );
+
+    _Check_return_
+    _ACRTIMP long long __cdecl _wtoll_l(
+        _In_z_   wchar_t const* _String,
+        _In_opt_ _locale_t      _Locale
+        );
+
+    _Check_return_wat_
+    _ACRTIMP errno_t __cdecl _i64tow_s(
+        _In_                         __int64  _Value,
+        _Out_writes_z_(_BufferCount) wchar_t* _Buffer,
+        _In_                         size_t   _BufferCount,
+        _In_                         int      _Radix
+        );
+
+    _CRT_INSECURE_DEPRECATE(_i64tow_s)
+    _ACRTIMP wchar_t* __cdecl _i64tow(
+        _In_                   __int64  _Value,
+        _Pre_notnull_ _Post_z_ wchar_t* _Buffer,
+        _In_                   int      _Radix
+        );
+
+    _Check_return_wat_
+    _ACRTIMP errno_t __cdecl _ui64tow_s(
+        _In_                         unsigned __int64 _Value,
+        _Out_writes_z_(_BufferCount) wchar_t*         _Buffer,
+        _In_                         size_t           _BufferCount,
+        _In_                         int              _Radix
+        );
+
+    _CRT_INSECURE_DEPRECATE(_ui64tow_s)
+    _ACRTIMP wchar_t* __cdecl _ui64tow(
+        _In_                   unsigned __int64 _Value,
+        _Pre_notnull_ _Post_z_ wchar_t*         _Buffer,
+        _In_                   int              _Radix
+        );
+
+    _Check_return_
+    _ACRTIMP __int64 __cdecl _wtoi64(
+        _In_z_ wchar_t const* _String
+        );
+
+    _Check_return_
+    _ACRTIMP __int64 __cdecl _wtoi64_l(
+        _In_z_   wchar_t const* _String,
+        _In_opt_ _locale_t      _Locale
+        );
+
+    _Check_return_
+    _ACRTIMP __int64 __cdecl _wcstoi64(
+        _In_z_                   wchar_t const* _String,
+        _Out_opt_ _Deref_post_z_ wchar_t**      _EndPtr,
+        _In_                     int            _Radix
+        );
+
+    _Check_return_
+    _ACRTIMP __int64 __cdecl _wcstoi64_l(
+        _In_z_                   wchar_t const* _String,
+        _Out_opt_ _Deref_post_z_ wchar_t**      _EndPtr,
+        _In_                     int            _Radix,
+        _In_opt_                 _locale_t      _Locale
+        );
+
+    _Check_return_
+    _ACRTIMP unsigned __int64 __cdecl _wcstoui64(
+        _In_z_                   wchar_t const* _String,
+        _Out_opt_ _Deref_post_z_ wchar_t**      _EndPtr,
+        _In_                     int            _Radix
+        );
+
+    _Check_return_
+    _ACRTIMP unsigned __int64 __cdecl _wcstoui64_l(
+        _In_z_                   wchar_t const* _String,
+        _Out_opt_ _Deref_post_z_ wchar_t**      _EndPtr,
+        _In_                     int            _Radix,
+        _In_opt_                 _locale_t      _Locale
+        );
+
+    #pragma push_macro("_wfullpath")
+    #undef _wfullpath
+
+    _Success_(return != 0)
+    _Check_return_
+    _ACRTIMP _CRTALLOCATOR wchar_t* __cdecl _wfullpath(
+        _Out_writes_opt_z_(_BufferCount) wchar_t*       _Buffer,
+        _In_z_                           wchar_t const* _Path,
+        _In_                             size_t         _BufferCount
+        );
+
+    #pragma pop_macro("_wfullpath")
+
+    _Check_return_wat_
+    _ACRTIMP errno_t __cdecl _wmakepath_s(
+        _Out_writes_z_(_BufferCount) wchar_t*       _Buffer,
+        _In_                         size_t         _BufferCount,
+        _In_opt_z_                   wchar_t const* _Drive,
+        _In_opt_z_                   wchar_t const* _Dir,
+        _In_opt_z_                   wchar_t const* _Filename,
+        _In_opt_z_                   wchar_t const* _Ext
+        );
+
+    __DEFINE_CPP_OVERLOAD_SECURE_FUNC_0_4(
+        errno_t, _wmakepath_s,
+                   wchar_t,        _Buffer,
+        _In_opt_z_ wchar_t const*, _Drive,
+        _In_opt_z_ wchar_t const*, _Dir,
+        _In_opt_z_ wchar_t const*, _Filename,
+        _In_opt_z_ wchar_t const*, _Ext
+        )
+
+__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_4(
+        void, __RETURN_POLICY_VOID, _ACRTIMP, _wmakepath,
+        _Pre_notnull_ _Post_z_, wchar_t,        _Buffer,
+        _In_opt_z_              wchar_t const*, _Drive,
+        _In_opt_z_              wchar_t const*, _Dir,
+        _In_opt_z_              wchar_t const*, _Filename,
+        _In_opt_z_              wchar_t const*, _Ext
+        )
+
+    _ACRTIMP void __cdecl _wperror(
+        _In_opt_z_ wchar_t const* _ErrorMessage
+        );
+
+    _CRT_INSECURE_DEPRECATE(_wsplitpath_s)
+    _ACRTIMP void __cdecl _wsplitpath(
+        _In_z_                   wchar_t const* _FullPath,
+        _Pre_maybenull_ _Post_z_ wchar_t*       _Drive,
+        _Pre_maybenull_ _Post_z_ wchar_t*       _Dir,
+        _Pre_maybenull_ _Post_z_ wchar_t*       _Filename,
+        _Pre_maybenull_ _Post_z_ wchar_t*       _Ext
+        );
+
+    _ACRTIMP errno_t __cdecl _wsplitpath_s(
+        _In_z_                             wchar_t const* _FullPath,
+        _Out_writes_opt_z_(_DriveCount)    wchar_t*       _Drive,
+        _In_                               size_t         _DriveCount,
+        _Out_writes_opt_z_(_DirCount)      wchar_t*       _Dir,
+        _In_                               size_t         _DirCount,
+        _Out_writes_opt_z_(_FilenameCount) wchar_t*       _Filename,
+        _In_                               size_t         _FilenameCount,
+        _Out_writes_opt_z_(_ExtCount)      wchar_t*       _Ext,
+        _In_                               size_t         _ExtCount
+        );
+
+    __DEFINE_CPP_OVERLOAD_SECURE_FUNC_SPLITPATH(
+        errno_t, _wsplitpath_s,
+        wchar_t, _Path
+        )
+
+        #pragma push_macro("_wdupenv_s")
+        #undef _wdupenv_s
+
+        _Check_return_wat_
+        _DCRTIMP errno_t __cdecl _wdupenv_s(
+            _Outptr_result_buffer_maybenull_(*_BufferCount) _Outptr_result_maybenull_z_ wchar_t**      _Buffer,
+            _Out_opt_                                                                   size_t*        _BufferCount,
+            _In_z_                                                                      wchar_t const* _VarName
+            );
+
+        #pragma pop_macro("_wdupenv_s")
+
+        _Check_return_ _CRT_INSECURE_DEPRECATE(_wdupenv_s)
+        _DCRTIMP wchar_t* __cdecl _wgetenv(
+            _In_z_ wchar_t const* _VarName
+            );
+
+        _Success_(return == 0)
+        _Check_return_wat_
+        _DCRTIMP errno_t __cdecl _wgetenv_s(
+            _Out_                            size_t*        _RequiredCount,
+            _Out_writes_opt_z_(_BufferCount) wchar_t*       _Buffer,
+            _In_                             size_t         _BufferCount,
+            _In_z_                           wchar_t const* _VarName
+            );
+
+        __DEFINE_CPP_OVERLOAD_SECURE_FUNC_1_1(
+            _Success_(return == 0)
+            errno_t, _wgetenv_s,
+            _Out_  size_t*,        _RequiredCount,
+                   wchar_t,        _Buffer,
+            _In_z_ wchar_t const*, _VarName
+            )
+
+        _Check_return_
+        _DCRTIMP int __cdecl _wputenv(
+            _In_z_ wchar_t const* _EnvString
+            );
+
+        _Check_return_wat_
+        _DCRTIMP errno_t __cdecl _wputenv_s(
+            _In_z_ wchar_t const* _Name,
+            _In_z_ wchar_t const* _Value
+            );
+
+        _DCRTIMP errno_t __cdecl _wsearchenv_s(
+            _In_z_                       wchar_t const* _Filename,
+            _In_z_                       wchar_t const* _VarName,
+            _Out_writes_z_(_BufferCount) wchar_t*       _Buffer,
+            _In_                         size_t         _BufferCount
+            );
+
+        __DEFINE_CPP_OVERLOAD_SECURE_FUNC_2_0(
+            errno_t, _wsearchenv_s,
+            _In_z_ wchar_t const*, _Filename,
+            _In_z_ wchar_t const*, _VarName,
+                   wchar_t,        _ResultPath
+                   )
+
+        __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_2_0(
+            void, __RETURN_POLICY_VOID, _DCRTIMP, _wsearchenv,
+            _In_z_                  wchar_t const*, _Filename,
+            _In_z_                  wchar_t const*, _VarName,
+            _Pre_notnull_ _Post_z_, wchar_t,        _ResultPath
+            )
+
+        _DCRTIMP int __cdecl _wsystem(
+            _In_opt_z_ wchar_t const* _Command
+            );
+
+#endif // _CRT_FUNCTIONS_REQUIRED
+
+
+
+_CRT_END_C_HEADER
+_UCRT_RESTORE_CLANG_WARNINGS
+#pragma warning(pop) // _UCRT_DISABLED_WARNINGS

.ccls-cache/@@home@anon@Documents@Code@minecraftconsoles/@home@anon@msvc@Windows Kits@10@Include@10.0.26100.0@ucrt@corecrt_wstring.h

@@ -0,0 +1,642 @@
+//
+// corecrt_wstring.h
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// This file declares the wide character (wchar_t) string functionality, shared
+// by <string.h> and <wchar.h>.
+//
+#pragma once
+
+#include <corecrt.h>
+#include <vcruntime_string.h>
+
+#pragma warning(push)
+#pragma warning(disable: _UCRT_DISABLED_WARNINGS)
+_UCRT_DISABLE_CLANG_WARNINGS
+
+#ifndef __midl
+
+_CRT_BEGIN_C_HEADER
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Secure Alternatives
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+#if __STDC_WANT_SECURE_LIB__
+
+    _Check_return_wat_
+    _ACRTIMP errno_t __cdecl wcscat_s(
+        _Inout_updates_z_(_SizeInWords) wchar_t* _Destination,
+        _In_ rsize_t _SizeInWords,
+        _In_z_ wchar_t const* _Source
+        );
+
+    _Check_return_wat_
+    _ACRTIMP errno_t __cdecl wcscpy_s(
+        _Out_writes_z_(_SizeInWords) wchar_t* _Destination,
+        _In_ rsize_t _SizeInWords,
+        _In_z_ wchar_t const* _Source
+        );
+
+    _Check_return_wat_
+    _ACRTIMP errno_t __cdecl wcsncat_s(
+        _Inout_updates_z_(_SizeInWords) wchar_t*       _Destination,
+        _In_                            rsize_t        _SizeInWords,
+        _In_reads_or_z_(_MaxCount)      wchar_t const* _Source,
+        _In_                            rsize_t        _MaxCount
+        );
+
+    _Check_return_wat_
+    _ACRTIMP errno_t __cdecl wcsncpy_s(
+        _Out_writes_z_(_SizeInWords) wchar_t*       _Destination,
+        _In_                         rsize_t        _SizeInWords,
+        _In_reads_or_z_(_MaxCount)   wchar_t const* _Source,
+        _In_                         rsize_t        _MaxCount
+        );
+
+    _Check_return_
+    _ACRTIMP wchar_t* __cdecl wcstok_s(
+        _Inout_opt_z_                 wchar_t*       _String,
+        _In_z_                        wchar_t const* _Delimiter,
+        _Inout_ _Deref_prepost_opt_z_ wchar_t**      _Context
+        );
+
+#endif // __STDC_WANT_SECURE_LIB__
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Wide-Character <string.h> Functions
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+#if defined _DEBUG && defined _CRTDBG_MAP_ALLOC
+    #pragma push_macro("_wcsdup")
+    #undef _wcsdup
+#endif
+
+_Check_return_
+_ACRTIMP _CRTALLOCATOR wchar_t* __cdecl _wcsdup(
+    _In_z_ wchar_t const* _String
+    );
+
+#if defined _DEBUG && defined _CRTDBG_MAP_ALLOC
+    #pragma pop_macro("_wcsdup")
+#endif
+
+
+
+__DEFINE_CPP_OVERLOAD_SECURE_FUNC_0_1(
+    errno_t, wcscat_s,
+           wchar_t,        _Destination,
+    _In_z_ wchar_t const*, _Source
+    )
+
+#ifndef RC_INVOKED
+    __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_1(
+        wchar_t*, __RETURN_POLICY_DST, _ACRTIMP, wcscat,
+        _Inout_updates_z_(_String_length_(_Destination) + _String_length_(_Source) + 1), wchar_t,        _Destination,
+        _In_z_                                                                           wchar_t const*, _Source
+        )
+#endif
+
+_Check_return_
+_ACRTIMP int __cdecl wcscmp(
+    _In_z_ wchar_t const* _String1,
+    _In_z_ wchar_t const* _String2
+    );
+
+__DEFINE_CPP_OVERLOAD_SECURE_FUNC_0_1(
+    errno_t, wcscpy_s,
+           wchar_t,        _Destination,
+    _In_z_ wchar_t const*, _Source
+    )
+
+__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_1(
+    wchar_t*, __RETURN_POLICY_DST, _ACRTIMP, wcscpy,
+    _Out_writes_z_(_String_length_(_Source) + 1), wchar_t,        _Destination,
+    _In_z_                                        wchar_t const*, _Source
+    )
+
+_Check_return_
+_ACRTIMP size_t __cdecl wcscspn(
+    _In_z_ wchar_t const* _String,
+    _In_z_ wchar_t const* _Control
+    );
+
+_Check_return_
+_ACRTIMP size_t __cdecl wcslen(
+    _In_z_ wchar_t const* _String
+    );
+
+_Check_return_
+_When_(
+    _MaxCount > _String_length_(_Source),
+    _Post_satisfies_(return == _String_length_(_Source))
+)
+_When_(
+    _MaxCount <= _String_length_(_Source),
+    _Post_satisfies_(return == _MaxCount)
+)
+_ACRTIMP size_t __cdecl wcsnlen(
+    _In_reads_or_z_(_MaxCount) wchar_t const* _Source,
+    _In_                       size_t         _MaxCount
+    );
+
+#if __STDC_WANT_SECURE_LIB__ && !defined(__midl)
+
+    _Check_return_
+    _When_(
+        _MaxCount > _String_length_(_Source),
+        _Post_satisfies_(return == _String_length_(_Source))
+    )
+    _When_(
+        _MaxCount <= _String_length_(_Source),
+        _Post_satisfies_(return == _MaxCount)
+    )
+    _CRT_NONSTANDARD_STATIC __inline size_t __CRTDECL wcsnlen_s(
+        _In_reads_or_z_(_MaxCount) wchar_t const* _Source,
+        _In_                       size_t         _MaxCount
+        )
+    {
+        return (_Source == 0) ? 0 : wcsnlen(_Source, _MaxCount);
+    }
+
+#endif // __STDC_WANT_SECURE_LIB__ && !defined(__midl)
+
+__DEFINE_CPP_OVERLOAD_SECURE_FUNC_0_2(
+    errno_t, wcsncat_s,
+    _Prepost_z_             wchar_t,        _Destination,
+    _In_reads_or_z_(_Count) wchar_t const*, _Source,
+    _In_                    size_t,         _Count
+    )
+
+__DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_2_EX(
+    wchar_t*, __RETURN_POLICY_DST, _ACRTIMP, wcsncat, wcsncat_s,
+    _Inout_updates_z_(_Size)   wchar_t,
+    _Inout_updates_z_(_Count), wchar_t,        _Destination,
+    _In_reads_or_z_(_Count)    wchar_t const*, _Source,
+    _In_                       size_t,         _Count
+    )
+
+_Check_return_
+_ACRTIMP int __cdecl wcsncmp(
+    _In_reads_or_z_(_MaxCount) wchar_t const* _String1,
+    _In_reads_or_z_(_MaxCount) wchar_t const* _String2,
+    _In_                       size_t         _MaxCount
+    );
+
+__DEFINE_CPP_OVERLOAD_SECURE_FUNC_0_2(
+    errno_t, wcsncpy_s,
+                            wchar_t,        _Destination,
+    _In_reads_or_z_(_Count) wchar_t const*, _Source,
+    _In_                    size_t,         _Count
+    )
+
+__DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_2_EX(
+    wchar_t*, __RETURN_POLICY_DST, _ACRTIMP, wcsncpy, wcsncpy_s,
+    _Pre_notnull_ _Post_maybez_         wchar_t,
+    _Out_writes_(_Count) _Post_maybez_, wchar_t,        _Destination,
+    _In_reads_or_z_(_Count)             wchar_t const*, _Source,
+    _In_                                size_t,         _Count
+    )
+
+_Check_return_
+_ACRTIMP wchar_t _CONST_RETURN* __cdecl wcspbrk(
+    _In_z_ wchar_t const* _String,
+    _In_z_ wchar_t const* _Control
+    );
+
+_Check_return_
+_ACRTIMP size_t __cdecl wcsspn(
+    _In_z_ wchar_t const* _String,
+    _In_z_ wchar_t const* _Control
+    );
+
+_Check_return_ _CRT_INSECURE_DEPRECATE(wcstok_s)
+_ACRTIMP wchar_t* __cdecl wcstok(
+    _Inout_opt_z_                     wchar_t*       _String,
+    _In_z_                            wchar_t const* _Delimiter,
+    _Inout_opt_ _Deref_prepost_opt_z_ wchar_t**      _Context
+    );
+
+#if !defined RC_INVOKED && !defined __midl
+
+    #if defined _CRT_NON_CONFORMING_WCSTOK
+        #define _WCSTOK_DEPRECATED _CRT_INSECURE_DEPRECATE(wcstok_s)
+    #else
+        #define _WCSTOK_DEPRECATED _CRT_DEPRECATE_TEXT(                           \
+                "wcstok has been changed to conform with the ISO C standard, "    \
+                "adding an extra context parameter. To use the legacy Microsoft " \
+                "wcstok, define _CRT_NON_CONFORMING_WCSTOK.")
+    #endif
+
+    // TRANSITION OS-58345186: this function should have external linkage.
+    _Check_return_ _CRT_INSECURE_DEPRECATE(wcstok_s)
+    static __inline wchar_t* __CRTDECL _wcstok(
+        _Inout_opt_z_ wchar_t*       const _String,
+        _In_z_        wchar_t const* const _Delimiter
+        )
+    {
+        return wcstok(_String, _Delimiter, 0);
+    }
+
+    #if defined _CRT_NON_CONFORMING_WCSTOK && !defined __cplusplus
+        #define wcstok _wcstok
+    #endif
+
+    #if defined __cplusplus && !defined _CRT_NO_INLINE_DEPRECATED_WCSTOK
+        extern "C++" _Check_return_ _WCSTOK_DEPRECATED
+        inline wchar_t* __CRTDECL wcstok(
+            _Inout_opt_z_ wchar_t*       _String,
+            _In_z_        wchar_t const* _Delimiter
+            ) throw()
+        {
+            return wcstok(_String, _Delimiter, 0);
+        }
+    #endif
+
+#endif // !defined RC_INVOKED && !defined __midl
+
+
+
+_Ret_z_
+_Check_return_ _CRT_INSECURE_DEPRECATE(_wcserror_s)
+_ACRTIMP wchar_t* __cdecl _wcserror(
+    _In_ int _ErrorNumber
+    );
+
+_Check_return_wat_
+_ACRTIMP errno_t __cdecl _wcserror_s(
+    _Out_writes_opt_z_(_SizeInWords) wchar_t* _Buffer,
+    _In_                             size_t   _SizeInWords,
+    _In_                             int      _ErrorNumber
+    );
+
+__DEFINE_CPP_OVERLOAD_SECURE_FUNC_0_1(
+    errno_t, _wcserror_s,
+         wchar_t, _Buffer,
+    _In_ int,     _Error
+    )
+
+_Ret_z_
+_Success_(return != 0)
+_Check_return_ _CRT_INSECURE_DEPRECATE(__wcserror_s)
+_ACRTIMP wchar_t* __cdecl __wcserror(
+    _In_opt_z_ wchar_t const* _String
+    );
+
+_Check_return_wat_ _ACRTIMP_ALT errno_t __cdecl __wcserror_s(
+    _Out_writes_opt_z_(_SizeInWords) wchar_t*       _Buffer,
+    _In_                             size_t         _SizeInWords,
+    _In_z_                           wchar_t const* _ErrorMessage
+    );
+
+__DEFINE_CPP_OVERLOAD_SECURE_FUNC_0_1(
+    errno_t, __wcserror_s,
+           wchar_t,        _Buffer,
+    _In_z_ wchar_t const*, _ErrorMessage
+    )
+
+_Check_return_ _ACRTIMP int __cdecl _wcsicmp(
+    _In_z_ wchar_t const* _String1,
+    _In_z_ wchar_t const* _String2
+    );
+
+_Check_return_ _ACRTIMP int __cdecl _wcsicmp_l(
+    _In_z_   wchar_t const* _String1,
+    _In_z_   wchar_t const* _String2,
+    _In_opt_ _locale_t      _Locale
+    );
+
+_Check_return_ _ACRTIMP int __cdecl _wcsnicmp(
+    _In_reads_or_z_(_MaxCount) wchar_t const* _String1,
+    _In_reads_or_z_(_MaxCount) wchar_t const* _String2,
+    _In_                       size_t         _MaxCount
+    );
+
+_Check_return_ _ACRTIMP int __cdecl _wcsnicmp_l(
+    _In_reads_or_z_(_MaxCount) wchar_t const* _String1,
+    _In_reads_or_z_(_MaxCount) wchar_t const* _String2,
+    _In_                       size_t         _MaxCount,
+    _In_opt_                   _locale_t      _Locale
+    );
+
+_Check_return_wat_ _ACRTIMP errno_t __cdecl _wcsnset_s(
+    _Inout_updates_z_(_SizeInWords) wchar_t* _Destination,
+    _In_                            size_t   _SizeInWords,
+    _In_                            wchar_t  _Value,
+    _In_                            size_t   _MaxCount
+    );
+
+__DEFINE_CPP_OVERLOAD_SECURE_FUNC_0_2(
+    errno_t, _wcsnset_s,
+    _Prepost_z_ wchar_t, _Destination,
+    _In_        wchar_t, _Value,
+    _In_         size_t, _MaxCount
+    )
+
+__DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_2_EX(
+    wchar_t*, __RETURN_POLICY_DST, _ACRTIMP, _wcsnset, _wcsnset_s,
+    _Inout_updates_z_(_Size)      wchar_t,
+    _Inout_updates_z_(_MaxCount), wchar_t, _String,
+    _In_                          wchar_t, _Value,
+    _In_                          size_t,  _MaxCount
+    )
+
+_ACRTIMP wchar_t* __cdecl _wcsrev(
+    _Inout_z_ wchar_t* _String
+    );
+
+_Check_return_wat_ _ACRTIMP errno_t __cdecl _wcsset_s(
+    _Inout_updates_z_(_SizeInWords) wchar_t* _Destination,
+    _In_                            size_t   _SizeInWords,
+    _In_                            wchar_t  _Value
+    );
+
+__DEFINE_CPP_OVERLOAD_SECURE_FUNC_0_1(
+    errno_t, _wcsset_s,
+    _Prepost_z_ wchar_t, _String,
+    _In_        wchar_t, _Value
+    )
+
+__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_1_EX(
+    wchar_t*, __RETURN_POLICY_DST, _ACRTIMP, _wcsset, _wcsset_s,
+    _Inout_updates_z_(_Size) wchar_t,
+    _Inout_z_,               wchar_t, _String,
+    _In_                     wchar_t, _Value
+    )
+
+_Check_return_wat_ _ACRTIMP errno_t __cdecl _wcslwr_s(
+    _Inout_updates_z_(_SizeInWords) wchar_t* _String,
+    _In_                            size_t   _SizeInWords
+    );
+
+__DEFINE_CPP_OVERLOAD_SECURE_FUNC_0_0(
+    errno_t, _wcslwr_s,
+    _Prepost_z_ wchar_t, _String
+    )
+
+__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_0(
+    wchar_t*, __RETURN_POLICY_DST, _ACRTIMP, _wcslwr,
+    _Inout_z_, wchar_t, _String
+    )
+
+_Check_return_wat_
+_ACRTIMP errno_t __cdecl _wcslwr_s_l(
+    _Inout_updates_z_(_SizeInWords) wchar_t*  _String,
+    _In_                            size_t    _SizeInWords,
+    _In_opt_                        _locale_t _Locale
+    );
+
+__DEFINE_CPP_OVERLOAD_SECURE_FUNC_0_1(
+    errno_t, _wcslwr_s_l,
+    _Prepost_z_ wchar_t,   _String,
+    _In_opt_    _locale_t, _Locale
+    )
+
+__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_1_EX(
+    wchar_t*, __RETURN_POLICY_DST, _ACRTIMP, _wcslwr_l, _wcslwr_s_l,
+    _Inout_updates_z_(_Size) wchar_t,
+    _Inout_z_,               wchar_t,   _String,
+    _In_opt_                 _locale_t, _Locale
+    )
+
+_Check_return_wat_
+_ACRTIMP errno_t __cdecl _wcsupr_s(
+    _Inout_updates_z_(_Size) wchar_t* _String,
+    _In_                     size_t   _Size
+    );
+
+__DEFINE_CPP_OVERLOAD_SECURE_FUNC_0_0(
+    errno_t, _wcsupr_s,
+    _Prepost_z_ wchar_t, _String
+    )
+
+__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_0(
+    wchar_t*, __RETURN_POLICY_DST, _ACRTIMP, _wcsupr,
+    _Inout_z_, wchar_t, _String
+    )
+
+_Check_return_wat_
+_ACRTIMP errno_t __cdecl _wcsupr_s_l(
+    _Inout_updates_z_(_Size) wchar_t*  _String,
+    _In_                     size_t    _Size,
+    _In_opt_                 _locale_t _Locale
+    );
+
+__DEFINE_CPP_OVERLOAD_SECURE_FUNC_0_1(
+    errno_t, _wcsupr_s_l,
+    _Prepost_z_ wchar_t,   _String,
+    _In_opt_    _locale_t, _Locale
+    )
+
+__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_1_EX(
+    wchar_t*, __RETURN_POLICY_DST, _ACRTIMP, _wcsupr_l, _wcsupr_s_l,
+    _Inout_updates_z_(_Size) wchar_t,
+    _Inout_z_,               wchar_t,   _String,
+    _In_opt_                 _locale_t, _Locale
+    )
+
+_Success_(return < _MaxCount)
+_Check_return_opt_
+_ACRTIMP size_t __cdecl wcsxfrm(
+    _Out_writes_opt_(_MaxCount) _Post_maybez_ wchar_t*       _Destination,
+    _In_z_                                    wchar_t const* _Source,
+    _In_ _In_range_(<= ,_CRT_INT_MAX)         size_t         _MaxCount
+    );
+
+_Success_(return < _MaxCount)
+_Check_return_opt_
+_ACRTIMP size_t __cdecl _wcsxfrm_l(
+    _Out_writes_opt_(_MaxCount) _Post_maybez_ wchar_t*       _Destination,
+    _In_z_                                    wchar_t const* _Source,
+    _In_ _In_range_(<= ,_CRT_INT_MAX)         size_t         _MaxCount,
+    _In_opt_                                  _locale_t      _Locale
+    );
+
+_Check_return_
+_ACRTIMP int __cdecl wcscoll(
+    _In_z_ wchar_t const* _String1,
+    _In_z_ wchar_t const* _String2
+    );
+
+_Check_return_
+_ACRTIMP int __cdecl _wcscoll_l(
+    _In_z_   wchar_t const* _String1,
+    _In_z_   wchar_t const* _String2,
+    _In_opt_ _locale_t      _Locale
+    );
+
+_Check_return_
+_ACRTIMP int __cdecl _wcsicoll(
+    _In_z_ wchar_t const* _String1,
+    _In_z_ wchar_t const* _String2
+    );
+
+_Check_return_
+_ACRTIMP int __cdecl _wcsicoll_l(
+    _In_z_   wchar_t const* _String1,
+    _In_z_   wchar_t const* _String2,
+    _In_opt_ _locale_t      _Locale
+    );
+
+_Check_return_
+_ACRTIMP int __cdecl _wcsncoll(
+    _In_reads_or_z_(_MaxCount) wchar_t const* _String1,
+    _In_reads_or_z_(_MaxCount) wchar_t const* _String2,
+    _In_                       size_t         _MaxCount
+    );
+
+_Check_return_
+_ACRTIMP int __cdecl _wcsncoll_l(
+    _In_reads_or_z_(_MaxCount) wchar_t const* _String1,
+    _In_reads_or_z_(_MaxCount) wchar_t const* _String2,
+    _In_                       size_t         _MaxCount,
+    _In_opt_                   _locale_t      _Locale
+    );
+
+_Check_return_
+_ACRTIMP int __cdecl _wcsnicoll(
+    _In_reads_or_z_(_MaxCount) wchar_t const* _String1,
+    _In_reads_or_z_(_MaxCount) wchar_t const* _String2,
+    _In_                       size_t         _MaxCount
+    );
+
+_Check_return_
+_ACRTIMP int __cdecl _wcsnicoll_l(
+    _In_reads_or_z_(_MaxCount) wchar_t const* _String1,
+    _In_reads_or_z_(_MaxCount) wchar_t const* _String2,
+    _In_                       size_t         _MaxCount,
+    _In_opt_                   _locale_t      _Locale
+    );
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Inline C++ Overloads
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+#ifdef __cplusplus
+extern "C++" {
+
+    _Check_return_
+    _When_(return != NULL, _Ret_range_(_String, _String+_String_length_(_String)-1))
+    inline wchar_t* __CRTDECL wcschr(_In_z_ wchar_t* _String, wchar_t _C)
+    {
+        return const_cast<wchar_t*>(wcschr(static_cast<wchar_t const*>(_String), _C));
+    }
+
+    _Check_return_
+    inline wchar_t* __CRTDECL wcspbrk(_In_z_ wchar_t* _String, _In_z_ wchar_t const* _Control)
+    {
+        return const_cast<wchar_t*>(wcspbrk(static_cast<wchar_t const*>(_String), _Control));
+    }
+
+    _Check_return_
+    inline wchar_t* __CRTDECL wcsrchr(_In_z_ wchar_t* _String, _In_ wchar_t _C)
+    {
+        return const_cast<wchar_t*>(wcsrchr(static_cast<wchar_t const*>(_String), _C));
+    }
+
+    _Check_return_ _Ret_maybenull_
+    _When_(return != NULL, _Ret_range_(_String, _String+_String_length_(_String)-1))
+    inline wchar_t* __CRTDECL wcsstr(_In_z_ wchar_t* _String, _In_z_ wchar_t const*_SubStr)
+    {
+        return const_cast<wchar_t*>(wcsstr(static_cast<wchar_t const*>(_String), _SubStr));
+    }
+
+}
+#endif // __cplusplus
+
+
+
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+//
+// Non-Standard Names
+//
+//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+#if defined(_CRT_INTERNAL_NONSTDC_NAMES) && _CRT_INTERNAL_NONSTDC_NAMES
+    #if defined _DEBUG && defined _CRTDBG_MAP_ALLOC
+        #pragma push_macro("wcsdup")
+        #undef wcsdup
+    #endif
+
+    _Check_return_ _CRT_NONSTDC_DEPRECATE(_wcsdup)
+    _ACRTIMP wchar_t* __cdecl wcsdup(
+        _In_z_ wchar_t const* _String
+        );
+
+    #if defined _DEBUG && defined _CRTDBG_MAP_ALLOC
+        #pragma pop_macro("wcsdup")
+    #endif
+
+    // Declarations of functions defined in oldnames.lib:
+    #define wcswcs wcsstr
+
+    _Check_return_ _CRT_NONSTDC_DEPRECATE(_wcsicmp)
+    _ACRTIMP int __cdecl wcsicmp(
+        _In_z_ wchar_t const* _String1,
+        _In_z_ wchar_t const* _String2
+        );
+
+    _Check_return_ _CRT_NONSTDC_DEPRECATE(_wcsnicmp)
+    _ACRTIMP int __cdecl wcsnicmp(
+        _In_reads_or_z_(_MaxCount) wchar_t const* _String1,
+        _In_reads_or_z_(_MaxCount) wchar_t const* _String2,
+        _In_                       size_t         _MaxCount
+        );
+
+    _CRT_NONSTDC_DEPRECATE(_wcsnset)
+    _Ret_z_
+    _ACRTIMP wchar_t* __cdecl wcsnset(
+        _Inout_updates_z_(_MaxCount) wchar_t* _String,
+        _In_                         wchar_t  _Value,
+        _In_                         size_t   _MaxCount
+        );
+
+    _CRT_NONSTDC_DEPRECATE(_wcsrev)
+    _Ret_z_
+    _ACRTIMP wchar_t* __cdecl wcsrev(
+        _Inout_z_ wchar_t* _String
+        );
+
+    _CRT_NONSTDC_DEPRECATE(_wcsset)
+    _Ret_z_
+    _ACRTIMP wchar_t* __cdecl wcsset(
+        _Inout_z_ wchar_t* _String,
+        _In_      wchar_t  _Value
+        );
+
+    _CRT_NONSTDC_DEPRECATE(_wcslwr)
+    _Ret_z_
+    _ACRTIMP wchar_t* __cdecl wcslwr(
+        _Inout_z_ wchar_t* _String
+        );
+
+    _CRT_NONSTDC_DEPRECATE(_wcsupr)
+    _Ret_z_
+    _ACRTIMP wchar_t* __cdecl wcsupr(
+        _Inout_z_ wchar_t* _String
+        );
+
+    _Check_return_ _CRT_NONSTDC_DEPRECATE(_wcsicoll)
+    _ACRTIMP int __cdecl wcsicoll(
+        _In_z_ wchar_t const* _String1,
+        _In_z_ wchar_t const* _String2
+        );
+
+#endif // _CRT_INTERNAL_NONSTDC_NAMES
+
+
+
+_CRT_END_C_HEADER
+
+#endif // !__midl
+_UCRT_RESTORE_CLANG_WARNINGS
+#pragma warning(pop) // _UCRT_DISABLED_WARNINGS

.ccls-cache/@@home@anon@Documents@Code@minecraftconsoles/@home@anon@msvc@Windows Kits@10@Include@10.0.26100.0@ucrt@errno.h

@@ -0,0 +1,137 @@
+//
+// errno.h
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// System error numbers for use with errno and errno_t.
+//
+#pragma once
+#ifndef _INC_ERRNO // include guard for 3rd party interop
+#define _INC_ERRNO
+
+#include <corecrt.h>
+
+#pragma warning(push)
+#pragma warning(disable: _UCRT_DISABLED_WARNINGS)
+_UCRT_DISABLE_CLANG_WARNINGS
+
+_CRT_BEGIN_C_HEADER
+
+
+
+#if _CRT_FUNCTIONS_REQUIRED
+    _ACRTIMP int* __cdecl _errno(void);
+    #define errno (*_errno())
+
+    _ACRTIMP errno_t __cdecl _set_errno(_In_ int _Value);
+    _ACRTIMP errno_t __cdecl _get_errno(_Out_ int* _Value);
+
+    _ACRTIMP unsigned long* __cdecl __doserrno(void);
+    #define _doserrno (*__doserrno())
+
+    _ACRTIMP errno_t __cdecl _set_doserrno(_In_ unsigned long _Value);
+    _ACRTIMP errno_t __cdecl _get_doserrno(_Out_ unsigned long * _Value);
+#endif // _CRT_FUNCTIONS_REQUIRED
+
+
+
+// Error codes
+#define EPERM           1
+#define ENOENT          2
+#define ESRCH           3
+#define EINTR           4
+#define EIO             5
+#define ENXIO           6
+#define E2BIG           7
+#define ENOEXEC         8
+#define EBADF           9
+#define ECHILD          10
+#define EAGAIN          11
+#define ENOMEM          12
+#define EACCES          13
+#define EFAULT          14
+#define EBUSY           16
+#define EEXIST          17
+#define EXDEV           18
+#define ENODEV          19
+#define ENOTDIR         20
+#define EISDIR          21
+#define ENFILE          23
+#define EMFILE          24
+#define ENOTTY          25
+#define EFBIG           27
+#define ENOSPC          28
+#define ESPIPE          29
+#define EROFS           30
+#define EMLINK          31
+#define EPIPE           32
+#define EDOM            33
+#define EDEADLK         36
+#define ENAMETOOLONG    38
+#define ENOLCK          39
+#define ENOSYS          40
+#define ENOTEMPTY       41
+
+// Error codes used in the Secure CRT functions
+#ifndef RC_INVOKED
+    #define _SECURECRT_ERRCODE_VALUES_DEFINED
+    #define EINVAL          22
+    #define ERANGE          34
+    #define EILSEQ          42
+    #define STRUNCATE       80
+#endif
+
+// Support EDEADLOCK for compatibility with older Microsoft C versions
+#define EDEADLOCK       EDEADLK
+
+// POSIX Supplement
+#ifndef _CRT_NO_POSIX_ERROR_CODES
+    #define EADDRINUSE      100
+    #define EADDRNOTAVAIL   101
+    #define EAFNOSUPPORT    102
+    #define EALREADY        103
+    #define EBADMSG         104
+    #define ECANCELED       105
+    #define ECONNABORTED    106
+    #define ECONNREFUSED    107
+    #define ECONNRESET      108
+    #define EDESTADDRREQ    109
+    #define EHOSTUNREACH    110
+    #define EIDRM           111
+    #define EINPROGRESS     112
+    #define EISCONN         113
+    #define ELOOP           114
+    #define EMSGSIZE        115
+    #define ENETDOWN        116
+    #define ENETRESET       117
+    #define ENETUNREACH     118
+    #define ENOBUFS         119
+    #define ENODATA         120
+    #define ENOLINK         121
+    #define ENOMSG          122
+    #define ENOPROTOOPT     123
+    #define ENOSR           124
+    #define ENOSTR          125
+    #define ENOTCONN        126
+    #define ENOTRECOVERABLE 127
+    #define ENOTSOCK        128
+    #define ENOTSUP         129
+    #define EOPNOTSUPP      130
+    #define EOTHER          131
+    #define EOVERFLOW       132
+    #define EOWNERDEAD      133
+    #define EPROTO          134
+    #define EPROTONOSUPPORT 135
+    #define EPROTOTYPE      136
+    #define ETIME           137
+    #define ETIMEDOUT       138
+    #define ETXTBSY         139
+    #define EWOULDBLOCK     140
+#endif // _CRT_NO_POSIX_ERROR_CODES
+
+
+
+_CRT_END_C_HEADER
+_UCRT_RESTORE_CLANG_WARNINGS
+#pragma warning(pop) // _UCRT_DISABLED_WARNINGS
+#endif // _INC_ERRNO

.ccls-cache/@@home@anon@Documents@Code@minecraftconsoles/@home@anon@msvc@Windows Kits@10@Include@10.0.26100.0@ucrt@fcntl.h

@@ -0,0 +1,68 @@
+//
+// fcntl.h
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// File control options used by _open().
+//
+#pragma once
+#ifndef _INC_FCNTL // include guard for 3rd party interop
+#define _INC_FCNTL
+
+#include <corecrt.h>
+
+#pragma warning(push)
+#pragma warning(disable: _UCRT_DISABLED_WARNINGS)
+_UCRT_DISABLE_CLANG_WARNINGS
+
+#define _O_RDONLY      0x0000  // open for reading only
+#define _O_WRONLY      0x0001  // open for writing only
+#define _O_RDWR        0x0002  // open for reading and writing
+#define _O_APPEND      0x0008  // writes done at eof
+
+#define _O_CREAT       0x0100  // create and open file
+#define _O_TRUNC       0x0200  // open and truncate
+#define _O_EXCL        0x0400  // open only if file doesn't already exist
+
+// O_TEXT files have <cr><lf> sequences translated to <lf> on read()'s and <lf>
+// sequences translated to <cr><lf> on write()'s
+
+#define _O_TEXT        0x4000  // file mode is text (translated)
+#define _O_BINARY      0x8000  // file mode is binary (untranslated)
+#define _O_WTEXT       0x10000 // file mode is UTF16 (translated)
+#define _O_U16TEXT     0x20000 // file mode is UTF16 no BOM (translated)
+#define _O_U8TEXT      0x40000 // file mode is UTF8  no BOM (translated)
+
+// macro to translate the C 2.0 name used to force binary mode for files
+#define _O_RAW _O_BINARY
+
+#define _O_NOINHERIT   0x0080  // child process doesn't inherit file
+#define _O_TEMPORARY   0x0040  // temporary file bit (file is deleted when last handle is closed)
+#define _O_SHORT_LIVED 0x1000  // temporary storage file, try not to flush
+#define _O_OBTAIN_DIR  0x2000  // get information about a directory
+#define _O_SEQUENTIAL  0x0020  // file access is primarily sequential
+#define _O_RANDOM      0x0010  // file access is primarily random
+
+
+
+#if (defined _CRT_DECLARE_NONSTDC_NAMES && _CRT_DECLARE_NONSTDC_NAMES) || (!defined _CRT_DECLARE_NONSTDC_NAMES && !__STDC__)
+    #define O_RDONLY     _O_RDONLY
+    #define O_WRONLY     _O_WRONLY
+    #define O_RDWR       _O_RDWR
+    #define O_APPEND     _O_APPEND
+    #define O_CREAT      _O_CREAT
+    #define O_TRUNC      _O_TRUNC
+    #define O_EXCL       _O_EXCL
+    #define O_TEXT       _O_TEXT
+    #define O_BINARY     _O_BINARY
+    #define O_RAW        _O_BINARY
+    #define O_TEMPORARY  _O_TEMPORARY
+    #define O_NOINHERIT  _O_NOINHERIT
+    #define O_SEQUENTIAL _O_SEQUENTIAL
+    #define O_RANDOM     _O_RANDOM
+#endif
+
+_UCRT_RESTORE_CLANG_WARNINGS
+#pragma warning(pop) // _UCRT_DISABLED_WARNINGS
+
+#endif // _INC_FCNTL

.ccls-cache/@@home@anon@Documents@Code@minecraftconsoles/@home@anon@msvc@Windows Kits@10@Include@10.0.26100.0@ucrt@io.h

@@ -0,0 +1,13 @@
+//
+// io.h
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// This file declares the low-level I/O and file handling functionality.
+//
+#pragma once
+#ifndef _INC_IO // include guard for 3rd party interop
+#define _INC_IO
+
+#include <corecrt_io.h>
+#endif // _INC_IO

.ccls-cache/@@home@anon@Documents@Code@minecraftconsoles/@home@anon@msvc@Windows Kits@10@Include@10.0.26100.0@ucrt@string.h

@@ -0,0 +1,592 @@
+//
+// string.h
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// The C Standard Library <string.h> header.
+//
+#pragma once
+#ifndef _INC_STRING // include guard for 3rd party interop
+#define _INC_STRING
+
+#include <corecrt.h>
+#include <corecrt_memory.h>
+#include <corecrt_wstring.h>
+#include <vcruntime_string.h>
+
+#ifndef __midl
+
+#pragma warning(push)
+#pragma warning(disable: _UCRT_DISABLED_WARNINGS)
+_UCRT_DISABLE_CLANG_WARNINGS
+
+_CRT_BEGIN_C_HEADER
+
+
+
+#define _NLSCMPERROR _CRT_INT_MAX // currently == INT_MAX
+
+#if __STDC_WANT_SECURE_LIB__
+
+    _Check_return_wat_
+    _ACRTIMP errno_t __cdecl strcpy_s(
+        _Out_writes_z_(_SizeInBytes) char*       _Destination,
+        _In_                         rsize_t     _SizeInBytes,
+        _In_z_                       char const* _Source
+        );
+
+    _Check_return_wat_
+    _ACRTIMP errno_t __cdecl strcat_s(
+        _Inout_updates_z_(_SizeInBytes) char*       _Destination,
+        _In_                            rsize_t     _SizeInBytes,
+        _In_z_                          char const* _Source
+        );
+
+    _Check_return_wat_
+    _ACRTIMP errno_t __cdecl strerror_s(
+        _Out_writes_z_(_SizeInBytes) char*  _Buffer,
+        _In_                         size_t _SizeInBytes,
+        _In_                         int    _ErrorNumber);
+
+    _Check_return_wat_
+    _ACRTIMP errno_t __cdecl strncat_s(
+        _Inout_updates_z_(_SizeInBytes) char*       _Destination,
+        _In_                            rsize_t     _SizeInBytes,
+        _In_reads_or_z_(_MaxCount)      char const* _Source,
+        _In_                            rsize_t     _MaxCount
+        );
+
+    _Check_return_wat_
+    _ACRTIMP errno_t __cdecl strncpy_s(
+        _Out_writes_z_(_SizeInBytes) char*       _Destination,
+        _In_                         rsize_t     _SizeInBytes,
+        _In_reads_or_z_(_MaxCount)   char const* _Source,
+        _In_                         rsize_t     _MaxCount
+        );
+
+    _Check_return_
+    _ACRTIMP char*  __cdecl strtok_s(
+        _Inout_opt_z_                 char*       _String,
+        _In_z_                        char const* _Delimiter,
+        _Inout_ _Deref_prepost_opt_z_ char**      _Context
+        );
+
+#endif // __STDC_WANT_SECURE_LIB__
+
+_ACRTIMP void* __cdecl _memccpy(
+    _Out_writes_bytes_opt_(_MaxCount) void*       _Dst,
+    _In_                              void const* _Src,
+    _In_                              int         _Val,
+    _In_                              size_t      _MaxCount
+    );
+
+__DEFINE_CPP_OVERLOAD_SECURE_FUNC_0_1(
+    errno_t, strcat_s,
+           char,        _Destination,
+    _In_z_ char const*, _Source
+    )
+
+#ifndef RC_INVOKED
+
+    __DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_1(
+        char*, __RETURN_POLICY_DST, __EMPTY_DECLSPEC, strcat,
+        _Inout_updates_z_(_String_length_(_Destination) + _String_length_(_Source) + 1), char,        _Destination,
+        _In_z_                                                                           char const*, _Source
+        )
+
+#endif // RC_INVOKED
+
+_Check_return_
+int __cdecl strcmp(
+    _In_z_ char const* _Str1,
+    _In_z_ char const* _Str2
+    );
+
+_Check_return_
+_ACRTIMP int __cdecl _strcmpi(
+    _In_z_ char const* _String1,
+    _In_z_ char const* _String2
+    );
+
+_Check_return_
+_ACRTIMP int __cdecl strcoll(
+    _In_z_ char const* _String1,
+    _In_z_ char const* _String2
+    );
+
+_Check_return_
+_ACRTIMP int __cdecl _strcoll_l(
+    _In_z_   char const* _String1,
+    _In_z_   char const* _String2,
+    _In_opt_ _locale_t   _Locale
+    );
+
+__DEFINE_CPP_OVERLOAD_SECURE_FUNC_0_1(
+    errno_t, strcpy_s,
+    _Post_z_ char,        _Destination,
+    _In_z_   char const*, _Source
+    )
+
+__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_1(
+    char*, __RETURN_POLICY_DST, __EMPTY_DECLSPEC, strcpy,
+    _Out_writes_z_(_String_length_(_Source) + 1), char,        _Destination,
+    _In_z_                                        char const*, _Source
+    )
+
+_Check_return_
+_ACRTIMP size_t __cdecl strcspn(
+    _In_z_ char const* _Str,
+    _In_z_ char const* _Control
+    );
+
+#if defined _DEBUG && defined _CRTDBG_MAP_ALLOC
+    #pragma push_macro("_strdup")
+    #undef _strdup
+#endif
+
+_Check_return_
+_ACRTIMP _CRTALLOCATOR char* __cdecl _strdup(
+    _In_opt_z_ char const* _Source
+    );
+
+#if defined _DEBUG && defined _CRTDBG_MAP_ALLOC
+    #pragma pop_macro("_strdup")
+#endif
+
+_Ret_z_
+_Success_(return != 0)
+_Check_return_ _CRT_INSECURE_DEPRECATE(_strerror_s)
+_ACRTIMP char*  __cdecl _strerror(
+    _In_opt_z_ char const* _ErrorMessage
+    );
+
+_Check_return_wat_
+_ACRTIMP errno_t __cdecl _strerror_s(
+    _Out_writes_z_(_SizeInBytes) char*       _Buffer,
+    _In_                         size_t      _SizeInBytes,
+    _In_opt_z_                   char const* _ErrorMessage
+    );
+
+__DEFINE_CPP_OVERLOAD_SECURE_FUNC_0_1(
+    errno_t, _strerror_s,
+               char,        _Buffer,
+    _In_opt_z_ char const*, _ErrorMessage
+    )
+
+_Ret_z_
+_Check_return_ _CRT_INSECURE_DEPRECATE(strerror_s)
+_ACRTIMP char* __cdecl strerror(
+    _In_ int _ErrorMessage
+    );
+
+__DEFINE_CPP_OVERLOAD_SECURE_FUNC_0_1(
+    errno_t, strerror_s,
+        char, _Buffer,
+    _In_ int, _ErrorMessage
+    )
+
+_Check_return_
+_ACRTIMP int __cdecl _stricmp(
+    _In_z_ char const* _String1,
+    _In_z_ char const* _String2
+    );
+
+_Check_return_
+_ACRTIMP int __cdecl _stricoll(
+    _In_z_ char const* _String1,
+    _In_z_ char const* _String2
+    );
+
+_Check_return_
+_ACRTIMP int __cdecl _stricoll_l(
+    _In_z_   char const* _String1,
+    _In_z_   char const* _String2,
+    _In_opt_ _locale_t   _Locale
+    );
+
+_Check_return_
+_ACRTIMP int __cdecl _stricmp_l(
+    _In_z_   char const* _String1,
+    _In_z_   char const* _String2,
+    _In_opt_ _locale_t   _Locale
+    );
+
+_Check_return_
+size_t __cdecl strlen(
+    _In_z_ char const* _Str
+    );
+
+_Check_return_wat_
+_ACRTIMP errno_t __cdecl _strlwr_s(
+    _Inout_updates_z_(_Size) char*  _String,
+    _In_                     size_t _Size
+    );
+
+__DEFINE_CPP_OVERLOAD_SECURE_FUNC_0_0(
+    errno_t, _strlwr_s,
+    _Prepost_z_ char, _String
+    )
+
+__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_0(
+    char*, __RETURN_POLICY_DST, _ACRTIMP, _strlwr,
+    _Inout_z_, char, _String
+    )
+
+_Check_return_wat_
+_ACRTIMP errno_t __cdecl _strlwr_s_l(
+    _Inout_updates_z_(_Size) char*     _String,
+    _In_                     size_t    _Size,
+    _In_opt_                 _locale_t _Locale
+    );
+
+__DEFINE_CPP_OVERLOAD_SECURE_FUNC_0_1(
+    errno_t, _strlwr_s_l,
+    _Prepost_z_ char,      _String,
+    _In_opt_    _locale_t, _Locale
+    )
+
+__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_1_EX(
+    char*, __RETURN_POLICY_DST, _ACRTIMP, _strlwr_l, _strlwr_s_l,
+    _Inout_updates_z_(_Size) char,
+    _Inout_z_,               char,      _String,
+    _In_opt_                 _locale_t, _Locale
+    )
+
+__DEFINE_CPP_OVERLOAD_SECURE_FUNC_0_2(
+    errno_t, strncat_s,
+    _Prepost_z_             char,        _Destination,
+    _In_reads_or_z_(_Count) char const*, _Source,
+    _In_                    size_t,      _Count
+    )
+
+__DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_2_EX(
+    char*, __RETURN_POLICY_DST, _ACRTIMP, strncat, strncat_s,
+    _Inout_updates_z_(_Size)   char,
+    _Inout_updates_z_(_Count), char,        _Destination,
+    _In_reads_or_z_(_Count)    char const*, _Source,
+    _In_                       size_t,      _Count
+    )
+
+_Check_return_
+_ACRTIMP int __cdecl strncmp(
+    _In_reads_or_z_(_MaxCount) char const* _Str1,
+    _In_reads_or_z_(_MaxCount) char const* _Str2,
+    _In_                       size_t      _MaxCount
+    );
+
+_Check_return_
+_ACRTIMP int __cdecl _strnicmp(
+    _In_reads_or_z_(_MaxCount) char const* _String1,
+    _In_reads_or_z_(_MaxCount) char const* _String2,
+    _In_                       size_t      _MaxCount
+    );
+
+_Check_return_
+_ACRTIMP int __cdecl _strnicmp_l(
+    _In_reads_or_z_(_MaxCount) char const* _String1,
+    _In_reads_or_z_(_MaxCount) char const* _String2,
+    _In_                       size_t      _MaxCount,
+    _In_opt_                   _locale_t   _Locale
+    );
+
+_Check_return_
+_ACRTIMP int __cdecl _strnicoll(
+    _In_reads_or_z_(_MaxCount) char const* _String1,
+    _In_reads_or_z_(_MaxCount) char const* _String2,
+    _In_                       size_t      _MaxCount
+    );
+
+_Check_return_
+_ACRTIMP int __cdecl _strnicoll_l(
+    _In_reads_or_z_(_MaxCount) char const* _String1,
+    _In_reads_or_z_(_MaxCount) char const* _String2,
+    _In_                       size_t      _MaxCount,
+    _In_opt_                   _locale_t   _Locale
+    );
+
+_Check_return_
+_ACRTIMP int __cdecl _strncoll(
+    _In_reads_or_z_(_MaxCount) char const* _String1,
+    _In_reads_or_z_(_MaxCount) char const* _String2,
+    _In_                       size_t      _MaxCount
+    );
+
+_Check_return_
+_ACRTIMP int __cdecl _strncoll_l(
+    _In_reads_or_z_(_MaxCount) char const* _String1,
+    _In_reads_or_z_(_MaxCount) char const* _String2,
+    _In_                       size_t      _MaxCount,
+    _In_opt_                   _locale_t   _Locale
+    );
+
+_ACRTIMP size_t __cdecl __strncnt(
+    _In_reads_or_z_(_Count) char const* _String,
+    _In_                    size_t      _Count
+    );
+
+__DEFINE_CPP_OVERLOAD_SECURE_FUNC_0_2(
+    errno_t, strncpy_s,
+                            char,        _Destination,
+    _In_reads_or_z_(_Count) char const*, _Source,
+    _In_                    size_t,      _Count
+    )
+
+__DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_2_EX(
+    char*, __RETURN_POLICY_DST, _ACRTIMP, strncpy, strncpy_s,
+    _Out_writes_z_(_Size)               char,
+    _Out_writes_(_Count) _Post_maybez_, char,        _Destination,
+    _In_reads_or_z_(_Count)             char const*, _Source,
+    _In_                                size_t,      _Count
+    )
+
+_Check_return_
+_When_(
+    _MaxCount > _String_length_(_String),
+    _Post_satisfies_(return == _String_length_(_String))
+)
+_When_(
+    _MaxCount <= _String_length_(_String),
+    _Post_satisfies_(return == _MaxCount)
+)
+_ACRTIMP size_t __cdecl strnlen(
+    _In_reads_or_z_(_MaxCount) char const* _String,
+    _In_                       size_t      _MaxCount
+    );
+
+#if __STDC_WANT_SECURE_LIB__ && !defined __midl
+
+    _Check_return_
+    _When_(
+        _MaxCount > _String_length_(_String),
+        _Post_satisfies_(return == _String_length_(_String))
+    )
+    _When_(
+        _MaxCount <= _String_length_(_String),
+        _Post_satisfies_(return == _MaxCount)
+    )
+    _CRT_NONSTANDARD_STATIC __inline size_t __CRTDECL strnlen_s(
+        _In_reads_or_z_(_MaxCount) char const* _String,
+        _In_                       size_t      _MaxCount
+        )
+    {
+        return _String == 0 ? 0 : strnlen(_String, _MaxCount);
+    }
+
+#endif
+
+_Check_return_wat_
+_ACRTIMP errno_t __cdecl _strnset_s(
+    _Inout_updates_z_(_SizeInBytes) char*  _String,
+    _In_                            size_t _SizeInBytes,
+    _In_                            int    _Value,
+    _In_                            size_t _MaxCount
+    );
+
+__DEFINE_CPP_OVERLOAD_SECURE_FUNC_0_2(
+    errno_t, _strnset_s,
+    _Prepost_z_ char,   _Destination,
+    _In_        int,    _Value,
+    _In_        size_t, _Count
+    )
+
+__DEFINE_CPP_OVERLOAD_STANDARD_NFUNC_0_2_EX(
+    char*, __RETURN_POLICY_DST, _ACRTIMP, _strnset, _strnset_s,
+    _Inout_updates_z_(_Size)   char,
+    _Inout_updates_z_(_Count), char,   _Destination,
+    _In_                       int,    _Value,
+    _In_                       size_t, _Count
+    )
+
+_Check_return_
+_ACRTIMP char _CONST_RETURN* __cdecl strpbrk(
+    _In_z_ char const* _Str,
+    _In_z_ char const* _Control
+    );
+
+_ACRTIMP char* __cdecl _strrev(
+    _Inout_z_ char* _Str
+    );
+
+_Check_return_wat_
+_ACRTIMP errno_t __cdecl _strset_s(
+    _Inout_updates_z_(_DestinationSize) char*  _Destination,
+    _In_                                size_t _DestinationSize,
+    _In_                                int    _Value
+    );
+
+__DEFINE_CPP_OVERLOAD_SECURE_FUNC_0_1(
+    errno_t, _strset_s,
+    _Prepost_z_ char, _Destination,
+    _In_        int,  _Value
+    )
+
+__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_1(
+    char*, __RETURN_POLICY_DST, __EMPTY_DECLSPEC, _strset,
+    _Inout_z_, char, _Destination,
+    _In_       int,  _Value
+    )
+
+_Check_return_
+_ACRTIMP size_t __cdecl strspn(
+    _In_z_ char const* _Str,
+    _In_z_ char const* _Control
+    );
+
+_Check_return_ _CRT_INSECURE_DEPRECATE(strtok_s)
+_ACRTIMP char* __cdecl strtok(
+    _Inout_opt_z_ char*       _String,
+    _In_z_        char const* _Delimiter
+    );
+
+_Check_return_wat_
+_ACRTIMP errno_t __cdecl _strupr_s(
+    _Inout_updates_z_(_Size) char*  _String,
+    _In_                     size_t _Size
+    );
+
+__DEFINE_CPP_OVERLOAD_SECURE_FUNC_0_0(
+    errno_t, _strupr_s,
+    _Prepost_z_ char, _String
+    )
+
+__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_0(
+    char*, __RETURN_POLICY_DST, _ACRTIMP, _strupr,
+    _Inout_z_, char, _String
+    )
+
+_Check_return_wat_
+_ACRTIMP errno_t __cdecl _strupr_s_l(
+    _Inout_updates_z_(_Size) char*     _String,
+    _In_                     size_t    _Size,
+    _In_opt_                 _locale_t _Locale
+    );
+
+__DEFINE_CPP_OVERLOAD_SECURE_FUNC_0_1(
+    errno_t, _strupr_s_l,
+    _Prepost_z_ char,      _String,
+    _In_opt_    _locale_t, _Locale
+    )
+
+__DEFINE_CPP_OVERLOAD_STANDARD_FUNC_0_1_EX(
+    char*, __RETURN_POLICY_DST, _ACRTIMP, _strupr_l, _strupr_s_l,
+    _Inout_updates_z_(_Size) char,
+    _Inout_z_,               char,      _String,
+    _In_opt_                 _locale_t, _Locale
+    )
+
+_Success_(return < _MaxCount)
+_Check_return_opt_
+_ACRTIMP size_t __cdecl strxfrm(
+    _Out_writes_opt_(_MaxCount) _Post_maybez_ char*       _Destination,
+    _In_z_                                    char const* _Source,
+    _In_ _In_range_(<=,_CRT_INT_MAX)          size_t      _MaxCount
+    );
+
+_Success_(return < _MaxCount)
+_Check_return_opt_
+_ACRTIMP size_t __cdecl _strxfrm_l(
+    _Out_writes_opt_(_MaxCount) _Post_maybez_ char*       _Destination,
+    _In_z_                                    char const* _Source,
+    _In_ _In_range_(<=,_CRT_INT_MAX)          size_t      _MaxCount,
+    _In_opt_                                  _locale_t   _Locale
+    );
+
+
+
+#ifdef __cplusplus
+extern "C++"
+{
+    _Check_return_
+    inline char* __CRTDECL strchr(_In_z_ char* const _String, _In_ int const _Ch)
+    {
+        return const_cast<char*>(strchr(static_cast<char const*>(_String), _Ch));
+    }
+
+    _Check_return_
+    inline char* __CRTDECL strpbrk(_In_z_ char* const _String, _In_z_ char const* const _Control)
+    {
+        return const_cast<char*>(strpbrk(static_cast<char const*>(_String), _Control));
+    }
+
+    _Check_return_
+    inline char* __CRTDECL strrchr(_In_z_ char* const _String, _In_ int const _Ch)
+    {
+        return const_cast<char*>(strrchr(static_cast<char const*>(_String), _Ch));
+    }
+
+    _Check_return_ _Ret_maybenull_
+    inline char* __CRTDECL strstr(_In_z_ char* const _String, _In_z_ char const* const _SubString)
+    {
+        return const_cast<char*>(strstr(static_cast<char const*>(_String), _SubString));
+    }
+}
+#endif // __cplusplus
+
+
+
+#if defined(_CRT_INTERNAL_NONSTDC_NAMES) && _CRT_INTERNAL_NONSTDC_NAMES
+
+    #pragma push_macro("strdup")
+    #undef strdup
+    _Check_return_ _CRT_NONSTDC_DEPRECATE(_strdup)
+    _ACRTIMP char* __cdecl strdup(
+        _In_opt_z_ char const* _String
+        );
+    #pragma pop_macro("strdup")
+
+    // Declarations of functions defined in oldnames.lib:
+    _Check_return_ _CRT_NONSTDC_DEPRECATE(_strcmpi)
+    _ACRTIMP int __cdecl strcmpi(
+        _In_z_ char const* _String1,
+        _In_z_ char const* _String2
+        );
+
+    _Check_return_ _CRT_NONSTDC_DEPRECATE(_stricmp)
+    _ACRTIMP int __cdecl stricmp(
+        _In_z_ char const* _String1,
+        _In_z_ char const* _String2
+        );
+
+    _CRT_NONSTDC_DEPRECATE(_strlwr)
+    _ACRTIMP char* __cdecl strlwr(
+        _Inout_z_ char* _String
+        );
+
+    _Check_return_ _CRT_NONSTDC_DEPRECATE(_strnicmp)
+    _ACRTIMP int __cdecl strnicmp(
+        _In_reads_or_z_(_MaxCount) char const* _String1,
+        _In_reads_or_z_(_MaxCount) char const* _String2,
+        _In_                       size_t      _MaxCount
+        );
+
+    _CRT_NONSTDC_DEPRECATE(_strnset)
+    _ACRTIMP char* __cdecl strnset(
+        _Inout_updates_z_(_MaxCount) char*  _String,
+        _In_                         int    _Value,
+        _In_                         size_t _MaxCount
+        );
+
+    _CRT_NONSTDC_DEPRECATE(_strrev)
+    _ACRTIMP char* __cdecl strrev(
+        _Inout_z_ char* _String
+        );
+
+    _CRT_NONSTDC_DEPRECATE(_strset)
+    char* __cdecl strset(
+        _Inout_z_ char* _String,
+        _In_      int   _Value);
+
+    _CRT_NONSTDC_DEPRECATE(_strupr)
+    _ACRTIMP char* __cdecl strupr(
+        _Inout_z_ char* _String
+        );
+
+#endif // _CRT_INTERNAL_NONSTDC_NAMES
+
+
+
+_CRT_END_C_HEADER
+_UCRT_RESTORE_CLANG_WARNINGS
+#pragma warning(pop) // _UCRT_DISABLED_WARNINGS
+#endif // !__midl
+#endif // _INC_STRING

.ccls-cache/@@home@anon@Documents@Code@minecraftconsoles/@home@anon@msvc@Windows Kits@10@Include@10.0.26100.0@ucrt@sys@types.h

@@ -0,0 +1,51 @@
+//
+// sys/types.h
+//
+//      Copyright (c) Microsoft Corporation. All rights reserved.
+//
+// Types used for returning file status and time information.
+//
+#pragma once
+
+#include <corecrt.h>
+
+#pragma warning(push)
+#pragma warning(disable: _UCRT_DISABLED_WARNINGS)
+_UCRT_DISABLE_CLANG_WARNINGS
+
+#ifndef _INO_T_DEFINED
+    #define _INO_T_DEFINED
+
+    typedef unsigned short _ino_t; // inode number (unused on Windows)
+
+    #if (defined _CRT_DECLARE_NONSTDC_NAMES && _CRT_DECLARE_NONSTDC_NAMES) || (!defined _CRT_DECLARE_NONSTDC_NAMES && !__STDC__)
+        typedef _ino_t ino_t;
+    #endif
+#endif
+
+
+
+#ifndef _DEV_T_DEFINED
+    #define _DEV_T_DEFINED
+
+    typedef unsigned int _dev_t; // device code
+
+    #if (defined _CRT_DECLARE_NONSTDC_NAMES && _CRT_DECLARE_NONSTDC_NAMES) || (!defined _CRT_DECLARE_NONSTDC_NAMES && !__STDC__)
+        typedef _dev_t dev_t;
+    #endif
+#endif
+
+
+
+#ifndef _OFF_T_DEFINED
+    #define _OFF_T_DEFINED
+
+    typedef long _off_t; // file offset value
+
+    #if (defined _CRT_DECLARE_NONSTDC_NAMES && _CRT_DECLARE_NONSTDC_NAMES) || (!defined _CRT_DECLARE_NONSTDC_NAMES && !__STDC__)
+        typedef _off_t off_t;
+    #endif
+#endif
+
+_UCRT_RESTORE_CLANG_WARNINGS
+#pragma warning(pop) // _UCRT_DISABLED_WARNINGS

.ccls-cache/@@home@anon@Documents@Code@minecraftconsoles/@usr@lib@clang@21@include@__stdarg___gnuc_va_list.h

@@ -0,0 +1,13 @@
+/*===---- __stdarg___gnuc_va_list.h - Definition of __gnuc_va_list ---------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __GNUC_VA_LIST
+#define __GNUC_VA_LIST
+typedef __builtin_va_list __gnuc_va_list;
+#endif

.ccls-cache/@@home@anon@Documents@Code@minecraftconsoles/@usr@lib@clang@21@include@__stdarg___va_copy.h

@@ -0,0 +1,12 @@
+/*===---- __stdarg___va_copy.h - Definition of __va_copy -------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __va_copy
+#define __va_copy(d, s) __builtin_va_copy(d, s)
+#endif

.ccls-cache/@@home@anon@Documents@Code@minecraftconsoles/@usr@lib@clang@21@include@__stdarg_header_macro.h

@@ -0,0 +1,12 @@
+/*===---- __stdarg_header_macro.h ------------------------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __STDARG_H
+#define __STDARG_H
+#endif

.ccls-cache/@@home@anon@Documents@Code@minecraftconsoles/@usr@lib@clang@21@include@__stdarg_va_arg.h

@@ -0,0 +1,22 @@
+/*===---- __stdarg_va_arg.h - Definitions of va_start, va_arg, va_end-------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef va_arg
+
+#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L
+/* C23 uses a special builtin. */
+#define va_start(...) __builtin_c23_va_start(__VA_ARGS__)
+#else
+/* Versions before C23 do require the second parameter. */
+#define va_start(ap, param) __builtin_va_start(ap, param)
+#endif
+#define va_end(ap) __builtin_va_end(ap)
+#define va_arg(ap, type) __builtin_va_arg(ap, type)
+
+#endif

.ccls-cache/@@home@anon@Documents@Code@minecraftconsoles/@usr@lib@clang@21@include@__stdarg_va_copy.h

@@ -0,0 +1,12 @@
+/*===---- __stdarg_va_copy.h - Definition of va_copy------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef va_copy
+#define va_copy(dest, src) __builtin_va_copy(dest, src)
+#endif

.ccls-cache/@@home@anon@Documents@Code@minecraftconsoles/@usr@lib@clang@21@include@__stdarg_va_list.h

@@ -0,0 +1,13 @@
+/*===---- __stdarg_va_list.h - Definition of va_list -----------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef _VA_LIST
+#define _VA_LIST
+typedef __builtin_va_list va_list;
+#endif

.ccls-cache/@@home@anon@Documents@Code@minecraftconsoles/@usr@lib@clang@21@include@__stddef_header_macro.h

@@ -0,0 +1,12 @@
+/*===---- __stddef_header_macro.h ------------------------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __STDDEF_H
+#define __STDDEF_H
+#endif

.ccls-cache/@@home@anon@Documents@Code@minecraftconsoles/@usr@lib@clang@21@include@__stddef_max_align_t.h

@@ -0,0 +1,27 @@
+/*===---- __stddef_max_align_t.h - Definition of max_align_t ---------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __CLANG_MAX_ALIGN_T_DEFINED
+#define __CLANG_MAX_ALIGN_T_DEFINED
+
+#if defined(_MSC_VER)
+typedef double max_align_t;
+#elif defined(__APPLE__)
+typedef long double max_align_t;
+#else
+// Define 'max_align_t' to match the GCC definition.
+typedef struct {
+  long long __clang_max_align_nonce1
+      __attribute__((__aligned__(__alignof__(long long))));
+  long double __clang_max_align_nonce2
+      __attribute__((__aligned__(__alignof__(long double))));
+} max_align_t;
+#endif
+
+#endif

.ccls-cache/@@home@anon@Documents@Code@minecraftconsoles/@usr@lib@clang@21@include@__stddef_null.h

@@ -0,0 +1,29 @@
+/*===---- __stddef_null.h - Definition of NULL -----------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#if !defined(NULL) || !__building_module(_Builtin_stddef)
+
+/* linux/stddef.h will define NULL to 0. glibc (and other) headers then define
+ * __need_NULL and rely on stddef.h to redefine NULL to the correct value again.
+ * Modules don't support redefining macros like that, but support that pattern
+ * in the non-modules case.
+ */
+#undef NULL
+
+#ifdef __cplusplus
+#if !defined(__MINGW32__) && !defined(_MSC_VER)
+#define NULL __null
+#else
+#define NULL 0
+#endif
+#else
+#define NULL ((void*)0)
+#endif
+
+#endif

.ccls-cache/@@home@anon@Documents@Code@minecraftconsoles/@usr@lib@clang@21@include@__stddef_offsetof.h

@@ -0,0 +1,17 @@
+/*===---- __stddef_offsetof.h - Definition of offsetof ---------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+/*
+ * When -fbuiltin-headers-in-system-modules is set this is a non-modular header
+ * and needs to behave as if it was textual.
+ */
+#if !defined(offsetof) ||                                                      \
+    (__has_feature(modules) && !__building_module(_Builtin_stddef))
+#define offsetof(t, d) __builtin_offsetof(t, d)
+#endif

.ccls-cache/@@home@anon@Documents@Code@minecraftconsoles/@usr@lib@clang@21@include@__stddef_ptrdiff_t.h

@@ -0,0 +1,20 @@
+/*===---- __stddef_ptrdiff_t.h - Definition of ptrdiff_t -------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+/*
+ * When -fbuiltin-headers-in-system-modules is set this is a non-modular header
+ * and needs to behave as if it was textual.
+ */
+#if !defined(_PTRDIFF_T) ||                                                    \
+    (__has_feature(modules) && !__building_module(_Builtin_stddef))
+#define _PTRDIFF_T
+
+typedef __PTRDIFF_TYPE__ ptrdiff_t;
+
+#endif

.ccls-cache/@@home@anon@Documents@Code@minecraftconsoles/@usr@lib@clang@21@include@__stddef_size_t.h

@@ -0,0 +1,20 @@
+/*===---- __stddef_size_t.h - Definition of size_t -------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+/*
+ * When -fbuiltin-headers-in-system-modules is set this is a non-modular header
+ * and needs to behave as if it was textual.
+ */
+#if !defined(_SIZE_T) ||                                                       \
+    (__has_feature(modules) && !__building_module(_Builtin_stddef))
+#define _SIZE_T
+
+typedef __SIZE_TYPE__ size_t;
+
+#endif

.ccls-cache/@@home@anon@Documents@Code@minecraftconsoles/@usr@lib@clang@21@include@__stddef_wchar_t.h

@@ -0,0 +1,28 @@
+/*===---- __stddef_wchar.h - Definition of wchar_t -------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#if !defined(__cplusplus) || (defined(_MSC_VER) && !_NATIVE_WCHAR_T_DEFINED)
+
+/*
+ * When -fbuiltin-headers-in-system-modules is set this is a non-modular header
+ * and needs to behave as if it was textual.
+ */
+#if !defined(_WCHAR_T) ||                                                      \
+    (__has_feature(modules) && !__building_module(_Builtin_stddef))
+#define _WCHAR_T
+
+#ifdef _MSC_EXTENSIONS
+#define _WCHAR_T_DEFINED
+#endif
+
+typedef __WCHAR_TYPE__ wchar_t;
+
+#endif
+
+#endif

.ccls-cache/@@home@anon@Documents@Code@minecraftconsoles/@usr@lib@clang@21@include@limits.h

@@ -0,0 +1,133 @@
+/*===---- limits.h - Standard header for integer sizes --------------------===*\
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+\*===----------------------------------------------------------------------===*/
+
+#ifndef __CLANG_LIMITS_H
+#define __CLANG_LIMITS_H
+
+#if defined(__MVS__) && __has_include_next(<limits.h>)
+#include_next <limits.h>
+#else
+
+/* The system's limits.h may, in turn, try to #include_next GCC's limits.h.
+   Avert this #include_next madness. */
+#if defined __GNUC__ && !defined _GCC_LIMITS_H_
+#define _GCC_LIMITS_H_
+#endif
+
+/* System headers include a number of constants from POSIX in <limits.h>.
+   Include it if we're hosted. */
+#if __STDC_HOSTED__ && __has_include_next(<limits.h>)
+#include_next <limits.h>
+#endif
+
+/* Many system headers try to "help us out" by defining these.  No really, we
+   know how big each datatype is. */
+#undef  SCHAR_MIN
+#undef  SCHAR_MAX
+#undef  UCHAR_MAX
+#undef  SHRT_MIN
+#undef  SHRT_MAX
+#undef  USHRT_MAX
+#undef  INT_MIN
+#undef  INT_MAX
+#undef  UINT_MAX
+#undef  LONG_MIN
+#undef  LONG_MAX
+#undef  ULONG_MAX
+
+#undef  CHAR_BIT
+#undef  CHAR_MIN
+#undef  CHAR_MAX
+
+/* C90/99 5.2.4.2.1 */
+#define SCHAR_MAX __SCHAR_MAX__
+#define SHRT_MAX  __SHRT_MAX__
+#define INT_MAX   __INT_MAX__
+#define LONG_MAX  __LONG_MAX__
+
+#define SCHAR_MIN (-__SCHAR_MAX__-1)
+#define SHRT_MIN  (-__SHRT_MAX__ -1)
+#define INT_MIN   (-__INT_MAX__  -1)
+#define LONG_MIN  (-__LONG_MAX__ -1L)
+
+#define UCHAR_MAX (__SCHAR_MAX__*2  +1)
+#if __SHRT_WIDTH__ < __INT_WIDTH__
+#define USHRT_MAX (__SHRT_MAX__ * 2 + 1)
+#else
+#define USHRT_MAX (__SHRT_MAX__ * 2U + 1U)
+#endif
+#define UINT_MAX  (__INT_MAX__  *2U +1U)
+#define ULONG_MAX (__LONG_MAX__ *2UL+1UL)
+
+#ifndef MB_LEN_MAX
+#define MB_LEN_MAX 1
+#endif
+
+#define CHAR_BIT  __CHAR_BIT__
+
+/* C23 5.2.4.2.1 */
+#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L
+#define BOOL_WIDTH   __BOOL_WIDTH__
+#define CHAR_WIDTH   CHAR_BIT
+#define SCHAR_WIDTH  CHAR_BIT
+#define UCHAR_WIDTH  CHAR_BIT
+#define USHRT_WIDTH  __SHRT_WIDTH__
+#define SHRT_WIDTH   __SHRT_WIDTH__
+#define UINT_WIDTH   __INT_WIDTH__
+#define INT_WIDTH    __INT_WIDTH__
+#define ULONG_WIDTH  __LONG_WIDTH__
+#define LONG_WIDTH   __LONG_WIDTH__
+#define ULLONG_WIDTH __LLONG_WIDTH__
+#define LLONG_WIDTH  __LLONG_WIDTH__
+
+#define BITINT_MAXWIDTH __BITINT_MAXWIDTH__
+#endif
+
+#ifdef __CHAR_UNSIGNED__  /* -funsigned-char */
+#define CHAR_MIN 0
+#define CHAR_MAX UCHAR_MAX
+#else
+#define CHAR_MIN SCHAR_MIN
+#define CHAR_MAX __SCHAR_MAX__
+#endif
+
+/* C99 5.2.4.2.1: Added long long.
+   C++11 18.3.3.2: same contents as the Standard C Library header <limits.h>.
+ */
+#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) ||              \
+    (defined(__cplusplus) && __cplusplus >= 201103L)
+
+#undef  LLONG_MIN
+#undef  LLONG_MAX
+#undef  ULLONG_MAX
+
+#define LLONG_MAX  __LONG_LONG_MAX__
+#define LLONG_MIN  (-__LONG_LONG_MAX__-1LL)
+#define ULLONG_MAX (__LONG_LONG_MAX__*2ULL+1ULL)
+#endif
+
+/* LONG_LONG_MIN/LONG_LONG_MAX/ULONG_LONG_MAX are a GNU extension. Android's
+   bionic also defines them. It's too bad that we don't have something like
+   #pragma poison that could be used to deprecate a macro - the code should just
+   use LLONG_MAX and friends.
+ */
+#if (defined(__GNU_LIBRARY__) ? defined(__USE_GNU)                             \
+                              : !defined(__STRICT_ANSI__)) ||                  \
+    defined(__BIONIC__)
+
+#undef   LONG_LONG_MIN
+#undef   LONG_LONG_MAX
+#undef   ULONG_LONG_MAX
+
+#define LONG_LONG_MAX  __LONG_LONG_MAX__
+#define LONG_LONG_MIN  (-__LONG_LONG_MAX__-1LL)
+#define ULONG_LONG_MAX (__LONG_LONG_MAX__*2ULL+1ULL)
+#endif
+
+#endif /* __MVS__ */
+#endif /* __CLANG_LIMITS_H */

.ccls-cache/@@home@anon@Documents@Code@minecraftconsoles/@usr@lib@clang@21@include@stdarg.h

@@ -0,0 +1,75 @@
+/*===---- stdarg.h - Variable argument handling ----------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+/*
+ * This header is designed to be included multiple times. If any of the __need_
+ * macros are defined, then only that subset of interfaces are provided. This
+ * can be useful for POSIX headers that need to not expose all of stdarg.h, but
+ * need to use some of its interfaces. Otherwise this header provides all of
+ * the expected interfaces.
+ *
+ * When clang modules are enabled, this header is a textual header to support
+ * the multiple include behavior. As such, it doesn't directly declare anything
+ * so that it doesn't add duplicate declarations to all of its includers'
+ * modules.
+ */
+#if defined(__MVS__) && __has_include_next(<stdarg.h>)
+#undef __need___va_list
+#undef __need_va_list
+#undef __need_va_arg
+#undef __need___va_copy
+#undef __need_va_copy
+#include <__stdarg_header_macro.h>
+#include_next <stdarg.h>
+
+#else
+#if !defined(__need___va_list) && !defined(__need_va_list) &&                  \
+    !defined(__need_va_arg) && !defined(__need___va_copy) &&                   \
+    !defined(__need_va_copy)
+#define __need___va_list
+#define __need_va_list
+#define __need_va_arg
+#define __need___va_copy
+/* GCC always defines __va_copy, but does not define va_copy unless in c99 mode
+ * or -ansi is not specified, since it was not part of C90.
+ */
+#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) ||              \
+    (defined(__cplusplus) && __cplusplus >= 201103L) ||                        \
+    !defined(__STRICT_ANSI__)
+#define __need_va_copy
+#endif
+#include <__stdarg_header_macro.h>
+#endif
+
+#ifdef __need___va_list
+#include <__stdarg___gnuc_va_list.h>
+#undef __need___va_list
+#endif /* defined(__need___va_list) */
+
+#ifdef __need_va_list
+#include <__stdarg_va_list.h>
+#undef __need_va_list
+#endif /* defined(__need_va_list) */
+
+#ifdef __need_va_arg
+#include <__stdarg_va_arg.h>
+#undef __need_va_arg
+#endif /* defined(__need_va_arg) */
+
+#ifdef __need___va_copy
+#include <__stdarg___va_copy.h>
+#undef __need___va_copy
+#endif /* defined(__need___va_copy) */
+
+#ifdef __need_va_copy
+#include <__stdarg_va_copy.h>
+#undef __need_va_copy
+#endif /* defined(__need_va_copy) */
+
+#endif /* __MVS__ */

.ccls-cache/@@home@anon@Documents@Code@minecraftconsoles/@usr@lib@clang@21@include@stddef.h

@@ -0,0 +1,139 @@
+/*===---- stddef.h - Basic type definitions --------------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+/*
+ * This header is designed to be included multiple times. If any of the __need_
+ * macros are defined, then only that subset of interfaces are provided. This
+ * can be useful for POSIX headers that need to not expose all of stddef.h, but
+ * need to use some of its interfaces. Otherwise this header provides all of
+ * the expected interfaces.
+ *
+ * When clang modules are enabled, this header is a textual header to support
+ * the multiple include behavior. As such, it doesn't directly declare anything
+ * so that it doesn't add duplicate declarations to all of its includers'
+ * modules.
+ */
+#if defined(__MVS__) && __has_include_next(<stddef.h>)
+#undef __need_ptrdiff_t
+#undef __need_size_t
+#undef __need_rsize_t
+#undef __need_wchar_t
+#undef __need_NULL
+#undef __need_nullptr_t
+#undef __need_unreachable
+#undef __need_max_align_t
+#undef __need_offsetof
+#undef __need_wint_t
+#include <__stddef_header_macro.h>
+#include_next <stddef.h>
+
+#else
+
+#if !defined(__need_ptrdiff_t) && !defined(__need_size_t) &&                   \
+    !defined(__need_rsize_t) && !defined(__need_wchar_t) &&                    \
+    !defined(__need_NULL) && !defined(__need_nullptr_t) &&                     \
+    !defined(__need_unreachable) && !defined(__need_max_align_t) &&            \
+    !defined(__need_offsetof) && !defined(__need_wint_t)
+#define __need_ptrdiff_t
+#define __need_size_t
+/* ISO9899:2011 7.20 (C11 Annex K): Define rsize_t if __STDC_WANT_LIB_EXT1__ is
+ * enabled. */
+#if defined(__STDC_WANT_LIB_EXT1__) && __STDC_WANT_LIB_EXT1__ >= 1
+#define __need_rsize_t
+#endif
+#define __need_wchar_t
+#if !defined(__STDDEF_H) || __has_feature(modules)
+/*
+ * __stddef_null.h is special when building without modules: if __need_NULL is
+ * set, then it will unconditionally redefine NULL. To avoid stepping on client
+ * definitions of NULL, __need_NULL should only be set the first time this
+ * header is included, that is when __STDDEF_H is not defined. However, when
+ * building with modules, this header is a textual header and needs to
+ * unconditionally include __stdef_null.h to support multiple submodules
+ * exporting _Builtin_stddef.null. Take module SM with submodules A and B, whose
+ * headers both include stddef.h When SM.A builds, __STDDEF_H will be defined.
+ * When SM.B builds, the definition from SM.A will leak when building without
+ * local submodule visibility. stddef.h wouldn't include __stddef_null.h, and
+ * SM.B wouldn't import _Builtin_stddef.null, and SM.B's `export *` wouldn't
+ * export NULL as expected. When building with modules, always include
+ * __stddef_null.h so that everything works as expected.
+ */
+#define __need_NULL
+#endif
+#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L) ||              \
+    defined(__cplusplus)
+#define __need_nullptr_t
+#endif
+#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L
+#define __need_unreachable
+#endif
+#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) ||              \
+    (defined(__cplusplus) && __cplusplus >= 201103L)
+#define __need_max_align_t
+#endif
+#define __need_offsetof
+/* wint_t is provided by <wchar.h> and not <stddef.h>. It's here
+ * for compatibility, but must be explicitly requested. Therefore
+ * __need_wint_t is intentionally not defined here. */
+#include <__stddef_header_macro.h>
+#endif
+
+#if defined(__need_ptrdiff_t)
+#include <__stddef_ptrdiff_t.h>
+#undef __need_ptrdiff_t
+#endif /* defined(__need_ptrdiff_t) */
+
+#if defined(__need_size_t)
+#include <__stddef_size_t.h>
+#undef __need_size_t
+#endif /*defined(__need_size_t) */
+
+#if defined(__need_rsize_t)
+#include <__stddef_rsize_t.h>
+#undef __need_rsize_t
+#endif /* defined(__need_rsize_t) */
+
+#if defined(__need_wchar_t)
+#include <__stddef_wchar_t.h>
+#undef __need_wchar_t
+#endif /* defined(__need_wchar_t) */
+
+#if defined(__need_NULL)
+#include <__stddef_null.h>
+#undef __need_NULL
+#endif /* defined(__need_NULL) */
+
+#if defined(__need_nullptr_t)
+#include <__stddef_nullptr_t.h>
+#undef __need_nullptr_t
+#endif /* defined(__need_nullptr_t) */
+
+#if defined(__need_unreachable)
+#include <__stddef_unreachable.h>
+#undef __need_unreachable
+#endif /* defined(__need_unreachable) */
+
+#if defined(__need_max_align_t)
+#include <__stddef_max_align_t.h>
+#undef __need_max_align_t
+#endif /* defined(__need_max_align_t) */
+
+#if defined(__need_offsetof)
+#include <__stddef_offsetof.h>
+#undef __need_offsetof
+#endif /* defined(__need_offsetof) */
+
+/* Some C libraries expect to see a wint_t here. Others (notably MinGW) will use
+__WINT_TYPE__ directly; accommodate both by requiring __need_wint_t */
+#if defined(__need_wint_t)
+#include <__stddef_wint_t.h>
+#undef __need_wint_t
+#endif /* __need_wint_t */
+
+#endif /* __MVS__ */

.ccls-cache/@@home@anon@Documents@Code@minecraftconsoles/@usr@lib@clang@21@include@vadefs.h

@@ -0,0 +1,51 @@
+/* ===-------- vadefs.h ---------------------------------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+/* Only include this if we are aiming for MSVC compatibility. */
+#ifndef _MSC_VER
+#include_next <vadefs.h>
+#else
+
+#ifndef __clang_vadefs_h
+#define __clang_vadefs_h
+
+#include_next <vadefs.h>
+
+/* Override macros from vadefs.h with definitions that work with Clang. */
+#ifdef _crt_va_start
+#undef _crt_va_start
+#define _crt_va_start(ap, param) __builtin_va_start(ap, param)
+#endif
+#ifdef _crt_va_end
+#undef _crt_va_end
+#define _crt_va_end(ap)          __builtin_va_end(ap)
+#endif
+#ifdef _crt_va_arg
+#undef _crt_va_arg
+#define _crt_va_arg(ap, type)    __builtin_va_arg(ap, type)
+#endif
+
+/* VS 2015 switched to double underscore names, which is an improvement, but now
+ * we have to intercept those names too.
+ */
+#ifdef __crt_va_start
+#undef __crt_va_start
+#define __crt_va_start(ap, param) __builtin_va_start(ap, param)
+#endif
+#ifdef __crt_va_end
+#undef __crt_va_end
+#define __crt_va_end(ap)          __builtin_va_end(ap)
+#endif
+#ifdef __crt_va_arg
+#undef __crt_va_arg
+#define __crt_va_arg(ap, type)    __builtin_va_arg(ap, type)
+#endif
+
+#endif
+#endif

.ccls-cache/@home@anon@Documents@Code@minecraftconsoles/Minecraft.Client@Common@zlib@adler32.c

@@ -0,0 +1,178 @@
+/* adler32.c -- compute the Adler-32 checksum of a data stream
+ * Copyright (C) 1995-2011 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* @(#) $Id$ */
+#include "zutil.h"
+
+#define local static
+
+local uLong adler32_combine_ OF((uLong adler1, uLong adler2, z_off64_t len2));
+
+#define BASE 65521      /* largest prime smaller than 65536 */
+#define NMAX 5552
+/* NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */
+
+#define DO1(buf,i)  {adler += (buf)[i]; sum2 += adler;}
+#define DO2(buf,i)  DO1(buf,i); DO1(buf,i+1);
+#define DO4(buf,i)  DO2(buf,i); DO2(buf,i+2);
+#define DO8(buf,i)  DO4(buf,i); DO4(buf,i+4);
+#define DO16(buf)   DO8(buf,0); DO8(buf,8);
+
+/* use NO_DIVIDE if your processor does not do division in hardware --
+   try it both ways to see which is faster */
+#ifdef NO_DIVIDE
+/* note that this assumes BASE is 65521, where 65536 % 65521 == 15
+   (thank you to John Reiser for pointing this out) */
+#  define CHOP(a) \
+    do { \
+        unsigned long tmp = a >> 16; \
+        a &= 0xffffUL; \
+        a += (tmp << 4) - tmp; \
+    } while (0)
+#  define MOD28(a) \
+    do { \
+        CHOP(a); \
+        if (a >= BASE) a -= BASE; \
+    } while (0)
+#  define MOD(a) \
+    do { \
+        CHOP(a); \
+        MOD28(a); \
+    } while (0)
+#  define MOD63(a) \
+    do { /* this assumes a is not negative */ \
+        z_off64_t tmp = a >> 32; \
+        a &= 0xffffffffL; \
+        a += (tmp << 8) - (tmp << 5) + tmp; \
+        tmp = a >> 16; \
+        a &= 0xffffL; \
+        a += (tmp << 4) - tmp; \
+        tmp = a >> 16; \
+        a &= 0xffffL; \
+        a += (tmp << 4) - tmp; \
+        if (a >= BASE) a -= BASE; \
+    } while (0)
+#else
+#  define MOD(a) a %= BASE
+#  define MOD28(a) a %= BASE
+#  define MOD63(a) a %= BASE
+#endif
+
+/* ========================================================================= */
+uLong ZEXPORT adler32(adler, buf, len)
+    uLong adler;
+    const Bytef *buf;
+    uInt len;
+{
+    unsigned long sum2;
+    unsigned n;
+
+    /* split Adler-32 into component sums */
+    sum2 = (adler >> 16) & 0xffff;
+    adler &= 0xffff;
+
+    /* in case user likes doing a byte at a time, keep it fast */
+    if (len == 1) {
+        adler += buf[0];
+        if (adler >= BASE)
+            adler -= BASE;
+        sum2 += adler;
+        if (sum2 >= BASE)
+            sum2 -= BASE;
+        return adler | (sum2 << 16);
+    }
+
+    /* initial Adler-32 value (deferred check for len == 1 speed) */
+    if (buf == Z_NULL)
+        return 1L;
+
+    /* in case short lengths are provided, keep it somewhat fast */
+    if (len < 16) {
+        while (len--) {
+            adler += *buf++;
+            sum2 += adler;
+        }
+        if (adler >= BASE)
+            adler -= BASE;
+        MOD28(sum2);            /* only added so many BASE's */
+        return adler | (sum2 << 16);
+    }
+
+    /* do length NMAX blocks -- requires just one modulo operation */
+    while (len >= NMAX) {
+        len -= NMAX;
+        n = NMAX / 16;          /* NMAX is divisible by 16 */
+        do {
+            DO16(buf);          /* 16 sums unrolled */
+            buf += 16;
+        } while (--n);
+        MOD(adler);
+        MOD(sum2);
+    }
+
+    /* do remaining bytes (less than NMAX, still just one modulo) */
+    if (len) {                  /* avoid modulos if none remaining */
+        while (len >= 16) {
+            len -= 16;
+            DO16(buf);
+            buf += 16;
+        }
+        while (len--) {
+            adler += *buf++;
+            sum2 += adler;
+        }
+        MOD(adler);
+        MOD(sum2);
+    }
+
+    /* return recombined sums */
+    return adler | (sum2 << 16);
+}
+
+/* ========================================================================= */
+local uLong adler32_combine_(adler1, adler2, len2)
+    uLong adler1;
+    uLong adler2;
+    z_off64_t len2;
+{
+    unsigned long sum1;
+    unsigned long sum2;
+    unsigned rem;
+
+    /* for negative len, return invalid adler32 as a clue for debugging */
+    if (len2 < 0)
+        return 0xffffffffUL;
+
+    /* the derivation of this formula is left as an exercise for the reader */
+    MOD63(len2);                /* assumes len2 >= 0 */
+    rem = (unsigned)len2;
+    sum1 = adler1 & 0xffff;
+    sum2 = rem * sum1;
+    MOD(sum2);
+    sum1 += (adler2 & 0xffff) + BASE - 1;
+    sum2 += ((adler1 >> 16) & 0xffff) + ((adler2 >> 16) & 0xffff) + BASE - rem;
+    if (sum1 >= BASE) sum1 -= BASE;
+    if (sum1 >= BASE) sum1 -= BASE;
+    if (sum2 >= (BASE << 1)) sum2 -= (BASE << 1);
+    if (sum2 >= BASE) sum2 -= BASE;
+    return sum1 | (sum2 << 16);
+}
+
+/* ========================================================================= */
+uLong ZEXPORT adler32_combine(adler1, adler2, len2)
+    uLong adler1;
+    uLong adler2;
+    z_off_t len2;
+{
+    return adler32_combine_(adler1, adler2, len2);
+}
+
+uLong ZEXPORT adler32_combine64(adler1, adler2, len2)
+    uLong adler1;
+    uLong adler2;
+    z_off64_t len2;
+{
+    return adler32_combine_(adler1, adler2, len2);
+}

.ccls-cache/@home@anon@Documents@Code@minecraftconsoles/Minecraft.Client@Common@zlib@compress.c

@@ -0,0 +1,81 @@
+/* compress.c -- compress a memory buffer
+ * Copyright (C) 1995-2005 Jean-loup Gailly.
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* @(#) $Id$ */
+
+#define ZLIB_INTERNAL
+#include "zlib.h"
+
+/* ===========================================================================
+     Compresses the source buffer into the destination buffer. The level
+   parameter has the same meaning as in deflateInit.  sourceLen is the byte
+   length of the source buffer. Upon entry, destLen is the total size of the
+   destination buffer, which must be at least 0.1% larger than sourceLen plus
+   12 bytes. Upon exit, destLen is the actual size of the compressed buffer.
+
+     compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_BUF_ERROR if there was not enough room in the output buffer,
+   Z_STREAM_ERROR if the level parameter is invalid.
+*/
+int ZEXPORT compress2 (dest, destLen, source, sourceLen, level)
+    Bytef *dest;
+    uLongf *destLen;
+    const Bytef *source;
+    uLong sourceLen;
+    int level;
+{
+    z_stream stream;
+    int err;
+
+    stream.next_in = (z_const Bytef *)source;
+    stream.avail_in = (uInt)sourceLen;
+#ifdef MAXSEG_64K
+    /* Check for source > 64K on 16-bit machine: */
+    if ((uLong)stream.avail_in != sourceLen) return Z_BUF_ERROR;
+#endif
+    stream.next_out = dest;
+    stream.avail_out = (uInt)*destLen;
+    if ((uLong)stream.avail_out != *destLen) return Z_BUF_ERROR;
+
+    stream.zalloc = (alloc_func)0;
+    stream.zfree = (free_func)0;
+    stream.opaque = (voidpf)0;
+
+    err = deflateInit(&stream, level);
+    if (err != Z_OK) return err;
+
+    err = deflate(&stream, Z_FINISH);
+    if (err != Z_STREAM_END) {
+        deflateEnd(&stream);
+        return err == Z_OK ? Z_BUF_ERROR : err;
+    }
+    *destLen = stream.total_out;
+
+    err = deflateEnd(&stream);
+    return err;
+}
+
+/* ===========================================================================
+ */
+int ZEXPORT compress (dest, destLen, source, sourceLen)
+    Bytef *dest;
+    uLongf *destLen;
+    const Bytef *source;
+    uLong sourceLen;
+{
+    return compress2(dest, destLen, source, sourceLen, Z_DEFAULT_COMPRESSION);
+}
+
+
+/* ===========================================================================
+     If the default memLevel or windowBits for deflateInit() is changed, then
+   this function needs to be updated.
+ */
+uLong ZEXPORT compressBound (sourceLen)
+    uLong sourceLen;
+{
+    return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) +
+           (sourceLen >> 25) + 13;
+}

.ccls-cache/@home@anon@Documents@Code@minecraftconsoles/Minecraft.Client@Common@zlib@crc32.c

@@ -0,0 +1,425 @@
+/* crc32.c -- compute the CRC-32 of a data stream
+ * Copyright (C) 1995-2006, 2010, 2011, 2012 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ *
+ * Thanks to Rodney Brown <rbrown64@csc.com.au> for his contribution of faster
+ * CRC methods: exclusive-oring 32 bits of data at a time, and pre-computing
+ * tables for updating the shift register in one step with three exclusive-ors
+ * instead of four steps with four exclusive-ors.  This results in about a
+ * factor of two increase in speed on a Power PC G4 (PPC7455) using gcc -O3.
+ */
+
+/* @(#) $Id$ */
+
+/*
+  Note on the use of DYNAMIC_CRC_TABLE: there is no mutex or semaphore
+  protection on the static variables used to control the first-use generation
+  of the crc tables.  Therefore, if you #define DYNAMIC_CRC_TABLE, you should
+  first call get_crc_table() to initialize the tables before allowing more than
+  one thread to use crc32().
+
+  DYNAMIC_CRC_TABLE and MAKECRCH can be #defined to write out crc32.h.
+ */
+
+#ifdef MAKECRCH
+#  include <stdio.h>
+#  ifndef DYNAMIC_CRC_TABLE
+#    define DYNAMIC_CRC_TABLE
+#  endif /* !DYNAMIC_CRC_TABLE */
+#endif /* MAKECRCH */
+
+#include "zutil.h"      /* for STDC and FAR definitions */
+
+#define local static
+
+/* Definitions for doing the crc four data bytes at a time. */
+#if !defined(NOBYFOUR) && defined(Z_U4)
+#  define BYFOUR
+#endif
+#ifdef BYFOUR
+   local unsigned long crc32_little OF((unsigned long,
+                        const unsigned char FAR *, unsigned));
+   local unsigned long crc32_big OF((unsigned long,
+                        const unsigned char FAR *, unsigned));
+#  define TBLS 8
+#else
+#  define TBLS 1
+#endif /* BYFOUR */
+
+/* Local functions for crc concatenation */
+local unsigned long gf2_matrix_times OF((unsigned long *mat,
+                                         unsigned long vec));
+local void gf2_matrix_square OF((unsigned long *square, unsigned long *mat));
+local uLong crc32_combine_ OF((uLong crc1, uLong crc2, z_off64_t len2));
+
+
+#ifdef DYNAMIC_CRC_TABLE
+
+local volatile int crc_table_empty = 1;
+local z_crc_t FAR crc_table[TBLS][256];
+local void make_crc_table OF((void));
+#ifdef MAKECRCH
+   local void write_table OF((FILE *, const z_crc_t FAR *));
+#endif /* MAKECRCH */
+/*
+  Generate tables for a byte-wise 32-bit CRC calculation on the polynomial:
+  x^32+x^26+x^23+x^22+x^16+x^12+x^11+x^10+x^8+x^7+x^5+x^4+x^2+x+1.
+
+  Polynomials over GF(2) are represented in binary, one bit per coefficient,
+  with the lowest powers in the most significant bit.  Then adding polynomials
+  is just exclusive-or, and multiplying a polynomial by x is a right shift by
+  one.  If we call the above polynomial p, and represent a byte as the
+  polynomial q, also with the lowest power in the most significant bit (so the
+  byte 0xb1 is the polynomial x^7+x^3+x+1), then the CRC is (q*x^32) mod p,
+  where a mod b means the remainder after dividing a by b.
+
+  This calculation is done using the shift-register method of multiplying and
+  taking the remainder.  The register is initialized to zero, and for each
+  incoming bit, x^32 is added mod p to the register if the bit is a one (where
+  x^32 mod p is p+x^32 = x^26+...+1), and the register is multiplied mod p by
+  x (which is shifting right by one and adding x^32 mod p if the bit shifted
+  out is a one).  We start with the highest power (least significant bit) of
+  q and repeat for all eight bits of q.
+
+  The first table is simply the CRC of all possible eight bit values.  This is
+  all the information needed to generate CRCs on data a byte at a time for all
+  combinations of CRC register values and incoming bytes.  The remaining tables
+  allow for word-at-a-time CRC calculation for both big-endian and little-
+  endian machines, where a word is four bytes.
+*/
+local void make_crc_table()
+{
+    z_crc_t c;
+    int n, k;
+    z_crc_t poly;                       /* polynomial exclusive-or pattern */
+    /* terms of polynomial defining this crc (except x^32): */
+    static volatile int first = 1;      /* flag to limit concurrent making */
+    static const unsigned char p[] = {0,1,2,4,5,7,8,10,11,12,16,22,23,26};
+
+    /* See if another task is already doing this (not thread-safe, but better
+       than nothing -- significantly reduces duration of vulnerability in
+       case the advice about DYNAMIC_CRC_TABLE is ignored) */
+    if (first) {
+        first = 0;
+
+        /* make exclusive-or pattern from polynomial (0xedb88320UL) */
+        poly = 0;
+        for (n = 0; n < (int)(sizeof(p)/sizeof(unsigned char)); n++)
+            poly |= (z_crc_t)1 << (31 - p[n]);
+
+        /* generate a crc for every 8-bit value */
+        for (n = 0; n < 256; n++) {
+            c = (z_crc_t)n;
+            for (k = 0; k < 8; k++)
+                c = c & 1 ? poly ^ (c >> 1) : c >> 1;
+            crc_table[0][n] = c;
+        }
+
+#ifdef BYFOUR
+        /* generate crc for each value followed by one, two, and three zeros,
+           and then the byte reversal of those as well as the first table */
+        for (n = 0; n < 256; n++) {
+            c = crc_table[0][n];
+            crc_table[4][n] = ZSWAP32(c);
+            for (k = 1; k < 4; k++) {
+                c = crc_table[0][c & 0xff] ^ (c >> 8);
+                crc_table[k][n] = c;
+                crc_table[k + 4][n] = ZSWAP32(c);
+            }
+        }
+#endif /* BYFOUR */
+
+        crc_table_empty = 0;
+    }
+    else {      /* not first */
+        /* wait for the other guy to finish (not efficient, but rare) */
+        while (crc_table_empty)
+            ;
+    }
+
+#ifdef MAKECRCH
+    /* write out CRC tables to crc32.h */
+    {
+        FILE *out;
+
+        out = fopen("crc32.h", "w");
+        if (out == NULL) return;
+        fprintf(out, "/* crc32.h -- tables for rapid CRC calculation\n");
+        fprintf(out, " * Generated automatically by crc32.c\n */\n\n");
+        fprintf(out, "local const z_crc_t FAR ");
+        fprintf(out, "crc_table[TBLS][256] =\n{\n  {\n");
+        write_table(out, crc_table[0]);
+#  ifdef BYFOUR
+        fprintf(out, "#ifdef BYFOUR\n");
+        for (k = 1; k < 8; k++) {
+            fprintf(out, "  },\n  {\n");
+            write_table(out, crc_table[k]);
+        }
+        fprintf(out, "#endif\n");
+#  endif /* BYFOUR */
+        fprintf(out, "  }\n};\n");
+        fclose(out);
+    }
+#endif /* MAKECRCH */
+}
+
+#ifdef MAKECRCH
+local void write_table(out, table)
+    FILE *out;
+    const z_crc_t FAR *table;
+{
+    int n;
+
+    for (n = 0; n < 256; n++)
+        fprintf(out, "%s0x%08lxUL%s", n % 5 ? "" : "    ",
+                (unsigned long)(table[n]),
+                n == 255 ? "\n" : (n % 5 == 4 ? ",\n" : ", "));
+}
+#endif /* MAKECRCH */
+
+#else /* !DYNAMIC_CRC_TABLE */
+/* ========================================================================
+ * Tables of CRC-32s of all single-byte values, made by make_crc_table().
+ */
+#include "crc32.h"
+#endif /* DYNAMIC_CRC_TABLE */
+
+/* =========================================================================
+ * This function can be used by asm versions of crc32()
+ */
+const z_crc_t FAR * ZEXPORT get_crc_table()
+{
+#ifdef DYNAMIC_CRC_TABLE
+    if (crc_table_empty)
+        make_crc_table();
+#endif /* DYNAMIC_CRC_TABLE */
+    return (const z_crc_t FAR *)crc_table;
+}
+
+/* ========================================================================= */
+#define DO1 crc = crc_table[0][((int)crc ^ (*buf++)) & 0xff] ^ (crc >> 8)
+#define DO8 DO1; DO1; DO1; DO1; DO1; DO1; DO1; DO1
+
+/* ========================================================================= */
+unsigned long ZEXPORT crc32(crc, buf, len)
+    unsigned long crc;
+    const unsigned char FAR *buf;
+    uInt len;
+{
+    if (buf == Z_NULL) return 0UL;
+
+#ifdef DYNAMIC_CRC_TABLE
+    if (crc_table_empty)
+        make_crc_table();
+#endif /* DYNAMIC_CRC_TABLE */
+
+#ifdef BYFOUR
+    if (sizeof(void *) == sizeof(ptrdiff_t)) {
+        z_crc_t endian;
+
+        endian = 1;
+        if (*((unsigned char *)(&endian)))
+            return crc32_little(crc, buf, len);
+        else
+            return crc32_big(crc, buf, len);
+    }
+#endif /* BYFOUR */
+    crc = crc ^ 0xffffffffUL;
+    while (len >= 8) {
+        DO8;
+        len -= 8;
+    }
+    if (len) do {
+        DO1;
+    } while (--len);
+    return crc ^ 0xffffffffUL;
+}
+
+#ifdef BYFOUR
+
+/* ========================================================================= */
+#define DOLIT4 c ^= *buf4++; \
+        c = crc_table[3][c & 0xff] ^ crc_table[2][(c >> 8) & 0xff] ^ \
+            crc_table[1][(c >> 16) & 0xff] ^ crc_table[0][c >> 24]
+#define DOLIT32 DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4
+
+/* ========================================================================= */
+local unsigned long crc32_little(crc, buf, len)
+    unsigned long crc;
+    const unsigned char FAR *buf;
+    unsigned len;
+{
+    register z_crc_t c;
+    register const z_crc_t FAR *buf4;
+
+    c = (z_crc_t)crc;
+    c = ~c;
+    while (len && ((ptrdiff_t)buf & 3)) {
+        c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8);
+        len--;
+    }
+
+    buf4 = (const z_crc_t FAR *)(const void FAR *)buf;
+    while (len >= 32) {
+        DOLIT32;
+        len -= 32;
+    }
+    while (len >= 4) {
+        DOLIT4;
+        len -= 4;
+    }
+    buf = (const unsigned char FAR *)buf4;
+
+    if (len) do {
+        c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8);
+    } while (--len);
+    c = ~c;
+    return (unsigned long)c;
+}
+
+/* ========================================================================= */
+#define DOBIG4 c ^= *++buf4; \
+        c = crc_table[4][c & 0xff] ^ crc_table[5][(c >> 8) & 0xff] ^ \
+            crc_table[6][(c >> 16) & 0xff] ^ crc_table[7][c >> 24]
+#define DOBIG32 DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4
+
+/* ========================================================================= */
+local unsigned long crc32_big(crc, buf, len)
+    unsigned long crc;
+    const unsigned char FAR *buf;
+    unsigned len;
+{
+    register z_crc_t c;
+    register const z_crc_t FAR *buf4;
+
+    c = ZSWAP32((z_crc_t)crc);
+    c = ~c;
+    while (len && ((ptrdiff_t)buf & 3)) {
+        c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8);
+        len--;
+    }
+
+    buf4 = (const z_crc_t FAR *)(const void FAR *)buf;
+    buf4--;
+    while (len >= 32) {
+        DOBIG32;
+        len -= 32;
+    }
+    while (len >= 4) {
+        DOBIG4;
+        len -= 4;
+    }
+    buf4++;
+    buf = (const unsigned char FAR *)buf4;
+
+    if (len) do {
+        c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8);
+    } while (--len);
+    c = ~c;
+    return (unsigned long)(ZSWAP32(c));
+}
+
+#endif /* BYFOUR */
+
+#define GF2_DIM 32      /* dimension of GF(2) vectors (length of CRC) */
+
+/* ========================================================================= */
+local unsigned long gf2_matrix_times(mat, vec)
+    unsigned long *mat;
+    unsigned long vec;
+{
+    unsigned long sum;
+
+    sum = 0;
+    while (vec) {
+        if (vec & 1)
+            sum ^= *mat;
+        vec >>= 1;
+        mat++;
+    }
+    return sum;
+}
+
+/* ========================================================================= */
+local void gf2_matrix_square(square, mat)
+    unsigned long *square;
+    unsigned long *mat;
+{
+    int n;
+
+    for (n = 0; n < GF2_DIM; n++)
+        square[n] = gf2_matrix_times(mat, mat[n]);
+}
+
+/* ========================================================================= */
+local uLong crc32_combine_(crc1, crc2, len2)
+    uLong crc1;
+    uLong crc2;
+    z_off64_t len2;
+{
+    int n;
+    unsigned long row;
+    unsigned long even[GF2_DIM];    /* even-power-of-two zeros operator */
+    unsigned long odd[GF2_DIM];     /* odd-power-of-two zeros operator */
+
+    /* degenerate case (also disallow negative lengths) */
+    if (len2 <= 0)
+        return crc1;
+
+    /* put operator for one zero bit in odd */
+    odd[0] = 0xedb88320UL;          /* CRC-32 polynomial */
+    row = 1;
+    for (n = 1; n < GF2_DIM; n++) {
+        odd[n] = row;
+        row <<= 1;
+    }
+
+    /* put operator for two zero bits in even */
+    gf2_matrix_square(even, odd);
+
+    /* put operator for four zero bits in odd */
+    gf2_matrix_square(odd, even);
+
+    /* apply len2 zeros to crc1 (first square will put the operator for one
+       zero byte, eight zero bits, in even) */
+    do {
+        /* apply zeros operator for this bit of len2 */
+        gf2_matrix_square(even, odd);
+        if (len2 & 1)
+            crc1 = gf2_matrix_times(even, crc1);
+        len2 >>= 1;
+
+        /* if no more bits set, then done */
+        if (len2 == 0)
+            break;
+
+        /* another iteration of the loop with odd and even swapped */
+        gf2_matrix_square(odd, even);
+        if (len2 & 1)
+            crc1 = gf2_matrix_times(odd, crc1);
+        len2 >>= 1;
+
+        /* if no more bits set, then done */
+    } while (len2 != 0);
+
+    /* return combined crc */
+    crc1 ^= crc2;
+    return crc1;
+}
+
+/* ========================================================================= */
+uLong ZEXPORT crc32_combine(crc1, crc2, len2)
+    uLong crc1;
+    uLong crc2;
+    z_off_t len2;
+{
+    return crc32_combine_(crc1, crc2, len2);
+}
+
+uLong ZEXPORT crc32_combine64(crc1, crc2, len2)
+    uLong crc1;
+    uLong crc2;
+    z_off64_t len2;
+{
+    return crc32_combine_(crc1, crc2, len2);
+}

.ccls-cache/@home@anon@Documents@Code@minecraftconsoles/Minecraft.Client@Common@zlib@crc32.h

@@ -0,0 +1,441 @@
+/* crc32.h -- tables for rapid CRC calculation
+ * Generated automatically by crc32.c
+ */
+
+local const z_crc_t FAR crc_table[TBLS][256] =
+{
+  {
+    0x00000000UL, 0x77073096UL, 0xee0e612cUL, 0x990951baUL, 0x076dc419UL,
+    0x706af48fUL, 0xe963a535UL, 0x9e6495a3UL, 0x0edb8832UL, 0x79dcb8a4UL,
+    0xe0d5e91eUL, 0x97d2d988UL, 0x09b64c2bUL, 0x7eb17cbdUL, 0xe7b82d07UL,
+    0x90bf1d91UL, 0x1db71064UL, 0x6ab020f2UL, 0xf3b97148UL, 0x84be41deUL,
+    0x1adad47dUL, 0x6ddde4ebUL, 0xf4d4b551UL, 0x83d385c7UL, 0x136c9856UL,
+    0x646ba8c0UL, 0xfd62f97aUL, 0x8a65c9ecUL, 0x14015c4fUL, 0x63066cd9UL,
+    0xfa0f3d63UL, 0x8d080df5UL, 0x3b6e20c8UL, 0x4c69105eUL, 0xd56041e4UL,
+    0xa2677172UL, 0x3c03e4d1UL, 0x4b04d447UL, 0xd20d85fdUL, 0xa50ab56bUL,
+    0x35b5a8faUL, 0x42b2986cUL, 0xdbbbc9d6UL, 0xacbcf940UL, 0x32d86ce3UL,
+    0x45df5c75UL, 0xdcd60dcfUL, 0xabd13d59UL, 0x26d930acUL, 0x51de003aUL,
+    0xc8d75180UL, 0xbfd06116UL, 0x21b4f4b5UL, 0x56b3c423UL, 0xcfba9599UL,
+    0xb8bda50fUL, 0x2802b89eUL, 0x5f058808UL, 0xc60cd9b2UL, 0xb10be924UL,
+    0x2f6f7c87UL, 0x58684c11UL, 0xc1611dabUL, 0xb6662d3dUL, 0x76dc4190UL,
+    0x01db7106UL, 0x98d220bcUL, 0xefd5102aUL, 0x71b18589UL, 0x06b6b51fUL,
+    0x9fbfe4a5UL, 0xe8b8d433UL, 0x7807c9a2UL, 0x0f00f934UL, 0x9609a88eUL,
+    0xe10e9818UL, 0x7f6a0dbbUL, 0x086d3d2dUL, 0x91646c97UL, 0xe6635c01UL,
+    0x6b6b51f4UL, 0x1c6c6162UL, 0x856530d8UL, 0xf262004eUL, 0x6c0695edUL,
+    0x1b01a57bUL, 0x8208f4c1UL, 0xf50fc457UL, 0x65b0d9c6UL, 0x12b7e950UL,
+    0x8bbeb8eaUL, 0xfcb9887cUL, 0x62dd1ddfUL, 0x15da2d49UL, 0x8cd37cf3UL,
+    0xfbd44c65UL, 0x4db26158UL, 0x3ab551ceUL, 0xa3bc0074UL, 0xd4bb30e2UL,
+    0x4adfa541UL, 0x3dd895d7UL, 0xa4d1c46dUL, 0xd3d6f4fbUL, 0x4369e96aUL,
+    0x346ed9fcUL, 0xad678846UL, 0xda60b8d0UL, 0x44042d73UL, 0x33031de5UL,
+    0xaa0a4c5fUL, 0xdd0d7cc9UL, 0x5005713cUL, 0x270241aaUL, 0xbe0b1010UL,
+    0xc90c2086UL, 0x5768b525UL, 0x206f85b3UL, 0xb966d409UL, 0xce61e49fUL,
+    0x5edef90eUL, 0x29d9c998UL, 0xb0d09822UL, 0xc7d7a8b4UL, 0x59b33d17UL,
+    0x2eb40d81UL, 0xb7bd5c3bUL, 0xc0ba6cadUL, 0xedb88320UL, 0x9abfb3b6UL,
+    0x03b6e20cUL, 0x74b1d29aUL, 0xead54739UL, 0x9dd277afUL, 0x04db2615UL,
+    0x73dc1683UL, 0xe3630b12UL, 0x94643b84UL, 0x0d6d6a3eUL, 0x7a6a5aa8UL,
+    0xe40ecf0bUL, 0x9309ff9dUL, 0x0a00ae27UL, 0x7d079eb1UL, 0xf00f9344UL,
+    0x8708a3d2UL, 0x1e01f268UL, 0x6906c2feUL, 0xf762575dUL, 0x806567cbUL,
+    0x196c3671UL, 0x6e6b06e7UL, 0xfed41b76UL, 0x89d32be0UL, 0x10da7a5aUL,
+    0x67dd4accUL, 0xf9b9df6fUL, 0x8ebeeff9UL, 0x17b7be43UL, 0x60b08ed5UL,
+    0xd6d6a3e8UL, 0xa1d1937eUL, 0x38d8c2c4UL, 0x4fdff252UL, 0xd1bb67f1UL,
+    0xa6bc5767UL, 0x3fb506ddUL, 0x48b2364bUL, 0xd80d2bdaUL, 0xaf0a1b4cUL,
+    0x36034af6UL, 0x41047a60UL, 0xdf60efc3UL, 0xa867df55UL, 0x316e8eefUL,
+    0x4669be79UL, 0xcb61b38cUL, 0xbc66831aUL, 0x256fd2a0UL, 0x5268e236UL,
+    0xcc0c7795UL, 0xbb0b4703UL, 0x220216b9UL, 0x5505262fUL, 0xc5ba3bbeUL,
+    0xb2bd0b28UL, 0x2bb45a92UL, 0x5cb36a04UL, 0xc2d7ffa7UL, 0xb5d0cf31UL,
+    0x2cd99e8bUL, 0x5bdeae1dUL, 0x9b64c2b0UL, 0xec63f226UL, 0x756aa39cUL,
+    0x026d930aUL, 0x9c0906a9UL, 0xeb0e363fUL, 0x72076785UL, 0x05005713UL,
+    0x95bf4a82UL, 0xe2b87a14UL, 0x7bb12baeUL, 0x0cb61b38UL, 0x92d28e9bUL,
+    0xe5d5be0dUL, 0x7cdcefb7UL, 0x0bdbdf21UL, 0x86d3d2d4UL, 0xf1d4e242UL,
+    0x68ddb3f8UL, 0x1fda836eUL, 0x81be16cdUL, 0xf6b9265bUL, 0x6fb077e1UL,
+    0x18b74777UL, 0x88085ae6UL, 0xff0f6a70UL, 0x66063bcaUL, 0x11010b5cUL,
+    0x8f659effUL, 0xf862ae69UL, 0x616bffd3UL, 0x166ccf45UL, 0xa00ae278UL,
+    0xd70dd2eeUL, 0x4e048354UL, 0x3903b3c2UL, 0xa7672661UL, 0xd06016f7UL,
+    0x4969474dUL, 0x3e6e77dbUL, 0xaed16a4aUL, 0xd9d65adcUL, 0x40df0b66UL,
+    0x37d83bf0UL, 0xa9bcae53UL, 0xdebb9ec5UL, 0x47b2cf7fUL, 0x30b5ffe9UL,
+    0xbdbdf21cUL, 0xcabac28aUL, 0x53b39330UL, 0x24b4a3a6UL, 0xbad03605UL,
+    0xcdd70693UL, 0x54de5729UL, 0x23d967bfUL, 0xb3667a2eUL, 0xc4614ab8UL,
+    0x5d681b02UL, 0x2a6f2b94UL, 0xb40bbe37UL, 0xc30c8ea1UL, 0x5a05df1bUL,
+    0x2d02ef8dUL
+#ifdef BYFOUR
+  },
+  {
+    0x00000000UL, 0x191b3141UL, 0x32366282UL, 0x2b2d53c3UL, 0x646cc504UL,
+    0x7d77f445UL, 0x565aa786UL, 0x4f4196c7UL, 0xc8d98a08UL, 0xd1c2bb49UL,
+    0xfaefe88aUL, 0xe3f4d9cbUL, 0xacb54f0cUL, 0xb5ae7e4dUL, 0x9e832d8eUL,
+    0x87981ccfUL, 0x4ac21251UL, 0x53d92310UL, 0x78f470d3UL, 0x61ef4192UL,
+    0x2eaed755UL, 0x37b5e614UL, 0x1c98b5d7UL, 0x05838496UL, 0x821b9859UL,
+    0x9b00a918UL, 0xb02dfadbUL, 0xa936cb9aUL, 0xe6775d5dUL, 0xff6c6c1cUL,
+    0xd4413fdfUL, 0xcd5a0e9eUL, 0x958424a2UL, 0x8c9f15e3UL, 0xa7b24620UL,
+    0xbea97761UL, 0xf1e8e1a6UL, 0xe8f3d0e7UL, 0xc3de8324UL, 0xdac5b265UL,
+    0x5d5daeaaUL, 0x44469febUL, 0x6f6bcc28UL, 0x7670fd69UL, 0x39316baeUL,
+    0x202a5aefUL, 0x0b07092cUL, 0x121c386dUL, 0xdf4636f3UL, 0xc65d07b2UL,
+    0xed705471UL, 0xf46b6530UL, 0xbb2af3f7UL, 0xa231c2b6UL, 0x891c9175UL,
+    0x9007a034UL, 0x179fbcfbUL, 0x0e848dbaUL, 0x25a9de79UL, 0x3cb2ef38UL,
+    0x73f379ffUL, 0x6ae848beUL, 0x41c51b7dUL, 0x58de2a3cUL, 0xf0794f05UL,
+    0xe9627e44UL, 0xc24f2d87UL, 0xdb541cc6UL, 0x94158a01UL, 0x8d0ebb40UL,
+    0xa623e883UL, 0xbf38d9c2UL, 0x38a0c50dUL, 0x21bbf44cUL, 0x0a96a78fUL,
+    0x138d96ceUL, 0x5ccc0009UL, 0x45d73148UL, 0x6efa628bUL, 0x77e153caUL,
+    0xbabb5d54UL, 0xa3a06c15UL, 0x888d3fd6UL, 0x91960e97UL, 0xded79850UL,
+    0xc7cca911UL, 0xece1fad2UL, 0xf5facb93UL, 0x7262d75cUL, 0x6b79e61dUL,
+    0x4054b5deUL, 0x594f849fUL, 0x160e1258UL, 0x0f152319UL, 0x243870daUL,
+    0x3d23419bUL, 0x65fd6ba7UL, 0x7ce65ae6UL, 0x57cb0925UL, 0x4ed03864UL,
+    0x0191aea3UL, 0x188a9fe2UL, 0x33a7cc21UL, 0x2abcfd60UL, 0xad24e1afUL,
+    0xb43fd0eeUL, 0x9f12832dUL, 0x8609b26cUL, 0xc94824abUL, 0xd05315eaUL,
+    0xfb7e4629UL, 0xe2657768UL, 0x2f3f79f6UL, 0x362448b7UL, 0x1d091b74UL,
+    0x04122a35UL, 0x4b53bcf2UL, 0x52488db3UL, 0x7965de70UL, 0x607eef31UL,
+    0xe7e6f3feUL, 0xfefdc2bfUL, 0xd5d0917cUL, 0xcccba03dUL, 0x838a36faUL,
+    0x9a9107bbUL, 0xb1bc5478UL, 0xa8a76539UL, 0x3b83984bUL, 0x2298a90aUL,
+    0x09b5fac9UL, 0x10aecb88UL, 0x5fef5d4fUL, 0x46f46c0eUL, 0x6dd93fcdUL,
+    0x74c20e8cUL, 0xf35a1243UL, 0xea412302UL, 0xc16c70c1UL, 0xd8774180UL,
+    0x9736d747UL, 0x8e2de606UL, 0xa500b5c5UL, 0xbc1b8484UL, 0x71418a1aUL,
+    0x685abb5bUL, 0x4377e898UL, 0x5a6cd9d9UL, 0x152d4f1eUL, 0x0c367e5fUL,
+    0x271b2d9cUL, 0x3e001cddUL, 0xb9980012UL, 0xa0833153UL, 0x8bae6290UL,
+    0x92b553d1UL, 0xddf4c516UL, 0xc4eff457UL, 0xefc2a794UL, 0xf6d996d5UL,
+    0xae07bce9UL, 0xb71c8da8UL, 0x9c31de6bUL, 0x852aef2aUL, 0xca6b79edUL,
+    0xd37048acUL, 0xf85d1b6fUL, 0xe1462a2eUL, 0x66de36e1UL, 0x7fc507a0UL,
+    0x54e85463UL, 0x4df36522UL, 0x02b2f3e5UL, 0x1ba9c2a4UL, 0x30849167UL,
+    0x299fa026UL, 0xe4c5aeb8UL, 0xfdde9ff9UL, 0xd6f3cc3aUL, 0xcfe8fd7bUL,
+    0x80a96bbcUL, 0x99b25afdUL, 0xb29f093eUL, 0xab84387fUL, 0x2c1c24b0UL,
+    0x350715f1UL, 0x1e2a4632UL, 0x07317773UL, 0x4870e1b4UL, 0x516bd0f5UL,
+    0x7a468336UL, 0x635db277UL, 0xcbfad74eUL, 0xd2e1e60fUL, 0xf9ccb5ccUL,
+    0xe0d7848dUL, 0xaf96124aUL, 0xb68d230bUL, 0x9da070c8UL, 0x84bb4189UL,
+    0x03235d46UL, 0x1a386c07UL, 0x31153fc4UL, 0x280e0e85UL, 0x674f9842UL,
+    0x7e54a903UL, 0x5579fac0UL, 0x4c62cb81UL, 0x8138c51fUL, 0x9823f45eUL,
+    0xb30ea79dUL, 0xaa1596dcUL, 0xe554001bUL, 0xfc4f315aUL, 0xd7626299UL,
+    0xce7953d8UL, 0x49e14f17UL, 0x50fa7e56UL, 0x7bd72d95UL, 0x62cc1cd4UL,
+    0x2d8d8a13UL, 0x3496bb52UL, 0x1fbbe891UL, 0x06a0d9d0UL, 0x5e7ef3ecUL,
+    0x4765c2adUL, 0x6c48916eUL, 0x7553a02fUL, 0x3a1236e8UL, 0x230907a9UL,
+    0x0824546aUL, 0x113f652bUL, 0x96a779e4UL, 0x8fbc48a5UL, 0xa4911b66UL,
+    0xbd8a2a27UL, 0xf2cbbce0UL, 0xebd08da1UL, 0xc0fdde62UL, 0xd9e6ef23UL,
+    0x14bce1bdUL, 0x0da7d0fcUL, 0x268a833fUL, 0x3f91b27eUL, 0x70d024b9UL,
+    0x69cb15f8UL, 0x42e6463bUL, 0x5bfd777aUL, 0xdc656bb5UL, 0xc57e5af4UL,
+    0xee530937UL, 0xf7483876UL, 0xb809aeb1UL, 0xa1129ff0UL, 0x8a3fcc33UL,
+    0x9324fd72UL
+  },
+  {
+    0x00000000UL, 0x01c26a37UL, 0x0384d46eUL, 0x0246be59UL, 0x0709a8dcUL,
+    0x06cbc2ebUL, 0x048d7cb2UL, 0x054f1685UL, 0x0e1351b8UL, 0x0fd13b8fUL,
+    0x0d9785d6UL, 0x0c55efe1UL, 0x091af964UL, 0x08d89353UL, 0x0a9e2d0aUL,
+    0x0b5c473dUL, 0x1c26a370UL, 0x1de4c947UL, 0x1fa2771eUL, 0x1e601d29UL,
+    0x1b2f0bacUL, 0x1aed619bUL, 0x18abdfc2UL, 0x1969b5f5UL, 0x1235f2c8UL,
+    0x13f798ffUL, 0x11b126a6UL, 0x10734c91UL, 0x153c5a14UL, 0x14fe3023UL,
+    0x16b88e7aUL, 0x177ae44dUL, 0x384d46e0UL, 0x398f2cd7UL, 0x3bc9928eUL,
+    0x3a0bf8b9UL, 0x3f44ee3cUL, 0x3e86840bUL, 0x3cc03a52UL, 0x3d025065UL,
+    0x365e1758UL, 0x379c7d6fUL, 0x35dac336UL, 0x3418a901UL, 0x3157bf84UL,
+    0x3095d5b3UL, 0x32d36beaUL, 0x331101ddUL, 0x246be590UL, 0x25a98fa7UL,
+    0x27ef31feUL, 0x262d5bc9UL, 0x23624d4cUL, 0x22a0277bUL, 0x20e69922UL,
+    0x2124f315UL, 0x2a78b428UL, 0x2bbade1fUL, 0x29fc6046UL, 0x283e0a71UL,
+    0x2d711cf4UL, 0x2cb376c3UL, 0x2ef5c89aUL, 0x2f37a2adUL, 0x709a8dc0UL,
+    0x7158e7f7UL, 0x731e59aeUL, 0x72dc3399UL, 0x7793251cUL, 0x76514f2bUL,
+    0x7417f172UL, 0x75d59b45UL, 0x7e89dc78UL, 0x7f4bb64fUL, 0x7d0d0816UL,
+    0x7ccf6221UL, 0x798074a4UL, 0x78421e93UL, 0x7a04a0caUL, 0x7bc6cafdUL,
+    0x6cbc2eb0UL, 0x6d7e4487UL, 0x6f38fadeUL, 0x6efa90e9UL, 0x6bb5866cUL,
+    0x6a77ec5bUL, 0x68315202UL, 0x69f33835UL, 0x62af7f08UL, 0x636d153fUL,
+    0x612bab66UL, 0x60e9c151UL, 0x65a6d7d4UL, 0x6464bde3UL, 0x662203baUL,
+    0x67e0698dUL, 0x48d7cb20UL, 0x4915a117UL, 0x4b531f4eUL, 0x4a917579UL,
+    0x4fde63fcUL, 0x4e1c09cbUL, 0x4c5ab792UL, 0x4d98dda5UL, 0x46c49a98UL,
+    0x4706f0afUL, 0x45404ef6UL, 0x448224c1UL, 0x41cd3244UL, 0x400f5873UL,
+    0x4249e62aUL, 0x438b8c1dUL, 0x54f16850UL, 0x55330267UL, 0x5775bc3eUL,
+    0x56b7d609UL, 0x53f8c08cUL, 0x523aaabbUL, 0x507c14e2UL, 0x51be7ed5UL,
+    0x5ae239e8UL, 0x5b2053dfUL, 0x5966ed86UL, 0x58a487b1UL, 0x5deb9134UL,
+    0x5c29fb03UL, 0x5e6f455aUL, 0x5fad2f6dUL, 0xe1351b80UL, 0xe0f771b7UL,
+    0xe2b1cfeeUL, 0xe373a5d9UL, 0xe63cb35cUL, 0xe7fed96bUL, 0xe5b86732UL,
+    0xe47a0d05UL, 0xef264a38UL, 0xeee4200fUL, 0xeca29e56UL, 0xed60f461UL,
+    0xe82fe2e4UL, 0xe9ed88d3UL, 0xebab368aUL, 0xea695cbdUL, 0xfd13b8f0UL,
+    0xfcd1d2c7UL, 0xfe976c9eUL, 0xff5506a9UL, 0xfa1a102cUL, 0xfbd87a1bUL,
+    0xf99ec442UL, 0xf85cae75UL, 0xf300e948UL, 0xf2c2837fUL, 0xf0843d26UL,
+    0xf1465711UL, 0xf4094194UL, 0xf5cb2ba3UL, 0xf78d95faUL, 0xf64fffcdUL,
+    0xd9785d60UL, 0xd8ba3757UL, 0xdafc890eUL, 0xdb3ee339UL, 0xde71f5bcUL,
+    0xdfb39f8bUL, 0xddf521d2UL, 0xdc374be5UL, 0xd76b0cd8UL, 0xd6a966efUL,
+    0xd4efd8b6UL, 0xd52db281UL, 0xd062a404UL, 0xd1a0ce33UL, 0xd3e6706aUL,
+    0xd2241a5dUL, 0xc55efe10UL, 0xc49c9427UL, 0xc6da2a7eUL, 0xc7184049UL,
+    0xc25756ccUL, 0xc3953cfbUL, 0xc1d382a2UL, 0xc011e895UL, 0xcb4dafa8UL,
+    0xca8fc59fUL, 0xc8c97bc6UL, 0xc90b11f1UL, 0xcc440774UL, 0xcd866d43UL,
+    0xcfc0d31aUL, 0xce02b92dUL, 0x91af9640UL, 0x906dfc77UL, 0x922b422eUL,
+    0x93e92819UL, 0x96a63e9cUL, 0x976454abUL, 0x9522eaf2UL, 0x94e080c5UL,
+    0x9fbcc7f8UL, 0x9e7eadcfUL, 0x9c381396UL, 0x9dfa79a1UL, 0x98b56f24UL,
+    0x99770513UL, 0x9b31bb4aUL, 0x9af3d17dUL, 0x8d893530UL, 0x8c4b5f07UL,
+    0x8e0de15eUL, 0x8fcf8b69UL, 0x8a809decUL, 0x8b42f7dbUL, 0x89044982UL,
+    0x88c623b5UL, 0x839a6488UL, 0x82580ebfUL, 0x801eb0e6UL, 0x81dcdad1UL,
+    0x8493cc54UL, 0x8551a663UL, 0x8717183aUL, 0x86d5720dUL, 0xa9e2d0a0UL,
+    0xa820ba97UL, 0xaa6604ceUL, 0xaba46ef9UL, 0xaeeb787cUL, 0xaf29124bUL,
+    0xad6fac12UL, 0xacadc625UL, 0xa7f18118UL, 0xa633eb2fUL, 0xa4755576UL,
+    0xa5b73f41UL, 0xa0f829c4UL, 0xa13a43f3UL, 0xa37cfdaaUL, 0xa2be979dUL,
+    0xb5c473d0UL, 0xb40619e7UL, 0xb640a7beUL, 0xb782cd89UL, 0xb2cddb0cUL,
+    0xb30fb13bUL, 0xb1490f62UL, 0xb08b6555UL, 0xbbd72268UL, 0xba15485fUL,
+    0xb853f606UL, 0xb9919c31UL, 0xbcde8ab4UL, 0xbd1ce083UL, 0xbf5a5edaUL,
+    0xbe9834edUL
+  },
+  {
+    0x00000000UL, 0xb8bc6765UL, 0xaa09c88bUL, 0x12b5afeeUL, 0x8f629757UL,
+    0x37def032UL, 0x256b5fdcUL, 0x9dd738b9UL, 0xc5b428efUL, 0x7d084f8aUL,
+    0x6fbde064UL, 0xd7018701UL, 0x4ad6bfb8UL, 0xf26ad8ddUL, 0xe0df7733UL,
+    0x58631056UL, 0x5019579fUL, 0xe8a530faUL, 0xfa109f14UL, 0x42acf871UL,
+    0xdf7bc0c8UL, 0x67c7a7adUL, 0x75720843UL, 0xcdce6f26UL, 0x95ad7f70UL,
+    0x2d111815UL, 0x3fa4b7fbUL, 0x8718d09eUL, 0x1acfe827UL, 0xa2738f42UL,
+    0xb0c620acUL, 0x087a47c9UL, 0xa032af3eUL, 0x188ec85bUL, 0x0a3b67b5UL,
+    0xb28700d0UL, 0x2f503869UL, 0x97ec5f0cUL, 0x8559f0e2UL, 0x3de59787UL,
+    0x658687d1UL, 0xdd3ae0b4UL, 0xcf8f4f5aUL, 0x7733283fUL, 0xeae41086UL,
+    0x525877e3UL, 0x40edd80dUL, 0xf851bf68UL, 0xf02bf8a1UL, 0x48979fc4UL,
+    0x5a22302aUL, 0xe29e574fUL, 0x7f496ff6UL, 0xc7f50893UL, 0xd540a77dUL,
+    0x6dfcc018UL, 0x359fd04eUL, 0x8d23b72bUL, 0x9f9618c5UL, 0x272a7fa0UL,
+    0xbafd4719UL, 0x0241207cUL, 0x10f48f92UL, 0xa848e8f7UL, 0x9b14583dUL,
+    0x23a83f58UL, 0x311d90b6UL, 0x89a1f7d3UL, 0x1476cf6aUL, 0xaccaa80fUL,
+    0xbe7f07e1UL, 0x06c36084UL, 0x5ea070d2UL, 0xe61c17b7UL, 0xf4a9b859UL,
+    0x4c15df3cUL, 0xd1c2e785UL, 0x697e80e0UL, 0x7bcb2f0eUL, 0xc377486bUL,
+    0xcb0d0fa2UL, 0x73b168c7UL, 0x6104c729UL, 0xd9b8a04cUL, 0x446f98f5UL,
+    0xfcd3ff90UL, 0xee66507eUL, 0x56da371bUL, 0x0eb9274dUL, 0xb6054028UL,
+    0xa4b0efc6UL, 0x1c0c88a3UL, 0x81dbb01aUL, 0x3967d77fUL, 0x2bd27891UL,
+    0x936e1ff4UL, 0x3b26f703UL, 0x839a9066UL, 0x912f3f88UL, 0x299358edUL,
+    0xb4446054UL, 0x0cf80731UL, 0x1e4da8dfUL, 0xa6f1cfbaUL, 0xfe92dfecUL,
+    0x462eb889UL, 0x549b1767UL, 0xec277002UL, 0x71f048bbUL, 0xc94c2fdeUL,
+    0xdbf98030UL, 0x6345e755UL, 0x6b3fa09cUL, 0xd383c7f9UL, 0xc1366817UL,
+    0x798a0f72UL, 0xe45d37cbUL, 0x5ce150aeUL, 0x4e54ff40UL, 0xf6e89825UL,
+    0xae8b8873UL, 0x1637ef16UL, 0x048240f8UL, 0xbc3e279dUL, 0x21e91f24UL,
+    0x99557841UL, 0x8be0d7afUL, 0x335cb0caUL, 0xed59b63bUL, 0x55e5d15eUL,
+    0x47507eb0UL, 0xffec19d5UL, 0x623b216cUL, 0xda874609UL, 0xc832e9e7UL,
+    0x708e8e82UL, 0x28ed9ed4UL, 0x9051f9b1UL, 0x82e4565fUL, 0x3a58313aUL,
+    0xa78f0983UL, 0x1f336ee6UL, 0x0d86c108UL, 0xb53aa66dUL, 0xbd40e1a4UL,
+    0x05fc86c1UL, 0x1749292fUL, 0xaff54e4aUL, 0x322276f3UL, 0x8a9e1196UL,
+    0x982bbe78UL, 0x2097d91dUL, 0x78f4c94bUL, 0xc048ae2eUL, 0xd2fd01c0UL,
+    0x6a4166a5UL, 0xf7965e1cUL, 0x4f2a3979UL, 0x5d9f9697UL, 0xe523f1f2UL,
+    0x4d6b1905UL, 0xf5d77e60UL, 0xe762d18eUL, 0x5fdeb6ebUL, 0xc2098e52UL,
+    0x7ab5e937UL, 0x680046d9UL, 0xd0bc21bcUL, 0x88df31eaUL, 0x3063568fUL,
+    0x22d6f961UL, 0x9a6a9e04UL, 0x07bda6bdUL, 0xbf01c1d8UL, 0xadb46e36UL,
+    0x15080953UL, 0x1d724e9aUL, 0xa5ce29ffUL, 0xb77b8611UL, 0x0fc7e174UL,
+    0x9210d9cdUL, 0x2aacbea8UL, 0x38191146UL, 0x80a57623UL, 0xd8c66675UL,
+    0x607a0110UL, 0x72cfaefeUL, 0xca73c99bUL, 0x57a4f122UL, 0xef189647UL,
+    0xfdad39a9UL, 0x45115eccUL, 0x764dee06UL, 0xcef18963UL, 0xdc44268dUL,
+    0x64f841e8UL, 0xf92f7951UL, 0x41931e34UL, 0x5326b1daUL, 0xeb9ad6bfUL,
+    0xb3f9c6e9UL, 0x0b45a18cUL, 0x19f00e62UL, 0xa14c6907UL, 0x3c9b51beUL,
+    0x842736dbUL, 0x96929935UL, 0x2e2efe50UL, 0x2654b999UL, 0x9ee8defcUL,
+    0x8c5d7112UL, 0x34e11677UL, 0xa9362eceUL, 0x118a49abUL, 0x033fe645UL,
+    0xbb838120UL, 0xe3e09176UL, 0x5b5cf613UL, 0x49e959fdUL, 0xf1553e98UL,
+    0x6c820621UL, 0xd43e6144UL, 0xc68bceaaUL, 0x7e37a9cfUL, 0xd67f4138UL,
+    0x6ec3265dUL, 0x7c7689b3UL, 0xc4caeed6UL, 0x591dd66fUL, 0xe1a1b10aUL,
+    0xf3141ee4UL, 0x4ba87981UL, 0x13cb69d7UL, 0xab770eb2UL, 0xb9c2a15cUL,
+    0x017ec639UL, 0x9ca9fe80UL, 0x241599e5UL, 0x36a0360bUL, 0x8e1c516eUL,
+    0x866616a7UL, 0x3eda71c2UL, 0x2c6fde2cUL, 0x94d3b949UL, 0x090481f0UL,
+    0xb1b8e695UL, 0xa30d497bUL, 0x1bb12e1eUL, 0x43d23e48UL, 0xfb6e592dUL,
+    0xe9dbf6c3UL, 0x516791a6UL, 0xccb0a91fUL, 0x740cce7aUL, 0x66b96194UL,
+    0xde0506f1UL
+  },
+  {
+    0x00000000UL, 0x96300777UL, 0x2c610eeeUL, 0xba510999UL, 0x19c46d07UL,
+    0x8ff46a70UL, 0x35a563e9UL, 0xa395649eUL, 0x3288db0eUL, 0xa4b8dc79UL,
+    0x1ee9d5e0UL, 0x88d9d297UL, 0x2b4cb609UL, 0xbd7cb17eUL, 0x072db8e7UL,
+    0x911dbf90UL, 0x6410b71dUL, 0xf220b06aUL, 0x4871b9f3UL, 0xde41be84UL,
+    0x7dd4da1aUL, 0xebe4dd6dUL, 0x51b5d4f4UL, 0xc785d383UL, 0x56986c13UL,
+    0xc0a86b64UL, 0x7af962fdUL, 0xecc9658aUL, 0x4f5c0114UL, 0xd96c0663UL,
+    0x633d0ffaUL, 0xf50d088dUL, 0xc8206e3bUL, 0x5e10694cUL, 0xe44160d5UL,
+    0x727167a2UL, 0xd1e4033cUL, 0x47d4044bUL, 0xfd850dd2UL, 0x6bb50aa5UL,
+    0xfaa8b535UL, 0x6c98b242UL, 0xd6c9bbdbUL, 0x40f9bcacUL, 0xe36cd832UL,
+    0x755cdf45UL, 0xcf0dd6dcUL, 0x593dd1abUL, 0xac30d926UL, 0x3a00de51UL,
+    0x8051d7c8UL, 0x1661d0bfUL, 0xb5f4b421UL, 0x23c4b356UL, 0x9995bacfUL,
+    0x0fa5bdb8UL, 0x9eb80228UL, 0x0888055fUL, 0xb2d90cc6UL, 0x24e90bb1UL,
+    0x877c6f2fUL, 0x114c6858UL, 0xab1d61c1UL, 0x3d2d66b6UL, 0x9041dc76UL,
+    0x0671db01UL, 0xbc20d298UL, 0x2a10d5efUL, 0x8985b171UL, 0x1fb5b606UL,
+    0xa5e4bf9fUL, 0x33d4b8e8UL, 0xa2c90778UL, 0x34f9000fUL, 0x8ea80996UL,
+    0x18980ee1UL, 0xbb0d6a7fUL, 0x2d3d6d08UL, 0x976c6491UL, 0x015c63e6UL,
+    0xf4516b6bUL, 0x62616c1cUL, 0xd8306585UL, 0x4e0062f2UL, 0xed95066cUL,
+    0x7ba5011bUL, 0xc1f40882UL, 0x57c40ff5UL, 0xc6d9b065UL, 0x50e9b712UL,
+    0xeab8be8bUL, 0x7c88b9fcUL, 0xdf1ddd62UL, 0x492dda15UL, 0xf37cd38cUL,
+    0x654cd4fbUL, 0x5861b24dUL, 0xce51b53aUL, 0x7400bca3UL, 0xe230bbd4UL,
+    0x41a5df4aUL, 0xd795d83dUL, 0x6dc4d1a4UL, 0xfbf4d6d3UL, 0x6ae96943UL,
+    0xfcd96e34UL, 0x468867adUL, 0xd0b860daUL, 0x732d0444UL, 0xe51d0333UL,
+    0x5f4c0aaaUL, 0xc97c0dddUL, 0x3c710550UL, 0xaa410227UL, 0x10100bbeUL,
+    0x86200cc9UL, 0x25b56857UL, 0xb3856f20UL, 0x09d466b9UL, 0x9fe461ceUL,
+    0x0ef9de5eUL, 0x98c9d929UL, 0x2298d0b0UL, 0xb4a8d7c7UL, 0x173db359UL,
+    0x810db42eUL, 0x3b5cbdb7UL, 0xad6cbac0UL, 0x2083b8edUL, 0xb6b3bf9aUL,
+    0x0ce2b603UL, 0x9ad2b174UL, 0x3947d5eaUL, 0xaf77d29dUL, 0x1526db04UL,
+    0x8316dc73UL, 0x120b63e3UL, 0x843b6494UL, 0x3e6a6d0dUL, 0xa85a6a7aUL,
+    0x0bcf0ee4UL, 0x9dff0993UL, 0x27ae000aUL, 0xb19e077dUL, 0x44930ff0UL,
+    0xd2a30887UL, 0x68f2011eUL, 0xfec20669UL, 0x5d5762f7UL, 0xcb676580UL,
+    0x71366c19UL, 0xe7066b6eUL, 0x761bd4feUL, 0xe02bd389UL, 0x5a7ada10UL,
+    0xcc4add67UL, 0x6fdfb9f9UL, 0xf9efbe8eUL, 0x43beb717UL, 0xd58eb060UL,
+    0xe8a3d6d6UL, 0x7e93d1a1UL, 0xc4c2d838UL, 0x52f2df4fUL, 0xf167bbd1UL,
+    0x6757bca6UL, 0xdd06b53fUL, 0x4b36b248UL, 0xda2b0dd8UL, 0x4c1b0aafUL,
+    0xf64a0336UL, 0x607a0441UL, 0xc3ef60dfUL, 0x55df67a8UL, 0xef8e6e31UL,
+    0x79be6946UL, 0x8cb361cbUL, 0x1a8366bcUL, 0xa0d26f25UL, 0x36e26852UL,
+    0x95770cccUL, 0x03470bbbUL, 0xb9160222UL, 0x2f260555UL, 0xbe3bbac5UL,
+    0x280bbdb2UL, 0x925ab42bUL, 0x046ab35cUL, 0xa7ffd7c2UL, 0x31cfd0b5UL,
+    0x8b9ed92cUL, 0x1daede5bUL, 0xb0c2649bUL, 0x26f263ecUL, 0x9ca36a75UL,
+    0x0a936d02UL, 0xa906099cUL, 0x3f360eebUL, 0x85670772UL, 0x13570005UL,
+    0x824abf95UL, 0x147ab8e2UL, 0xae2bb17bUL, 0x381bb60cUL, 0x9b8ed292UL,
+    0x0dbed5e5UL, 0xb7efdc7cUL, 0x21dfdb0bUL, 0xd4d2d386UL, 0x42e2d4f1UL,
+    0xf8b3dd68UL, 0x6e83da1fUL, 0xcd16be81UL, 0x5b26b9f6UL, 0xe177b06fUL,
+    0x7747b718UL, 0xe65a0888UL, 0x706a0fffUL, 0xca3b0666UL, 0x5c0b0111UL,
+    0xff9e658fUL, 0x69ae62f8UL, 0xd3ff6b61UL, 0x45cf6c16UL, 0x78e20aa0UL,
+    0xeed20dd7UL, 0x5483044eUL, 0xc2b30339UL, 0x612667a7UL, 0xf71660d0UL,
+    0x4d476949UL, 0xdb776e3eUL, 0x4a6ad1aeUL, 0xdc5ad6d9UL, 0x660bdf40UL,
+    0xf03bd837UL, 0x53aebca9UL, 0xc59ebbdeUL, 0x7fcfb247UL, 0xe9ffb530UL,
+    0x1cf2bdbdUL, 0x8ac2bacaUL, 0x3093b353UL, 0xa6a3b424UL, 0x0536d0baUL,
+    0x9306d7cdUL, 0x2957de54UL, 0xbf67d923UL, 0x2e7a66b3UL, 0xb84a61c4UL,
+    0x021b685dUL, 0x942b6f2aUL, 0x37be0bb4UL, 0xa18e0cc3UL, 0x1bdf055aUL,
+    0x8def022dUL
+  },
+  {
+    0x00000000UL, 0x41311b19UL, 0x82623632UL, 0xc3532d2bUL, 0x04c56c64UL,
+    0x45f4777dUL, 0x86a75a56UL, 0xc796414fUL, 0x088ad9c8UL, 0x49bbc2d1UL,
+    0x8ae8effaUL, 0xcbd9f4e3UL, 0x0c4fb5acUL, 0x4d7eaeb5UL, 0x8e2d839eUL,
+    0xcf1c9887UL, 0x5112c24aUL, 0x1023d953UL, 0xd370f478UL, 0x9241ef61UL,
+    0x55d7ae2eUL, 0x14e6b537UL, 0xd7b5981cUL, 0x96848305UL, 0x59981b82UL,
+    0x18a9009bUL, 0xdbfa2db0UL, 0x9acb36a9UL, 0x5d5d77e6UL, 0x1c6c6cffUL,
+    0xdf3f41d4UL, 0x9e0e5acdUL, 0xa2248495UL, 0xe3159f8cUL, 0x2046b2a7UL,
+    0x6177a9beUL, 0xa6e1e8f1UL, 0xe7d0f3e8UL, 0x2483dec3UL, 0x65b2c5daUL,
+    0xaaae5d5dUL, 0xeb9f4644UL, 0x28cc6b6fUL, 0x69fd7076UL, 0xae6b3139UL,
+    0xef5a2a20UL, 0x2c09070bUL, 0x6d381c12UL, 0xf33646dfUL, 0xb2075dc6UL,
+    0x715470edUL, 0x30656bf4UL, 0xf7f32abbUL, 0xb6c231a2UL, 0x75911c89UL,
+    0x34a00790UL, 0xfbbc9f17UL, 0xba8d840eUL, 0x79dea925UL, 0x38efb23cUL,
+    0xff79f373UL, 0xbe48e86aUL, 0x7d1bc541UL, 0x3c2ade58UL, 0x054f79f0UL,
+    0x447e62e9UL, 0x872d4fc2UL, 0xc61c54dbUL, 0x018a1594UL, 0x40bb0e8dUL,
+    0x83e823a6UL, 0xc2d938bfUL, 0x0dc5a038UL, 0x4cf4bb21UL, 0x8fa7960aUL,
+    0xce968d13UL, 0x0900cc5cUL, 0x4831d745UL, 0x8b62fa6eUL, 0xca53e177UL,
+    0x545dbbbaUL, 0x156ca0a3UL, 0xd63f8d88UL, 0x970e9691UL, 0x5098d7deUL,
+    0x11a9ccc7UL, 0xd2fae1ecUL, 0x93cbfaf5UL, 0x5cd76272UL, 0x1de6796bUL,
+    0xdeb55440UL, 0x9f844f59UL, 0x58120e16UL, 0x1923150fUL, 0xda703824UL,
+    0x9b41233dUL, 0xa76bfd65UL, 0xe65ae67cUL, 0x2509cb57UL, 0x6438d04eUL,
+    0xa3ae9101UL, 0xe29f8a18UL, 0x21cca733UL, 0x60fdbc2aUL, 0xafe124adUL,
+    0xeed03fb4UL, 0x2d83129fUL, 0x6cb20986UL, 0xab2448c9UL, 0xea1553d0UL,
+    0x29467efbUL, 0x687765e2UL, 0xf6793f2fUL, 0xb7482436UL, 0x741b091dUL,
+    0x352a1204UL, 0xf2bc534bUL, 0xb38d4852UL, 0x70de6579UL, 0x31ef7e60UL,
+    0xfef3e6e7UL, 0xbfc2fdfeUL, 0x7c91d0d5UL, 0x3da0cbccUL, 0xfa368a83UL,
+    0xbb07919aUL, 0x7854bcb1UL, 0x3965a7a8UL, 0x4b98833bUL, 0x0aa99822UL,
+    0xc9fab509UL, 0x88cbae10UL, 0x4f5def5fUL, 0x0e6cf446UL, 0xcd3fd96dUL,
+    0x8c0ec274UL, 0x43125af3UL, 0x022341eaUL, 0xc1706cc1UL, 0x804177d8UL,
+    0x47d73697UL, 0x06e62d8eUL, 0xc5b500a5UL, 0x84841bbcUL, 0x1a8a4171UL,
+    0x5bbb5a68UL, 0x98e87743UL, 0xd9d96c5aUL, 0x1e4f2d15UL, 0x5f7e360cUL,
+    0x9c2d1b27UL, 0xdd1c003eUL, 0x120098b9UL, 0x533183a0UL, 0x9062ae8bUL,
+    0xd153b592UL, 0x16c5f4ddUL, 0x57f4efc4UL, 0x94a7c2efUL, 0xd596d9f6UL,
+    0xe9bc07aeUL, 0xa88d1cb7UL, 0x6bde319cUL, 0x2aef2a85UL, 0xed796bcaUL,
+    0xac4870d3UL, 0x6f1b5df8UL, 0x2e2a46e1UL, 0xe136de66UL, 0xa007c57fUL,
+    0x6354e854UL, 0x2265f34dUL, 0xe5f3b202UL, 0xa4c2a91bUL, 0x67918430UL,
+    0x26a09f29UL, 0xb8aec5e4UL, 0xf99fdefdUL, 0x3accf3d6UL, 0x7bfde8cfUL,
+    0xbc6ba980UL, 0xfd5ab299UL, 0x3e099fb2UL, 0x7f3884abUL, 0xb0241c2cUL,
+    0xf1150735UL, 0x32462a1eUL, 0x73773107UL, 0xb4e17048UL, 0xf5d06b51UL,
+    0x3683467aUL, 0x77b25d63UL, 0x4ed7facbUL, 0x0fe6e1d2UL, 0xccb5ccf9UL,
+    0x8d84d7e0UL, 0x4a1296afUL, 0x0b238db6UL, 0xc870a09dUL, 0x8941bb84UL,
+    0x465d2303UL, 0x076c381aUL, 0xc43f1531UL, 0x850e0e28UL, 0x42984f67UL,
+    0x03a9547eUL, 0xc0fa7955UL, 0x81cb624cUL, 0x1fc53881UL, 0x5ef42398UL,
+    0x9da70eb3UL, 0xdc9615aaUL, 0x1b0054e5UL, 0x5a314ffcUL, 0x996262d7UL,
+    0xd85379ceUL, 0x174fe149UL, 0x567efa50UL, 0x952dd77bUL, 0xd41ccc62UL,
+    0x138a8d2dUL, 0x52bb9634UL, 0x91e8bb1fUL, 0xd0d9a006UL, 0xecf37e5eUL,
+    0xadc26547UL, 0x6e91486cUL, 0x2fa05375UL, 0xe836123aUL, 0xa9070923UL,
+    0x6a542408UL, 0x2b653f11UL, 0xe479a796UL, 0xa548bc8fUL, 0x661b91a4UL,
+    0x272a8abdUL, 0xe0bccbf2UL, 0xa18dd0ebUL, 0x62defdc0UL, 0x23efe6d9UL,
+    0xbde1bc14UL, 0xfcd0a70dUL, 0x3f838a26UL, 0x7eb2913fUL, 0xb924d070UL,
+    0xf815cb69UL, 0x3b46e642UL, 0x7a77fd5bUL, 0xb56b65dcUL, 0xf45a7ec5UL,
+    0x370953eeUL, 0x763848f7UL, 0xb1ae09b8UL, 0xf09f12a1UL, 0x33cc3f8aUL,
+    0x72fd2493UL
+  },
+  {
+    0x00000000UL, 0x376ac201UL, 0x6ed48403UL, 0x59be4602UL, 0xdca80907UL,
+    0xebc2cb06UL, 0xb27c8d04UL, 0x85164f05UL, 0xb851130eUL, 0x8f3bd10fUL,
+    0xd685970dUL, 0xe1ef550cUL, 0x64f91a09UL, 0x5393d808UL, 0x0a2d9e0aUL,
+    0x3d475c0bUL, 0x70a3261cUL, 0x47c9e41dUL, 0x1e77a21fUL, 0x291d601eUL,
+    0xac0b2f1bUL, 0x9b61ed1aUL, 0xc2dfab18UL, 0xf5b56919UL, 0xc8f23512UL,
+    0xff98f713UL, 0xa626b111UL, 0x914c7310UL, 0x145a3c15UL, 0x2330fe14UL,
+    0x7a8eb816UL, 0x4de47a17UL, 0xe0464d38UL, 0xd72c8f39UL, 0x8e92c93bUL,
+    0xb9f80b3aUL, 0x3cee443fUL, 0x0b84863eUL, 0x523ac03cUL, 0x6550023dUL,
+    0x58175e36UL, 0x6f7d9c37UL, 0x36c3da35UL, 0x01a91834UL, 0x84bf5731UL,
+    0xb3d59530UL, 0xea6bd332UL, 0xdd011133UL, 0x90e56b24UL, 0xa78fa925UL,
+    0xfe31ef27UL, 0xc95b2d26UL, 0x4c4d6223UL, 0x7b27a022UL, 0x2299e620UL,
+    0x15f32421UL, 0x28b4782aUL, 0x1fdeba2bUL, 0x4660fc29UL, 0x710a3e28UL,
+    0xf41c712dUL, 0xc376b32cUL, 0x9ac8f52eUL, 0xada2372fUL, 0xc08d9a70UL,
+    0xf7e75871UL, 0xae591e73UL, 0x9933dc72UL, 0x1c259377UL, 0x2b4f5176UL,
+    0x72f11774UL, 0x459bd575UL, 0x78dc897eUL, 0x4fb64b7fUL, 0x16080d7dUL,
+    0x2162cf7cUL, 0xa4748079UL, 0x931e4278UL, 0xcaa0047aUL, 0xfdcac67bUL,
+    0xb02ebc6cUL, 0x87447e6dUL, 0xdefa386fUL, 0xe990fa6eUL, 0x6c86b56bUL,
+    0x5bec776aUL, 0x02523168UL, 0x3538f369UL, 0x087faf62UL, 0x3f156d63UL,
+    0x66ab2b61UL, 0x51c1e960UL, 0xd4d7a665UL, 0xe3bd6464UL, 0xba032266UL,
+    0x8d69e067UL, 0x20cbd748UL, 0x17a11549UL, 0x4e1f534bUL, 0x7975914aUL,
+    0xfc63de4fUL, 0xcb091c4eUL, 0x92b75a4cUL, 0xa5dd984dUL, 0x989ac446UL,
+    0xaff00647UL, 0xf64e4045UL, 0xc1248244UL, 0x4432cd41UL, 0x73580f40UL,
+    0x2ae64942UL, 0x1d8c8b43UL, 0x5068f154UL, 0x67023355UL, 0x3ebc7557UL,
+    0x09d6b756UL, 0x8cc0f853UL, 0xbbaa3a52UL, 0xe2147c50UL, 0xd57ebe51UL,
+    0xe839e25aUL, 0xdf53205bUL, 0x86ed6659UL, 0xb187a458UL, 0x3491eb5dUL,
+    0x03fb295cUL, 0x5a456f5eUL, 0x6d2fad5fUL, 0x801b35e1UL, 0xb771f7e0UL,
+    0xeecfb1e2UL, 0xd9a573e3UL, 0x5cb33ce6UL, 0x6bd9fee7UL, 0x3267b8e5UL,
+    0x050d7ae4UL, 0x384a26efUL, 0x0f20e4eeUL, 0x569ea2ecUL, 0x61f460edUL,
+    0xe4e22fe8UL, 0xd388ede9UL, 0x8a36abebUL, 0xbd5c69eaUL, 0xf0b813fdUL,
+    0xc7d2d1fcUL, 0x9e6c97feUL, 0xa90655ffUL, 0x2c101afaUL, 0x1b7ad8fbUL,
+    0x42c49ef9UL, 0x75ae5cf8UL, 0x48e900f3UL, 0x7f83c2f2UL, 0x263d84f0UL,
+    0x115746f1UL, 0x944109f4UL, 0xa32bcbf5UL, 0xfa958df7UL, 0xcdff4ff6UL,
+    0x605d78d9UL, 0x5737bad8UL, 0x0e89fcdaUL, 0x39e33edbUL, 0xbcf571deUL,
+    0x8b9fb3dfUL, 0xd221f5ddUL, 0xe54b37dcUL, 0xd80c6bd7UL, 0xef66a9d6UL,
+    0xb6d8efd4UL, 0x81b22dd5UL, 0x04a462d0UL, 0x33cea0d1UL, 0x6a70e6d3UL,
+    0x5d1a24d2UL, 0x10fe5ec5UL, 0x27949cc4UL, 0x7e2adac6UL, 0x494018c7UL,
+    0xcc5657c2UL, 0xfb3c95c3UL, 0xa282d3c1UL, 0x95e811c0UL, 0xa8af4dcbUL,
+    0x9fc58fcaUL, 0xc67bc9c8UL, 0xf1110bc9UL, 0x740744ccUL, 0x436d86cdUL,
+    0x1ad3c0cfUL, 0x2db902ceUL, 0x4096af91UL, 0x77fc6d90UL, 0x2e422b92UL,
+    0x1928e993UL, 0x9c3ea696UL, 0xab546497UL, 0xf2ea2295UL, 0xc580e094UL,
+    0xf8c7bc9fUL, 0xcfad7e9eUL, 0x9613389cUL, 0xa179fa9dUL, 0x246fb598UL,
+    0x13057799UL, 0x4abb319bUL, 0x7dd1f39aUL, 0x3035898dUL, 0x075f4b8cUL,
+    0x5ee10d8eUL, 0x698bcf8fUL, 0xec9d808aUL, 0xdbf7428bUL, 0x82490489UL,
+    0xb523c688UL, 0x88649a83UL, 0xbf0e5882UL, 0xe6b01e80UL, 0xd1dadc81UL,
+    0x54cc9384UL, 0x63a65185UL, 0x3a181787UL, 0x0d72d586UL, 0xa0d0e2a9UL,
+    0x97ba20a8UL, 0xce0466aaUL, 0xf96ea4abUL, 0x7c78ebaeUL, 0x4b1229afUL,
+    0x12ac6fadUL, 0x25c6adacUL, 0x1881f1a7UL, 0x2feb33a6UL, 0x765575a4UL,
+    0x413fb7a5UL, 0xc429f8a0UL, 0xf3433aa1UL, 0xaafd7ca3UL, 0x9d97bea2UL,
+    0xd073c4b5UL, 0xe71906b4UL, 0xbea740b6UL, 0x89cd82b7UL, 0x0cdbcdb2UL,
+    0x3bb10fb3UL, 0x620f49b1UL, 0x55658bb0UL, 0x6822d7bbUL, 0x5f4815baUL,
+    0x06f653b8UL, 0x319c91b9UL, 0xb48adebcUL, 0x83e01cbdUL, 0xda5e5abfUL,
+    0xed3498beUL
+  },
+  {
+    0x00000000UL, 0x6567bcb8UL, 0x8bc809aaUL, 0xeeafb512UL, 0x5797628fUL,
+    0x32f0de37UL, 0xdc5f6b25UL, 0xb938d79dUL, 0xef28b4c5UL, 0x8a4f087dUL,
+    0x64e0bd6fUL, 0x018701d7UL, 0xb8bfd64aUL, 0xddd86af2UL, 0x3377dfe0UL,
+    0x56106358UL, 0x9f571950UL, 0xfa30a5e8UL, 0x149f10faUL, 0x71f8ac42UL,
+    0xc8c07bdfUL, 0xada7c767UL, 0x43087275UL, 0x266fcecdUL, 0x707fad95UL,
+    0x1518112dUL, 0xfbb7a43fUL, 0x9ed01887UL, 0x27e8cf1aUL, 0x428f73a2UL,
+    0xac20c6b0UL, 0xc9477a08UL, 0x3eaf32a0UL, 0x5bc88e18UL, 0xb5673b0aUL,
+    0xd00087b2UL, 0x6938502fUL, 0x0c5fec97UL, 0xe2f05985UL, 0x8797e53dUL,
+    0xd1878665UL, 0xb4e03addUL, 0x5a4f8fcfUL, 0x3f283377UL, 0x8610e4eaUL,
+    0xe3775852UL, 0x0dd8ed40UL, 0x68bf51f8UL, 0xa1f82bf0UL, 0xc49f9748UL,
+    0x2a30225aUL, 0x4f579ee2UL, 0xf66f497fUL, 0x9308f5c7UL, 0x7da740d5UL,
+    0x18c0fc6dUL, 0x4ed09f35UL, 0x2bb7238dUL, 0xc518969fUL, 0xa07f2a27UL,
+    0x1947fdbaUL, 0x7c204102UL, 0x928ff410UL, 0xf7e848a8UL, 0x3d58149bUL,
+    0x583fa823UL, 0xb6901d31UL, 0xd3f7a189UL, 0x6acf7614UL, 0x0fa8caacUL,
+    0xe1077fbeUL, 0x8460c306UL, 0xd270a05eUL, 0xb7171ce6UL, 0x59b8a9f4UL,
+    0x3cdf154cUL, 0x85e7c2d1UL, 0xe0807e69UL, 0x0e2fcb7bUL, 0x6b4877c3UL,
+    0xa20f0dcbUL, 0xc768b173UL, 0x29c70461UL, 0x4ca0b8d9UL, 0xf5986f44UL,
+    0x90ffd3fcUL, 0x7e5066eeUL, 0x1b37da56UL, 0x4d27b90eUL, 0x284005b6UL,
+    0xc6efb0a4UL, 0xa3880c1cUL, 0x1ab0db81UL, 0x7fd76739UL, 0x9178d22bUL,
+    0xf41f6e93UL, 0x03f7263bUL, 0x66909a83UL, 0x883f2f91UL, 0xed589329UL,
+    0x546044b4UL, 0x3107f80cUL, 0xdfa84d1eUL, 0xbacff1a6UL, 0xecdf92feUL,
+    0x89b82e46UL, 0x67179b54UL, 0x027027ecUL, 0xbb48f071UL, 0xde2f4cc9UL,
+    0x3080f9dbUL, 0x55e74563UL, 0x9ca03f6bUL, 0xf9c783d3UL, 0x176836c1UL,
+    0x720f8a79UL, 0xcb375de4UL, 0xae50e15cUL, 0x40ff544eUL, 0x2598e8f6UL,
+    0x73888baeUL, 0x16ef3716UL, 0xf8408204UL, 0x9d273ebcUL, 0x241fe921UL,
+    0x41785599UL, 0xafd7e08bUL, 0xcab05c33UL, 0x3bb659edUL, 0x5ed1e555UL,
+    0xb07e5047UL, 0xd519ecffUL, 0x6c213b62UL, 0x094687daUL, 0xe7e932c8UL,
+    0x828e8e70UL, 0xd49eed28UL, 0xb1f95190UL, 0x5f56e482UL, 0x3a31583aUL,
+    0x83098fa7UL, 0xe66e331fUL, 0x08c1860dUL, 0x6da63ab5UL, 0xa4e140bdUL,
+    0xc186fc05UL, 0x2f294917UL, 0x4a4ef5afUL, 0xf3762232UL, 0x96119e8aUL,
+    0x78be2b98UL, 0x1dd99720UL, 0x4bc9f478UL, 0x2eae48c0UL, 0xc001fdd2UL,
+    0xa566416aUL, 0x1c5e96f7UL, 0x79392a4fUL, 0x97969f5dUL, 0xf2f123e5UL,
+    0x05196b4dUL, 0x607ed7f5UL, 0x8ed162e7UL, 0xebb6de5fUL, 0x528e09c2UL,
+    0x37e9b57aUL, 0xd9460068UL, 0xbc21bcd0UL, 0xea31df88UL, 0x8f566330UL,
+    0x61f9d622UL, 0x049e6a9aUL, 0xbda6bd07UL, 0xd8c101bfUL, 0x366eb4adUL,
+    0x53090815UL, 0x9a4e721dUL, 0xff29cea5UL, 0x11867bb7UL, 0x74e1c70fUL,
+    0xcdd91092UL, 0xa8beac2aUL, 0x46111938UL, 0x2376a580UL, 0x7566c6d8UL,
+    0x10017a60UL, 0xfeaecf72UL, 0x9bc973caUL, 0x22f1a457UL, 0x479618efUL,
+    0xa939adfdUL, 0xcc5e1145UL, 0x06ee4d76UL, 0x6389f1ceUL, 0x8d2644dcUL,
+    0xe841f864UL, 0x51792ff9UL, 0x341e9341UL, 0xdab12653UL, 0xbfd69aebUL,
+    0xe9c6f9b3UL, 0x8ca1450bUL, 0x620ef019UL, 0x07694ca1UL, 0xbe519b3cUL,
+    0xdb362784UL, 0x35999296UL, 0x50fe2e2eUL, 0x99b95426UL, 0xfcdee89eUL,
+    0x12715d8cUL, 0x7716e134UL, 0xce2e36a9UL, 0xab498a11UL, 0x45e63f03UL,
+    0x208183bbUL, 0x7691e0e3UL, 0x13f65c5bUL, 0xfd59e949UL, 0x983e55f1UL,
+    0x2106826cUL, 0x44613ed4UL, 0xaace8bc6UL, 0xcfa9377eUL, 0x38417fd6UL,
+    0x5d26c36eUL, 0xb389767cUL, 0xd6eecac4UL, 0x6fd61d59UL, 0x0ab1a1e1UL,
+    0xe41e14f3UL, 0x8179a84bUL, 0xd769cb13UL, 0xb20e77abUL, 0x5ca1c2b9UL,
+    0x39c67e01UL, 0x80fea99cUL, 0xe5991524UL, 0x0b36a036UL, 0x6e511c8eUL,
+    0xa7166686UL, 0xc271da3eUL, 0x2cde6f2cUL, 0x49b9d394UL, 0xf0810409UL,
+    0x95e6b8b1UL, 0x7b490da3UL, 0x1e2eb11bUL, 0x483ed243UL, 0x2d596efbUL,
+    0xc3f6dbe9UL, 0xa6916751UL, 0x1fa9b0ccUL, 0x7ace0c74UL, 0x9461b966UL,
+    0xf10605deUL
+#endif
+  }
+};

.ccls-cache/@home@anon@Documents@Code@minecraftconsoles/Minecraft.Client@Common@zlib@deflate.h

@@ -0,0 +1,346 @@
+/* deflate.h -- internal compression state
+ * Copyright (C) 1995-2012 Jean-loup Gailly
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+   part of the implementation of the compression library and is
+   subject to change. Applications should only use zlib.h.
+ */
+
+/* @(#) $Id$ */
+
+#ifndef DEFLATE_H
+#define DEFLATE_H
+
+#include "zutil.h"
+
+/* define NO_GZIP when compiling if you want to disable gzip header and
+   trailer creation by deflate().  NO_GZIP would be used to avoid linking in
+   the crc code when it is not needed.  For shared libraries, gzip encoding
+   should be left enabled. */
+#ifndef NO_GZIP
+#  define GZIP
+#endif
+
+/* ===========================================================================
+ * Internal compression state.
+ */
+
+#define LENGTH_CODES 29
+/* number of length codes, not counting the special END_BLOCK code */
+
+#define LITERALS  256
+/* number of literal bytes 0..255 */
+
+#define L_CODES (LITERALS+1+LENGTH_CODES)
+/* number of Literal or Length codes, including the END_BLOCK code */
+
+#define D_CODES   30
+/* number of distance codes */
+
+#define BL_CODES  19
+/* number of codes used to transfer the bit lengths */
+
+#define HEAP_SIZE (2*L_CODES+1)
+/* maximum heap size */
+
+#define MAX_BITS 15
+/* All codes must not exceed MAX_BITS bits */
+
+#define Buf_size 16
+/* size of bit buffer in bi_buf */
+
+#define INIT_STATE    42
+#define EXTRA_STATE   69
+#define NAME_STATE    73
+#define COMMENT_STATE 91
+#define HCRC_STATE   103
+#define BUSY_STATE   113
+#define FINISH_STATE 666
+/* Stream status */
+
+
+/* Data structure describing a single value and its code string. */
+typedef struct ct_data_s {
+    union {
+        ush  freq;       /* frequency count */
+        ush  code;       /* bit string */
+    } fc;
+    union {
+        ush  dad;        /* father node in Huffman tree */
+        ush  len;        /* length of bit string */
+    } dl;
+} FAR ct_data;
+
+#define Freq fc.freq
+#define Code fc.code
+#define Dad  dl.dad
+#define Len  dl.len
+
+typedef struct static_tree_desc_s  static_tree_desc;
+
+typedef struct tree_desc_s {
+    ct_data *dyn_tree;           /* the dynamic tree */
+    int     max_code;            /* largest code with non zero frequency */
+    static_tree_desc *stat_desc; /* the corresponding static tree */
+} FAR tree_desc;
+
+typedef ush Pos;
+typedef Pos FAR Posf;
+typedef unsigned IPos;
+
+/* A Pos is an index in the character window. We use short instead of int to
+ * save space in the various tables. IPos is used only for parameter passing.
+ */
+
+typedef struct internal_state {
+    z_streamp strm;      /* pointer back to this zlib stream */
+    int   status;        /* as the name implies */
+    Bytef *pending_buf;  /* output still pending */
+    ulg   pending_buf_size; /* size of pending_buf */
+    Bytef *pending_out;  /* next pending byte to output to the stream */
+    uInt   pending;      /* nb of bytes in the pending buffer */
+    int   wrap;          /* bit 0 true for zlib, bit 1 true for gzip */
+    gz_headerp  gzhead;  /* gzip header information to write */
+    uInt   gzindex;      /* where in extra, name, or comment */
+    Byte  method;        /* can only be DEFLATED */
+    int   last_flush;    /* value of flush param for previous deflate call */
+
+                /* used by deflate.c: */
+
+    uInt  w_size;        /* LZ77 window size (32K by default) */
+    uInt  w_bits;        /* log2(w_size)  (8..16) */
+    uInt  w_mask;        /* w_size - 1 */
+
+    Bytef *window;
+    /* Sliding window. Input bytes are read into the second half of the window,
+     * and move to the first half later to keep a dictionary of at least wSize
+     * bytes. With this organization, matches are limited to a distance of
+     * wSize-MAX_MATCH bytes, but this ensures that IO is always
+     * performed with a length multiple of the block size. Also, it limits
+     * the window size to 64K, which is quite useful on MSDOS.
+     * To do: use the user input buffer as sliding window.
+     */
+
+    ulg window_size;
+    /* Actual size of window: 2*wSize, except when the user input buffer
+     * is directly used as sliding window.
+     */
+
+    Posf *prev;
+    /* Link to older string with same hash index. To limit the size of this
+     * array to 64K, this link is maintained only for the last 32K strings.
+     * An index in this array is thus a window index modulo 32K.
+     */
+
+    Posf *head; /* Heads of the hash chains or NIL. */
+
+    uInt  ins_h;          /* hash index of string to be inserted */
+    uInt  hash_size;      /* number of elements in hash table */
+    uInt  hash_bits;      /* log2(hash_size) */
+    uInt  hash_mask;      /* hash_size-1 */
+
+    uInt  hash_shift;
+    /* Number of bits by which ins_h must be shifted at each input
+     * step. It must be such that after MIN_MATCH steps, the oldest
+     * byte no longer takes part in the hash key, that is:
+     *   hash_shift * MIN_MATCH >= hash_bits
+     */
+
+    long block_start;
+    /* Window position at the beginning of the current output block. Gets
+     * negative when the window is moved backwards.
+     */
+
+    uInt match_length;           /* length of best match */
+    IPos prev_match;             /* previous match */
+    int match_available;         /* set if previous match exists */
+    uInt strstart;               /* start of string to insert */
+    uInt match_start;            /* start of matching string */
+    uInt lookahead;              /* number of valid bytes ahead in window */
+
+    uInt prev_length;
+    /* Length of the best match at previous step. Matches not greater than this
+     * are discarded. This is used in the lazy match evaluation.
+     */
+
+    uInt max_chain_length;
+    /* To speed up deflation, hash chains are never searched beyond this
+     * length.  A higher limit improves compression ratio but degrades the
+     * speed.
+     */
+
+    uInt max_lazy_match;
+    /* Attempt to find a better match only when the current match is strictly
+     * smaller than this value. This mechanism is used only for compression
+     * levels >= 4.
+     */
+#   define max_insert_length  max_lazy_match
+    /* Insert new strings in the hash table only if the match length is not
+     * greater than this length. This saves time but degrades compression.
+     * max_insert_length is used only for compression levels <= 3.
+     */
+
+    int level;    /* compression level (1..9) */
+    int strategy; /* favor or force Huffman coding*/
+
+    uInt good_match;
+    /* Use a faster search when the previous match is longer than this */
+
+    int nice_match; /* Stop searching when current match exceeds this */
+
+                /* used by trees.c: */
+    /* Didn't use ct_data typedef below to suppress compiler warning */
+    struct ct_data_s dyn_ltree[HEAP_SIZE];   /* literal and length tree */
+    struct ct_data_s dyn_dtree[2*D_CODES+1]; /* distance tree */
+    struct ct_data_s bl_tree[2*BL_CODES+1];  /* Huffman tree for bit lengths */
+
+    struct tree_desc_s l_desc;               /* desc. for literal tree */
+    struct tree_desc_s d_desc;               /* desc. for distance tree */
+    struct tree_desc_s bl_desc;              /* desc. for bit length tree */
+
+    ush bl_count[MAX_BITS+1];
+    /* number of codes at each bit length for an optimal tree */
+
+    int heap[2*L_CODES+1];      /* heap used to build the Huffman trees */
+    int heap_len;               /* number of elements in the heap */
+    int heap_max;               /* element of largest frequency */
+    /* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used.
+     * The same heap array is used to build all trees.
+     */
+
+    uch depth[2*L_CODES+1];
+    /* Depth of each subtree used as tie breaker for trees of equal frequency
+     */
+
+    uchf *l_buf;          /* buffer for literals or lengths */
+
+    uInt  lit_bufsize;
+    /* Size of match buffer for literals/lengths.  There are 4 reasons for
+     * limiting lit_bufsize to 64K:
+     *   - frequencies can be kept in 16 bit counters
+     *   - if compression is not successful for the first block, all input
+     *     data is still in the window so we can still emit a stored block even
+     *     when input comes from standard input.  (This can also be done for
+     *     all blocks if lit_bufsize is not greater than 32K.)
+     *   - if compression is not successful for a file smaller than 64K, we can
+     *     even emit a stored file instead of a stored block (saving 5 bytes).
+     *     This is applicable only for zip (not gzip or zlib).
+     *   - creating new Huffman trees less frequently may not provide fast
+     *     adaptation to changes in the input data statistics. (Take for
+     *     example a binary file with poorly compressible code followed by
+     *     a highly compressible string table.) Smaller buffer sizes give
+     *     fast adaptation but have of course the overhead of transmitting
+     *     trees more frequently.
+     *   - I can't count above 4
+     */
+
+    uInt last_lit;      /* running index in l_buf */
+
+    ushf *d_buf;
+    /* Buffer for distances. To simplify the code, d_buf and l_buf have
+     * the same number of elements. To use different lengths, an extra flag
+     * array would be necessary.
+     */
+
+    ulg opt_len;        /* bit length of current block with optimal trees */
+    ulg static_len;     /* bit length of current block with static trees */
+    uInt matches;       /* number of string matches in current block */
+    uInt insert;        /* bytes at end of window left to insert */
+
+#ifdef DEBUG
+    ulg compressed_len; /* total bit length of compressed file mod 2^32 */
+    ulg bits_sent;      /* bit length of compressed data sent mod 2^32 */
+#endif
+
+    ush bi_buf;
+    /* Output buffer. bits are inserted starting at the bottom (least
+     * significant bits).
+     */
+    int bi_valid;
+    /* Number of valid bits in bi_buf.  All bits above the last valid bit
+     * are always zero.
+     */
+
+    ulg high_water;
+    /* High water mark offset in window for initialized bytes -- bytes above
+     * this are set to zero in order to avoid memory check warnings when
+     * longest match routines access bytes past the input.  This is then
+     * updated to the new high water mark.
+     */
+
+} FAR deflate_state;
+
+/* Output a byte on the stream.
+ * IN assertion: there is enough room in pending_buf.
+ */
+#define put_byte(s, c) {s->pending_buf[s->pending++] = (c);}
+
+
+#define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1)
+/* Minimum amount of lookahead, except at the end of the input file.
+ * See deflate.c for comments about the MIN_MATCH+1.
+ */
+
+#define MAX_DIST(s)  ((s)->w_size-MIN_LOOKAHEAD)
+/* In order to simplify the code, particularly on 16 bit machines, match
+ * distances are limited to MAX_DIST instead of WSIZE.
+ */
+
+#define WIN_INIT MAX_MATCH
+/* Number of bytes after end of data in window to initialize in order to avoid
+   memory checker errors from longest match routines */
+
+        /* in trees.c */
+void ZLIB_INTERNAL _tr_init OF((deflate_state *s));
+int ZLIB_INTERNAL _tr_tally OF((deflate_state *s, unsigned dist, unsigned lc));
+void ZLIB_INTERNAL _tr_flush_block OF((deflate_state *s, charf *buf,
+                        ulg stored_len, int last));
+void ZLIB_INTERNAL _tr_flush_bits OF((deflate_state *s));
+void ZLIB_INTERNAL _tr_align OF((deflate_state *s));
+void ZLIB_INTERNAL _tr_stored_block OF((deflate_state *s, charf *buf,
+                        ulg stored_len, int last));
+
+#define d_code(dist) \
+   ((dist) < 256 ? _dist_code[dist] : _dist_code[256+((dist)>>7)])
+/* Mapping from a distance to a distance code. dist is the distance - 1 and
+ * must not have side effects. _dist_code[256] and _dist_code[257] are never
+ * used.
+ */
+
+#ifndef DEBUG
+/* Inline versions of _tr_tally for speed: */
+
+#if defined(GEN_TREES_H) || !defined(STDC)
+  extern uch ZLIB_INTERNAL _length_code[];
+  extern uch ZLIB_INTERNAL _dist_code[];
+#else
+  extern const uch ZLIB_INTERNAL _length_code[];
+  extern const uch ZLIB_INTERNAL _dist_code[];
+#endif
+
+# define _tr_tally_lit(s, c, flush) \
+  { uch cc = (c); \
+    s->d_buf[s->last_lit] = 0; \
+    s->l_buf[s->last_lit++] = cc; \
+    s->dyn_ltree[cc].Freq++; \
+    flush = (s->last_lit == s->lit_bufsize-1); \
+   }
+# define _tr_tally_dist(s, distance, length, flush) \
+  { uch len = (length); \
+    ush dist = (distance); \
+    s->d_buf[s->last_lit] = dist; \
+    s->l_buf[s->last_lit++] = len; \
+    dist--; \
+    s->dyn_ltree[_length_code[len]+LITERALS+1].Freq++; \
+    s->dyn_dtree[d_code(dist)].Freq++; \
+    flush = (s->last_lit == s->lit_bufsize-1); \
+  }
+#else
+# define _tr_tally_lit(s, c, flush) flush = _tr_tally(s, 0, c)
+# define _tr_tally_dist(s, distance, length, flush) \
+              flush = _tr_tally(s, distance, length)
+#endif
+
+#endif /* DEFLATE_H */

.ccls-cache/@home@anon@Documents@Code@minecraftconsoles/Minecraft.Client@Common@zlib@gzclose.c

@@ -0,0 +1,25 @@
+/* gzclose.c -- zlib gzclose() function
+ * Copyright (C) 2004, 2010 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+#include "gzguts.h"
+
+/* gzclose() is in a separate file so that it is linked in only if it is used.
+   That way the other gzclose functions can be used instead to avoid linking in
+   unneeded compression or decompression routines. */
+int ZEXPORT gzclose(file)
+    gzFile file;
+{
+#ifndef NO_GZCOMPRESS
+    gz_statep state;
+
+    if (file == NULL)
+        return Z_STREAM_ERROR;
+    state = (gz_statep)file;
+
+    return state->mode == GZ_READ ? gzclose_r(file) : gzclose_w(file);
+#else
+    return gzclose_r(file);
+#endif
+}

.ccls-cache/@home@anon@Documents@Code@minecraftconsoles/Minecraft.Client@Common@zlib@gzguts.h

@@ -0,0 +1,209 @@
+/* gzguts.h -- zlib internal header definitions for gz* operations
+ * Copyright (C) 2004, 2005, 2010, 2011, 2012, 2013 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+#ifdef _LARGEFILE64_SOURCE
+#  ifndef _LARGEFILE_SOURCE
+#    define _LARGEFILE_SOURCE 1
+#  endif
+#  ifdef _FILE_OFFSET_BITS
+#    undef _FILE_OFFSET_BITS
+#  endif
+#endif
+
+#ifdef HAVE_HIDDEN
+#  define ZLIB_INTERNAL __attribute__((visibility ("hidden")))
+#else
+#  define ZLIB_INTERNAL
+#endif
+
+#include <stdio.h>
+#include "zlib.h"
+#ifdef STDC
+#  include <string.h>
+#  include <stdlib.h>
+#  include <limits.h>
+#endif
+#include <fcntl.h>
+
+#ifdef _WIN32
+#  include <stddef.h>
+#endif
+
+#if defined(__TURBOC__) || defined(_MSC_VER) || defined(_WIN32)
+#  include <io.h>
+#endif
+
+#ifdef WINAPI_FAMILY
+#  define open _open
+#  define read _read
+#  define write _write
+#  define close _close
+#endif
+
+#ifdef NO_DEFLATE       /* for compatibility with old definition */
+#  define NO_GZCOMPRESS
+#endif
+
+#if defined(STDC99) || (defined(__TURBOC__) && __TURBOC__ >= 0x550)
+#  ifndef HAVE_VSNPRINTF
+#    define HAVE_VSNPRINTF
+#  endif
+#endif
+
+#if defined(__CYGWIN__)
+#  ifndef HAVE_VSNPRINTF
+#    define HAVE_VSNPRINTF
+#  endif
+#endif
+
+#if defined(MSDOS) && defined(__BORLANDC__) && (BORLANDC > 0x410)
+#  ifndef HAVE_VSNPRINTF
+#    define HAVE_VSNPRINTF
+#  endif
+#endif
+
+#ifndef HAVE_VSNPRINTF
+#  ifdef MSDOS
+/* vsnprintf may exist on some MS-DOS compilers (DJGPP?),
+   but for now we just assume it doesn't. */
+#    define NO_vsnprintf
+#  endif
+#  ifdef __TURBOC__
+#    define NO_vsnprintf
+#  endif
+#  ifdef WIN32
+/* In Win32, vsnprintf is available as the "non-ANSI" _vsnprintf. */
+#    if !defined(vsnprintf) && !defined(NO_vsnprintf)
+#      if !defined(_MSC_VER) || ( defined(_MSC_VER) && _MSC_VER < 1500 )
+#         define vsnprintf _vsnprintf
+#      endif
+#    endif
+#  endif
+#  ifdef __SASC
+#    define NO_vsnprintf
+#  endif
+#  ifdef VMS
+#    define NO_vsnprintf
+#  endif
+#  ifdef __OS400__
+#    define NO_vsnprintf
+#  endif
+#  ifdef __MVS__
+#    define NO_vsnprintf
+#  endif
+#endif
+
+/* unlike snprintf (which is required in C99, yet still not supported by
+   Microsoft more than a decade later!), _snprintf does not guarantee null
+   termination of the result -- however this is only used in gzlib.c where
+   the result is assured to fit in the space provided */
+#ifdef _MSC_VER
+#  define snprintf _snprintf
+#endif
+
+#ifndef local
+#  define local static
+#endif
+/* compile with -Dlocal if your debugger can't find static symbols */
+
+/* gz* functions always use library allocation functions */
+#ifndef STDC
+  extern voidp  malloc OF((uInt size));
+  extern void   free   OF((voidpf ptr));
+#endif
+
+/* get errno and strerror definition */
+#if defined UNDER_CE
+#  include <windows.h>
+#  define zstrerror() gz_strwinerror((DWORD)GetLastError())
+#else
+#  ifndef NO_STRERROR
+#    include <errno.h>
+#    define zstrerror() strerror(errno)
+#  else
+#    define zstrerror() "stdio error (consult errno)"
+#  endif
+#endif
+
+/* provide prototypes for these when building zlib without LFS */
+#if !defined(_LARGEFILE64_SOURCE) || _LFS64_LARGEFILE-0 == 0
+    ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *));
+    ZEXTERN z_off64_t ZEXPORT gzseek64 OF((gzFile, z_off64_t, int));
+    ZEXTERN z_off64_t ZEXPORT gztell64 OF((gzFile));
+    ZEXTERN z_off64_t ZEXPORT gzoffset64 OF((gzFile));
+#endif
+
+/* default memLevel */
+#if MAX_MEM_LEVEL >= 8
+#  define DEF_MEM_LEVEL 8
+#else
+#  define DEF_MEM_LEVEL  MAX_MEM_LEVEL
+#endif
+
+/* default i/o buffer size -- double this for output when reading (this and
+   twice this must be able to fit in an unsigned type) */
+#define GZBUFSIZE 8192
+
+/* gzip modes, also provide a little integrity check on the passed structure */
+#define GZ_NONE 0
+#define GZ_READ 7247
+#define GZ_WRITE 31153
+#define GZ_APPEND 1     /* mode set to GZ_WRITE after the file is opened */
+
+/* values for gz_state how */
+#define LOOK 0      /* look for a gzip header */
+#define COPY 1      /* copy input directly */
+#define GZIP 2      /* decompress a gzip stream */
+
+/* internal gzip file state data structure */
+typedef struct {
+        /* exposed contents for gzgetc() macro */
+    struct gzFile_s x;      /* "x" for exposed */
+                            /* x.have: number of bytes available at x.next */
+                            /* x.next: next output data to deliver or write */
+                            /* x.pos: current position in uncompressed data */
+        /* used for both reading and writing */
+    int mode;               /* see gzip modes above */
+    int fd;                 /* file descriptor */
+    char *path;             /* path or fd for error messages */
+    unsigned size;          /* buffer size, zero if not allocated yet */
+    unsigned want;          /* requested buffer size, default is GZBUFSIZE */
+    unsigned char *in;      /* input buffer */
+    unsigned char *out;     /* output buffer (double-sized when reading) */
+    int direct;             /* 0 if processing gzip, 1 if transparent */
+        /* just for reading */
+    int how;                /* 0: get header, 1: copy, 2: decompress */
+    z_off64_t start;        /* where the gzip data started, for rewinding */
+    int eof;                /* true if end of input file reached */
+    int past;               /* true if read requested past end */
+        /* just for writing */
+    int level;              /* compression level */
+    int strategy;           /* compression strategy */
+        /* seek request */
+    z_off64_t skip;         /* amount to skip (already rewound if backwards) */
+    int seek;               /* true if seek request pending */
+        /* error information */
+    int err;                /* error code */
+    char *msg;              /* error message */
+        /* zlib inflate or deflate stream */
+    z_stream strm;          /* stream structure in-place (not a pointer) */
+} gz_state;
+typedef gz_state FAR *gz_statep;
+
+/* shared functions */
+void ZLIB_INTERNAL gz_error OF((gz_statep, int, const char *));
+#if defined UNDER_CE
+char ZLIB_INTERNAL *gz_strwinerror OF((DWORD error));
+#endif
+
+/* GT_OFF(x), where x is an unsigned value, is true if x > maximum z_off64_t
+   value -- needed when comparing unsigned to z_off64_t, which is signed
+   (possible z_off64_t types off_t, off64_t, and long are all signed) */
+#ifdef INT_MAX
+#  define GT_OFF(x) (sizeof(int) == sizeof(z_off64_t) && (x) > INT_MAX)
+#else
+unsigned ZLIB_INTERNAL gz_intmax OF((void));
+#  define GT_OFF(x) (sizeof(int) == sizeof(z_off64_t) && (x) > gz_intmax())
+#endif