import_std_string_nc.cpp

#include "runtime.h"
// Typeid redirect table
static unsigned __nullcTR[170];
// Function pointer table
static __nullcFunctionArray* __nullcFM;
// Function pointer redirect table
static unsigned __nullcFR[183];

// Type prototypes
struct auto_ref;
struct auto__;
struct char__;
struct auto_ref__;
struct int__;
struct __function__;
struct short__;
struct float__;
struct double__;
struct const_string;
struct __FinalizeProxy;
struct string;

// Type definitions
#pragma pack(push, 4)
struct __typeProxy_void_ref_int_{};
struct __typeProxy_void_ref_int_char___{};
struct __typeProxy_int_ref_char___char___{};
struct __typeProxy_char___ref_char___char___{};
struct __typeProxy_char___ref_char___ref_char___{};
struct __typeProxy_bool_ref_bool_{};
struct __typeProxy_char_ref_char_{};
struct __typeProxy_short_ref_short_{};
struct __typeProxy_int_ref_int_{};
struct __typeProxy_long_ref_long_{};
struct __typeProxy_float_ref_float_{};
struct __typeProxy_double_ref_double_{};
struct __typeProxy_void_ref_bool_{};
struct __typeProxy_void_ref_char_{};
struct __typeProxy_void_ref_short_{};
struct __typeProxy_void_ref_long_{};
struct __typeProxy_void_ref_float_{};
struct __typeProxy_void_ref_double_{};
struct __typeProxy_int_ref_char_{};
struct __typeProxy_int_ref_short_{};
struct __typeProxy_long_ref_int_{};
struct __typeProxy_short_ref_char___{};
struct __typeProxy_void_ref_char___{};
struct __typeProxy_char___ref__{};
struct __typeProxy_int_ref_char___{};
struct __typeProxy_long_ref_char___{};
struct __typeProxy_float_ref_char___{};
struct __typeProxy_char___ref_int_bool_{};
struct __typeProxy_double_ref_char___{};
struct __typeProxy_void_ref_ref_int_int_{};
struct __typeProxy_int___ref_int_int_int_{};
struct __typeProxy_auto_ref_ref_auto_ref_{};
struct __typeProxy_void_ref_auto___ref_auto___{};
struct __typeProxy_auto___ref_auto___{};
struct __typeProxy_auto_ref_ref_auto_ref_auto_ref_{};
struct __typeProxy_void_ref_auto_ref_auto_ref_{};
struct __typeProxy_int_ref_auto_ref_auto_ref_{};
struct __typeProxy_void_ref_auto___auto___{};
struct __typeProxy_void_ref__{};
struct __typeProxy_void_ref___ref_auto_ref___function___ref_{};
struct __typeProxy_auto_ref_char___ref_int___{};
struct __typeProxy_char___ref_ref_char___ref_int___{};
struct __typeProxy_auto_ref_short___ref_int___{};
struct __typeProxy_short___ref_ref_short___ref_int___{};
struct __typeProxy_auto_ref_float___ref_double___{};
struct __typeProxy_float___ref_ref_float___ref_double___{};
struct __typeProxy_typeid_ref_auto_ref_{};
struct __typeProxy_int_ref__{};
struct __typeProxy_int_ref_typeid_typeid_{};
struct __typeProxy_bool_ref_auto_ref_auto_ref_{};
struct __typeProxy_int_ref_auto_ref_{};
struct __typeProxy_int_ref_void_ref_int__void_ref_int__{};
struct __typeProxy_int_ref_auto___auto___{};
struct __typeProxy_auto___ref_ref_auto___ref_auto_ref_{};
struct __typeProxy_auto_ref_ref_auto_ref_auto___ref_{};
struct __typeProxy_auto_ref_ref_auto___ref_int_{};
struct const_string
{
	NULLCArray< char > arr;
};
struct __typeProxy_auto_ref_const_string_ref_char___{};
struct __typeProxy_const_string_ref_ref_const_string_ref_char___{};
struct __typeProxy_const_string_ref_char___{};
struct __typeProxy_char_ref_const_string_ref_int_{};
struct __typeProxy_int_ref_const_string_const_string_{};
struct __typeProxy_int_ref_const_string_char___{};
struct __typeProxy_int_ref_char___const_string_{};
struct __typeProxy_const_string_ref_const_string_const_string_{};
struct __typeProxy_const_string_ref_const_string_char___{};
struct __typeProxy_const_string_ref_char___const_string_{};
struct __typeProxy_void_ref_auto___ref_typeid_int_{};
struct __typeProxy_auto___ref_typeid_int_{};
struct __typeProxy_void_ref_auto_ref_int_{};
struct __typeProxy_void_ref_auto___ref_int_{};
struct __typeProxy_void_ref_auto_ref_{};
struct __typeProxy_auto_ref___ref__{};
struct __FinalizeProxy
{
};
struct __typeProxy_void_ref_ref_void_ref_typeid_{};
struct __typeProxy_void_ref_void_ref_ref_void_ref_int_int_{};
struct __typeProxy_bool_ref__{};
struct __typeProxy_int_ref_char___char_{};
struct string
{
	NULLCArray< char > data;
};
struct __typeProxy_void_ref_int_char_{};
struct __typeProxy_void_ref_string_ref_{};
struct __typeProxy_string_ref_ref_string_ref_string_ref_{};
struct __typeProxy_string_ref_ref_string_ref_char___{};
struct __typeProxy_string_ref_ref_string_ref_char_{};
struct __typeProxy_char_ref_ref_string_ref_int_{};
struct __typeProxy_string_ref_string_ref_int_int_{};
struct __typeProxy_char_ref_ref__{};
struct __typeProxy_string_ref_ref_int_string_ref_{};
struct __typeProxy_string_ref_ref_int_char___{};
struct __typeProxy_string_ref_ref_int_int_char_{};
struct __typeProxy_string_ref_ref_int_int_{};
struct __typeProxy_string_ref_ref_int_int_string_ref_{};
struct __typeProxy_string_ref_ref_int_int_char___{};
struct __typeProxy_string_ref_ref_int_int_int_char_{};
struct __typeProxy_int_ref_string_ref_int_{};
struct __typeProxy_int_ref_char___int_{};
struct __typeProxy_int_ref_char_int_{};
struct __typeProxy_bool_ref_char_string_ref_{};
struct __typeProxy_string_ref_int_int_{};
struct __typeProxy_string_ref_string_ref_string_ref_{};
struct __typeProxy_string_ref_char___string_ref_{};
struct __typeProxy_string_ref_string_ref_char___{};
struct __typeProxy_bool_ref_string_ref_string_ref_{};
struct __typeProxy_bool_ref_string_ref_char___{};
struct __typeProxy_bool_ref_char___string_ref_{};
#pragma pack(pop)

// Function prototypes
void assert_void_ref_int_(int val, void* __context);
void assert_void_ref_int_char___(int val, NULLCArray< char > message, void* __context);
int __operatorEqual_int_ref_char___char___(NULLCArray< char > a, NULLCArray< char > b, void* __context);
int __operatorNEqual_int_ref_char___char___(NULLCArray< char > a, NULLCArray< char > b, void* __context);
NULLCArray< char > __operatorAdd_char___ref_char___char___(NULLCArray< char > a, NULLCArray< char > b, void* __context);
NULLCArray< char > __operatorAddSet_char___ref_char___ref_char___(NULLCArray< char >* a, NULLCArray< char > b, void* __context);
bool bool_bool_ref_bool_(bool a, void* __context);
char char_char_ref_char_(char a, void* __context);
short short_short_ref_short_(short a, void* __context);
int int_int_ref_int_(int a, void* __context);
long long long_long_ref_long_(long long a, void* __context);
float float_float_ref_float_(float a, void* __context);
double double_double_ref_double_(double a, void* __context);
void bool__bool_void_ref_bool_(bool a, bool* __context);
void char__char_void_ref_char_(char a, char* __context);
void short__short_void_ref_short_(short a, short* __context);
void int__int_void_ref_int_(int a, int* __context);
void long__long_void_ref_long_(long long a, long long* __context);
void float__float_void_ref_float_(float a, float* __context);
void double__double_void_ref_double_(double a, double* __context);
int as_unsigned_int_ref_char_(char a, void* __context);
int as_unsigned_int_ref_short_(short a, void* __context);
long long as_unsigned_long_ref_int_(int a, void* __context);
short short_short_ref_char___(NULLCArray< char > str, void* __context);
void short__short_void_ref_char___(NULLCArray< char > str, short* __context);
NULLCArray< char > short__str_char___ref__(short* __context);
int int_int_ref_char___(NULLCArray< char > str, void* __context);
void int__int_void_ref_char___(NULLCArray< char > str, int* __context);
NULLCArray< char > int__str_char___ref__(int* __context);
long long long_long_ref_char___(NULLCArray< char > str, void* __context);
void long__long_void_ref_char___(NULLCArray< char > str, long long* __context);
NULLCArray< char > long__str_char___ref__(long long* __context);
float float_float_ref_char___(NULLCArray< char > str, void* __context);
void float__float_void_ref_char___(NULLCArray< char > str, float* __context);
NULLCArray< char > float__str_char___ref_int_bool_(int precision, bool showExponent, float* __context);
double double_double_ref_char___(NULLCArray< char > str, void* __context);
void double__double_void_ref_char___(NULLCArray< char > str, double* __context);
NULLCArray< char > double__str_char___ref_int_bool_(int precision, bool showExponent, double* __context);
void* __newS_void_ref_ref_int_int_(int size, int type, void* __context);
NULLCArray< int > __newA_int___ref_int_int_int_(int size, int count, int type, void* __context);
NULLCRef duplicate_auto_ref_ref_auto_ref_(NULLCRef obj, void* __context);
void __duplicate_array_void_ref_auto___ref_auto___(NULLCAutoArray* dst, NULLCAutoArray src, void* __context);
NULLCAutoArray duplicate_auto___ref_auto___(NULLCAutoArray arr, void* __context);
NULLCRef replace_auto_ref_ref_auto_ref_auto_ref_(NULLCRef l, NULLCRef r, void* __context);
void swap_void_ref_auto_ref_auto_ref_(NULLCRef l, NULLCRef r, void* __context);
int equal_int_ref_auto_ref_auto_ref_(NULLCRef l, NULLCRef r, void* __context);
void assign_void_ref_auto_ref_auto_ref_(NULLCRef l, NULLCRef r, void* __context);
void array_copy_void_ref_auto___auto___(NULLCAutoArray l, NULLCAutoArray r, void* __context);
NULLCFuncPtr<__typeProxy_void_ref__> __redirect_void_ref___ref_auto_ref___function___ref_(NULLCRef r, NULLCArray< __function >* f, void* __context);
NULLCFuncPtr<__typeProxy_void_ref__> __redirect_ptr_void_ref___ref_auto_ref___function___ref_(NULLCRef r, NULLCArray< __function >* f, void* __context);
NULLCArray< char >* __operatorSet_char___ref_ref_char___ref_int___(NULLCArray< char >* dst, NULLCArray< int > src, void* __context);
NULLCArray< short >* __operatorSet_short___ref_ref_short___ref_int___(NULLCArray< short >* dst, NULLCArray< int > src, void* __context);
NULLCArray< float >* __operatorSet_float___ref_ref_float___ref_double___(NULLCArray< float >* dst, NULLCArray< double > src, void* __context);
unsigned typeid_typeid_ref_auto_ref_(NULLCRef type, void* __context);
int typeid__size__int_ref___(unsigned* __context);
int __operatorEqual_int_ref_typeid_typeid_(unsigned a, unsigned b, void* __context);
int __operatorNEqual_int_ref_typeid_typeid_(unsigned a, unsigned b, void* __context);
int __rcomp_int_ref_auto_ref_auto_ref_(NULLCRef a, NULLCRef b, void* __context);
int __rncomp_int_ref_auto_ref_auto_ref_(NULLCRef a, NULLCRef b, void* __context);
bool __operatorLess_bool_ref_auto_ref_auto_ref_(NULLCRef a, NULLCRef b, void* __context);
bool __operatorLEqual_bool_ref_auto_ref_auto_ref_(NULLCRef a, NULLCRef b, void* __context);
bool __operatorGreater_bool_ref_auto_ref_auto_ref_(NULLCRef a, NULLCRef b, void* __context);
bool __operatorGEqual_bool_ref_auto_ref_auto_ref_(NULLCRef a, NULLCRef b, void* __context);
int hash_value_int_ref_auto_ref_(NULLCRef x, void* __context);
int __pcomp_int_ref_void_ref_int__void_ref_int__(NULLCFuncPtr<__typeProxy_void_ref_int_> a, NULLCFuncPtr<__typeProxy_void_ref_int_> b, void* __context);
int __pncomp_int_ref_void_ref_int__void_ref_int__(NULLCFuncPtr<__typeProxy_void_ref_int_> a, NULLCFuncPtr<__typeProxy_void_ref_int_> b, void* __context);
int __acomp_int_ref_auto___auto___(NULLCAutoArray a, NULLCAutoArray b, void* __context);
int __ancomp_int_ref_auto___auto___(NULLCAutoArray a, NULLCAutoArray b, void* __context);
int __typeCount_int_ref__(void* __context);
NULLCAutoArray* __operatorSet_auto___ref_ref_auto___ref_auto_ref_(NULLCAutoArray* l, NULLCRef r, void* __context);
NULLCRef __aaassignrev_auto_ref_ref_auto_ref_auto___ref_(NULLCRef l, NULLCAutoArray* r, void* __context);
NULLCRef __operatorIndex_auto_ref_ref_auto___ref_int_(NULLCAutoArray* l, int index, void* __context);
int const_string__size__int_ref___(const_string* __context);
const_string* __operatorSet_const_string_ref_ref_const_string_ref_char___(const_string* l, NULLCArray< char > arr, void* __context);
const_string const_string_const_string_ref_char___(NULLCArray< char > arr, void* __context);
char __operatorIndex_char_ref_const_string_ref_int_(const_string* l, int index, void* __context);
int __operatorEqual_int_ref_const_string_const_string_(const_string a, const_string b, void* __context);
int __operatorEqual_int_ref_const_string_char___(const_string a, NULLCArray< char > b, void* __context);
int __operatorEqual_int_ref_char___const_string_(NULLCArray< char > a, const_string b, void* __context);
int __operatorNEqual_int_ref_const_string_const_string_(const_string a, const_string b, void* __context);
int __operatorNEqual_int_ref_const_string_char___(const_string a, NULLCArray< char > b, void* __context);
int __operatorNEqual_int_ref_char___const_string_(NULLCArray< char > a, const_string b, void* __context);
const_string __operatorAdd_const_string_ref_const_string_const_string_(const_string a, const_string b, void* __context);
const_string __operatorAdd_const_string_ref_const_string_char___(const_string a, NULLCArray< char > b, void* __context);
const_string __operatorAdd_const_string_ref_char___const_string_(NULLCArray< char > a, const_string b, void* __context);
int isStackPointer_int_ref_auto_ref_(NULLCRef x, void* __context);
void auto_array_impl_void_ref_auto___ref_typeid_int_(NULLCAutoArray* arr, unsigned type, int count, void* __context);
NULLCAutoArray auto_array_auto___ref_typeid_int_(unsigned type, int count, void* __context);
void auto____set_void_ref_auto_ref_int_(NULLCRef x, int pos, NULLCAutoArray* __context);
void __force_size_void_ref_auto___ref_int_(NULLCAutoArray* s, int size, void* __context);
int isCoroutineReset_int_ref_auto_ref_(NULLCRef f, void* __context);
void __assertCoroutine_void_ref_auto_ref_(NULLCRef f, void* __context);
NULLCArray< NULLCRef > __getFinalizeList_auto_ref___ref__(void* __context);
void __FinalizeProxy__finalize_void_ref__(__FinalizeProxy* __context);
void __finalizeObjects_void_ref__(void* __context);
void* assert_derived_from_base_void_ref_ref_void_ref_typeid_(void* derived, unsigned base, void* __context);
void __closeUpvalue_void_ref_void_ref_ref_void_ref_int_int_(void** l, void* v, int offset, int size, void* __context);
int float__str_610894668_precision__int_ref___(void* __context);
bool float__str_610894668_showExponent__bool_ref___(void* __context);
int double__str_610894668_precision__int_ref___(void* __context);
bool double__str_610894668_showExponent__bool_ref___(void* __context);
int strstr_int_ref_char___char___(NULLCArray< char > string, NULLCArray< char > substring, void* __context);
int strchr_int_ref_char___char_(NULLCArray< char > string, char ch, void* __context);
int strcmp_int_ref_char___char___(NULLCArray< char > a, NULLCArray< char > b, void* __context);
void string__string_void_ref__(string* __context);
void string__string_void_ref_char___(NULLCArray< char > right, string* __context);
void string__string_void_ref_int_char_(int count, char ch, string* __context);
void string__string_void_ref_string_ref_(string* data, string* __context);
string* __operatorSet_string_ref_ref_string_ref_string_ref_(string* left, string* right, void* __context);
string* __operatorSet_string_ref_ref_string_ref_char___(string* left, NULLCArray< char > right, void* __context);
string* __operatorSet_string_ref_ref_string_ref_char_(string* left, char right, void* __context);
int string__size__int_ref___(string* __context);
int string__length_int_ref__(string* __context);
void string__clear_void_ref__(string* __context);
bool string__empty_bool_ref__(string* __context);
char* __operatorIndex_char_ref_ref_string_ref_int_(string* left, int index, void* __context);
string __operatorIndex_string_ref_string_ref_int_int_(string* left, int start, int end, void* __context);
char* string__front_char_ref_ref__(string* __context);
char* string__back_char_ref_ref__(string* __context);
string* __operatorAddSet_string_ref_ref_string_ref_string_ref_(string* left, string* right, void* __context);
string* __operatorAddSet_string_ref_ref_string_ref_char___(string* left, NULLCArray< char > right, void* __context);
string* string__insert_string_ref_ref_int_string_ref_(int offset, string* str, string* __context);
string* string__insert_string_ref_ref_int_char___(int offset, NULLCArray< char > str, string* __context);
string* string__insert_string_ref_ref_int_int_char_(int offset, int count, char ch, string* __context);
string* string__erase_string_ref_ref_int_int_(int offset, int length, string* __context);
string* string__replace_string_ref_ref_int_int_string_ref_(int offset, int length, string* str, string* __context);
string* string__replace_string_ref_ref_int_int_char___(int offset, int length, NULLCArray< char > str, string* __context);
string* string__replace_string_ref_ref_int_int_int_char_(int offset, int length, int count, char ch, string* __context);
void string__swap_void_ref_string_ref_(string* right, string* __context);
void string__swap_void_ref_char___(NULLCArray< char > right, string* __context);
int string__find_int_ref_string_ref_int_(string* str, int offset, string* __context);
int string__find_int_ref_char___int_(NULLCArray< char > str, int offset, string* __context);
int string__find_int_ref_char_int_(char ch, int offset, string* __context);
int string__rfind_int_ref_string_ref_int_(string* str, int offset, string* __context);
int string__rfind_int_ref_char___int_(NULLCArray< char > str, int offset, string* __context);
int string__rfind_int_ref_char_int_(char ch, int offset, string* __context);
int string__find_first_of_int_ref_string_ref_int_(string* str, int offset, string* __context);
int string__find_first_of_int_ref_char___int_(NULLCArray< char > str, int offset, string* __context);
int string__find_first_of_int_ref_char_int_(char ch, int offset, string* __context);
int string__find_last_of_int_ref_string_ref_int_(string* str, int offset, string* __context);
int string__find_last_of_int_ref_char___int_(NULLCArray< char > str, int offset, string* __context);
int string__find_last_of_int_ref_char_int_(char ch, int offset, string* __context);
int string__find_first_not_of_int_ref_string_ref_int_(string* str, int offset, string* __context);
int string__find_first_not_of_int_ref_char___int_(NULLCArray< char > str, int offset, string* __context);
int string__find_first_not_of_int_ref_char_int_(char ch, int offset, string* __context);
int string__find_last_not_of_int_ref_string_ref_int_(string* str, int offset, string* __context);
int string__find_last_not_of_int_ref_char___int_(NULLCArray< char > str, int offset, string* __context);
int string__find_last_not_of_int_ref_char_int_(char ch, int offset, string* __context);
bool in_bool_ref_char_string_ref_(char ch, string* str, void* __context);
string string__substr_string_ref_int_int_(int start, int length, string* __context);
string __operatorAdd_string_ref_string_ref_string_ref_(string* left, string* right, void* __context);
string __operatorAdd_string_ref_char___string_ref_(NULLCArray< char > left, string* right, void* __context);
string __operatorAdd_string_ref_string_ref_char___(string* left, NULLCArray< char > right, void* __context);
bool __operatorEqual_bool_ref_string_ref_string_ref_(string* left, string* right, void* __context);
bool __operatorEqual_bool_ref_string_ref_char___(string* left, NULLCArray< char > right, void* __context);
bool __operatorEqual_bool_ref_char___string_ref_(NULLCArray< char > left, string* right, void* __context);
bool __operatorNEqual_bool_ref_string_ref_string_ref_(string* left, string* right, void* __context);
bool __operatorNEqual_bool_ref_string_ref_char___(string* left, NULLCArray< char > right, void* __context);
bool __operatorNEqual_bool_ref_char___string_ref_(NULLCArray< char > left, string* right, void* __context);
int string__erase_3081620873_length__int_ref___(void* __context);
int string__find_2424387209_offset__int_ref___(void* __context);
int string__find_1089031307_offset__int_ref___(void* __context);
int string__find_28588211_offset__int_ref___(void* __context);
int string__rfind_2424387209_offset__int_ref___(void* __context);
int string__rfind_1089031307_offset__int_ref___(void* __context);
int string__rfind_28588211_offset__int_ref___(void* __context);
int string__find_first_of_2424387209_offset__int_ref___(void* __context);
int string__find_first_of_1089031307_offset__int_ref___(void* __context);
int string__find_first_of_28588211_offset__int_ref___(void* __context);
int string__find_last_of_2424387209_offset__int_ref___(void* __context);
int string__find_last_of_1089031307_offset__int_ref___(void* __context);
int string__find_last_of_28588211_offset__int_ref___(void* __context);
int string__find_first_not_of_2424387209_offset__int_ref___(void* __context);
int string__find_first_not_of_1089031307_offset__int_ref___(void* __context);
int string__find_first_not_of_28588211_offset__int_ref___(void* __context);
int string__find_last_not_of_2424387209_offset__int_ref___(void* __context);
int string__find_last_not_of_1089031307_offset__int_ref___(void* __context);
int string__find_last_not_of_28588211_offset__int_ref___(void* __context);
int string__substr_536940012_length__int_ref___(void* __context);

// Global variables
extern NULLCArray< __function > __vtbl3761170085finalize;

// Function definitions
void string__string_void_ref__(string* __context)
{
	return;;
}

void string__string_void_ref_char___(NULLCArray< char > right, string* __context)
{
	NULLCAutoArray __temp0;
	if((*(&(&right)->size)) > (1))
	{
		__aaassignrev_auto_ref_ref_auto_ref_auto___ref_(__nullcMakeAutoRef(&(__context)->data, __nullcTR[17]), (
			/* Definition of variable '$temp0' */*(&__temp0) = (duplicate_auto___ref_auto___(__makeAutoArray(__nullcTR[2], right), (void*)0)), 
			&__temp0
		), (void*)0);
	}
;
	return;;
}

void string__string_void_ref_int_char_(int count, char ch, string* __context)
{
	int i_296;
	assert_void_ref_int_((int)((count) >= (0)), (void*)0);
	if((count) > (0))
	{
		{
			*(&(__context)->data) = (__newA_int___ref_int_int_int_(1, (count) + (1), (int)(__nullcTR[2]), (void*)0));
			/* Definition of variable 'i' */*(&i_296) = (0);
			while((i_296) < (count))
			{
				*(__nullcIndexUnsizedArray(*(&(__context)->data), i_296)) = (ch);
continue_1:;
				// Increment
				{
					/*empty sequence*/;
					(*(&i_296))++;
				};
			}
break_1:
			;
			// Closures
			/*empty sequence*/;
		};
	}
;
	return;;
}

void string__string_void_ref_string_ref_(string* data, string* __context)
{
	NULLCAutoArray __temp1;
	__aaassignrev_auto_ref_ref_auto_ref_auto___ref_(__nullcMakeAutoRef(&(__context)->data, __nullcTR[17]), (
		/* Definition of variable '$temp1' */*(&__temp1) = (duplicate_auto___ref_auto___(__makeAutoArray(__nullcTR[2], *(&(data)->data)), (void*)0)), 
		&__temp1
	), (void*)0);
	return;;
}

string* __operatorSet_string_ref_ref_string_ref_string_ref_(string* left, string* right, void* __context)
{
	NULLCAutoArray __temp2;
	string* __nullcReturnValue_5;
	__aaassignrev_auto_ref_ref_auto_ref_auto___ref_(__nullcMakeAutoRef(&(left)->data, __nullcTR[17]), (
		/* Definition of variable '$temp2' */*(&__temp2) = (duplicate_auto___ref_auto___(__makeAutoArray(__nullcTR[2], *(&(right)->data)), (void*)0)), 
		&__temp2
	), (void*)0);
	return left;;
}

string* __operatorSet_string_ref_ref_string_ref_char___(string* left, NULLCArray< char > right, void* __context)
{
	NULLCAutoArray __temp3;
	string* __nullcReturnValue_6;
	if((*(&(&right)->size)) > (1))
	{
		__aaassignrev_auto_ref_ref_auto_ref_auto___ref_(__nullcMakeAutoRef(&(left)->data, __nullcTR[17]), (
			/* Definition of variable '$temp3' */*(&__temp3) = (duplicate_auto___ref_auto___(__makeAutoArray(__nullcTR[2], right), (void*)0)), 
			&__temp3
		), (void*)0);
	}
	else
	{
		__operatorSet_char___ref_ref_char___ref_int___(&(left)->data, NULLCArray< int >(), (void*)0);
	}
;
	return left;;
}

string* __operatorSet_string_ref_ref_string_ref_char_(string* left, char right, void* __context)
{
	string* __nullcReturnValue_7;
	*(&(left)->data) = (__newA_int___ref_int_int_int_(1, 2, (int)(__nullcTR[2]), (void*)0));
	*(__nullcIndexUnsizedArray(*(&(left)->data), 0)) = (right);
	return left;;
}

int string__size__int_ref___(string* __context)
{
	int __nullcReturnValue_8;
	return (*(&(&(__context)->data)->size)) ? ((*(&(&(__context)->data)->size)) - (1)) : (0);;
}

int string__length_int_ref__(string* __context)
{
	int __nullcReturnValue_9;
	return (*(&(&(__context)->data)->size)) ? ((*(&(&(__context)->data)->size)) - (1)) : (0);;
}

void string__clear_void_ref__(string* __context)
{
	__operatorSet_char___ref_ref_char___ref_int___(&(__context)->data, NULLCArray< int >(), (void*)0);
	return;;
}

bool string__empty_bool_ref__(string* __context)
{
	bool __nullcReturnValue_11;
	return (*(&(&(__context)->data)->size)) == (0);;
}

char* __operatorIndex_char_ref_ref_string_ref_int_(string* left, int index, void* __context)
{
	char* __nullcReturnValue_12;
	return __nullcIndexUnsizedArray(*(&(left)->data), index);;
}

string __operatorIndex_string_ref_string_ref_int_int_(string* left, int start, int end, void* __context)
{
	NULLCArray< char > buf;
	int i_330;
	string res;
	string __nullcReturnValue_13;
	assert_void_ref_int_((int)(((start) == (0)) || (((start) > (0)) && ((start) < ((*(&(&(left)->data)->size)) - (1))))), (void*)0);
	assert_void_ref_int_((int)(((end) == (0)) || (((end) > (0)) && ((end) < ((*(&(&(left)->data)->size)) - (1))))), (void*)0);
	assert_void_ref_int_((int)((start) <= (end)), (void*)0);
	/* Definition of variable 'buf' */*(&buf) = (__newA_int___ref_int_int_int_(1, ((end) - (start)) + (2), (int)(__nullcTR[2]), (void*)0));
	/* Definition of variable 'i' */*(&i_330) = (start);
	while((i_330) <= (end))
	{
		*(__nullcIndexUnsizedArray(buf, (i_330) - (start))) = (*(__nullcIndexUnsizedArray(*(&(left)->data), i_330)));
continue_2:;
		// Increment
		{
			/*empty sequence*/;
			(*(&i_330))++;
		};
	}
break_2:
	;
	/* Definition of variable 'res' */string__string_void_ref__(&res);
	*(&(&res)->data) = (buf);
	return res;;
}

char* string__front_char_ref_ref__(string* __context)
{
	char* __nullcReturnValue_14;
	return __nullcIndexUnsizedArray(*(&(__context)->data), 0);;
}

char* string__back_char_ref_ref__(string* __context)
{
	char* __nullcReturnValue_15;
	return __nullcIndexUnsizedArray(*(&(__context)->data), (*(&(&(__context)->data)->size)) - (2));;
}

string* __operatorAddSet_string_ref_ref_string_ref_string_ref_(string* left, string* right, void* __context)
{
	string* __nullcReturnValue_16;
	*(&(left)->data) = (__operatorAdd_char___ref_char___char___(*(&(left)->data), *(&(right)->data), (void*)0));
	return left;;
}

string* __operatorAddSet_string_ref_ref_string_ref_char___(string* left, NULLCArray< char > right, void* __context)
{
	string* __nullcReturnValue_17;
	*(&(left)->data) = (__operatorAdd_char___ref_char___char___(*(&(left)->data), right, (void*)0));
	return left;;
}

string* string__insert_string_ref_ref_int_string_ref_(int offset, string* str, string* __context)
{
	NULLCAutoArray __temp4_346;
	NULLCArray< char > buf;
	int i_348;
	int i_349;
	int i_350;
	string* __nullcReturnValue_18;
	if((string__size__int_ref___(str)) == (0))
	{
		return __context;;
	}
;
	assert_void_ref_int_((int)(((offset) == (0)) || (((offset) > (0)) && ((offset) < (*(&(&(__context)->data)->size))))), (void*)0);
	if((string__size__int_ref___(__context)) == (0))
	{
		{
			__aaassignrev_auto_ref_ref_auto_ref_auto___ref_(__nullcMakeAutoRef(&(__context)->data, __nullcTR[17]), (
				/* Definition of variable '$temp4' */*(&__temp4_346) = (duplicate_auto___ref_auto___(__makeAutoArray(__nullcTR[2], *(&(str)->data)), (void*)0)), 
				&__temp4_346
			), (void*)0);
			return __context;;
			// Closures
			/*empty sequence*/;
		};
	}
;
	/* Definition of variable 'buf' */*(&buf) = (__newA_int___ref_int_int_int_(1, ((*(&(&(__context)->data)->size)) + (*(&(&(str)->data)->size))) - (1), (int)(__nullcTR[2]), (void*)0));
	/* Definition of variable 'i' */*(&i_348) = (0);
	while((i_348) < (offset))
	{
		*(__nullcIndexUnsizedArray(buf, i_348)) = (*(__nullcIndexUnsizedArray(*(&(__context)->data), i_348)));
continue_3:;
		// Increment
		{
			/*empty sequence*/;
			(*(&i_348))++;
		};
	}
break_3:
	;
	/* Definition of variable 'i' */*(&i_349) = (0);
	while((i_349) < ((*(&(&(str)->data)->size)) - (1)))
	{
		*(__nullcIndexUnsizedArray(buf, (i_349) + (offset))) = (*(__nullcIndexUnsizedArray(*(&(str)->data), i_349)));
continue_4:;
		// Increment
		{
			/*empty sequence*/;
			(*(&i_349))++;
		};
	}
break_4:
	;
	/* Definition of variable 'i' */*(&i_350) = (offset);
	while((i_350) < ((*(&(&(__context)->data)->size)) - (1)))
	{
		*(__nullcIndexUnsizedArray(buf, ((i_350) + (*(&(&(str)->data)->size))) - (1))) = (*(__nullcIndexUnsizedArray(*(&(__context)->data), i_350)));
continue_5:;
		// Increment
		{
			/*empty sequence*/;
			(*(&i_350))++;
		};
	}
break_5:
	;
	*(&(__context)->data) = (buf);
	return __context;;
}

string* string__insert_string_ref_ref_int_char___(int offset, NULLCArray< char > str, string* __context)
{
	string __temp5;
	string __temp6;
	string* __nullcReturnValue_19;
	return string__insert_string_ref_ref_int_string_ref_(offset, (
		/* Definition of variable '$temp6' */*(&__temp6) = ((
			/* Definition of variable '$temp5' */0, 
			string__string_void_ref_char___(str, &__temp5), 
			__temp5
		)), 
		&__temp6
	), __context);;
}

string* string__insert_string_ref_ref_int_int_char_(int offset, int count, char ch, string* __context)
{
	string __temp7;
	string __temp8;
	string* __nullcReturnValue_20;
	return string__insert_string_ref_ref_int_string_ref_(offset, (
		/* Definition of variable '$temp8' */*(&__temp8) = ((
			/* Definition of variable '$temp7' */0, 
			string__string_void_ref_int_char_(count, ch, &__temp7), 
			__temp7
		)), 
		&__temp8
	), __context);;
}

string* string__erase_string_ref_ref_int_int_(int offset, int length, string* __context)
{
	NULLCArray< char > buf;
	int i_371;
	int i_372;
	string* __nullcReturnValue_21;
	if(((length) < (0)) || ((length) > ((*(&(&(__context)->data)->size)) - (offset))))
	{
		*(&length) = (((*(&(&(__context)->data)->size)) - (offset)) - (1));
	}
;
	if((length) == (0))
	{
		return __context;;
	}
;
	assert_void_ref_int_((int)(((offset) == (0)) || (((offset) > (0)) && ((offset) < (*(&(&(__context)->data)->size))))), (void*)0);
	if((string__size__int_ref___(__context)) == (0))
	{
		return __context;;
	}
;
	/* Definition of variable 'buf' */*(&buf) = (__newA_int___ref_int_int_int_(1, (*(&(&(__context)->data)->size)) - (length), (int)(__nullcTR[2]), (void*)0));
	/* Definition of variable 'i' */*(&i_371) = (0);
	while((i_371) < (offset))
	{
		*(__nullcIndexUnsizedArray(buf, i_371)) = (*(__nullcIndexUnsizedArray(*(&(__context)->data), i_371)));
continue_6:;
		// Increment
		{
			/*empty sequence*/;
			(*(&i_371))++;
		};
	}
break_6:
	;
	/* Definition of variable 'i' */*(&i_372) = ((offset) + (length));
	while((i_372) < (*(&(&(__context)->data)->size)))
	{
		*(__nullcIndexUnsizedArray(buf, (i_372) - (length))) = (*(__nullcIndexUnsizedArray(*(&(__context)->data), i_372)));
continue_7:;
		// Increment
		{
			/*empty sequence*/;
			(*(&i_372))++;
		};
	}
break_7:
	;
	*(&(__context)->data) = (buf);
	return __context;;
}

string* string__replace_string_ref_ref_int_int_string_ref_(int offset, int length, string* str, string* __context)
{
	NULLCArray< char > buf;
	int i_381;
	int i_382;
	int i_383;
	string* __nullcReturnValue_22;
	assert_void_ref_int_((int)(((offset) == (0)) || (((offset) > (0)) && ((offset) < (*(&(&(__context)->data)->size))))), (void*)0);
	if(((length) < (0)) || ((length) >= ((*(&(&(__context)->data)->size)) - (offset))))
	{
		*(&length) = (((*(&(&(__context)->data)->size)) - (offset)) - (1));
	}
;
	/* Definition of variable 'buf' */*(&buf) = (__newA_int___ref_int_int_int_(1, (((*(&(&(__context)->data)->size)) - (length)) + (*(&(&(str)->data)->size))) - (1), (int)(__nullcTR[2]), (void*)0));
	/* Definition of variable 'i' */*(&i_381) = (0);
	while((i_381) < (offset))
	{
		*(__nullcIndexUnsizedArray(buf, i_381)) = (*(__nullcIndexUnsizedArray(*(&(__context)->data), i_381)));
continue_8:;
		// Increment
		{
			/*empty sequence*/;
			(*(&i_381))++;
		};
	}
break_8:
	;
	/* Definition of variable 'i' */*(&i_382) = (0);
	while((i_382) < ((*(&(&(str)->data)->size)) - (1)))
	{
		*(__nullcIndexUnsizedArray(buf, (i_382) + (offset))) = (*(__nullcIndexUnsizedArray(*(&(str)->data), i_382)));
continue_9:;
		// Increment
		{
			/*empty sequence*/;
			(*(&i_382))++;
		};
	}
break_9:
	;
	/* Definition of variable 'i' */*(&i_383) = ((offset) + (length));
	while((i_383) < ((*(&(&(__context)->data)->size)) - (1)))
	{
		*(__nullcIndexUnsizedArray(buf, (((i_383) - (length)) + (*(&(&(str)->data)->size))) - (1))) = (*(__nullcIndexUnsizedArray(*(&(__context)->data), i_383)));
continue_10:;
		// Increment
		{
			/*empty sequence*/;
			(*(&i_383))++;
		};
	}
break_10:
	;
	*(&(__context)->data) = (buf);
	return __context;;
}

string* string__replace_string_ref_ref_int_int_char___(int offset, int length, NULLCArray< char > str, string* __context)
{
	string __temp9;
	string __temp10;
	string* __nullcReturnValue_23;
	return string__replace_string_ref_ref_int_int_string_ref_(offset, length, (
		/* Definition of variable '$temp10' */*(&__temp10) = ((
			/* Definition of variable '$temp9' */0, 
			string__string_void_ref_char___(str, &__temp9), 
			__temp9
		)), 
		&__temp10
	), __context);;
}

string* string__replace_string_ref_ref_int_int_int_char_(int offset, int length, int count, char ch, string* __context)
{
	string __temp11;
	string __temp12;
	string* __nullcReturnValue_24;
	return string__replace_string_ref_ref_int_int_string_ref_(offset, length, (
		/* Definition of variable '$temp12' */*(&__temp12) = ((
			/* Definition of variable '$temp11' */0, 
			string__string_void_ref_int_char_(count, ch, &__temp11), 
			__temp11
		)), 
		&__temp12
	), __context);;
}

void string__swap_void_ref_string_ref_(string* right, string* __context)
{
	NULLCArray< char > tmp;
	/* Definition of variable 'tmp' */*(&tmp) = (*(&(__context)->data));
	*(&(__context)->data) = (*(&(right)->data));
	*(&(right)->data) = (tmp);
	return;;
}

void string__swap_void_ref_char___(NULLCArray< char > right, string* __context)
{
	*(&(__context)->data) = (right);
	return;;
}

int string__find_int_ref_string_ref_int_(string* str, int offset, string* __context)
{
	int last;
	int i_416;
	bool wrong_417;
	int k_418;
	int __nullcReturnValue_27;
	/* Definition of variable 'last' */*(&last) = (((*(&(&(__context)->data)->size)) - (*(&(&(str)->data)->size))) + (1));
	/* Definition of variable 'i' */*(&i_416) = (offset);
	while((i_416) < (last))
	{
		{
			/* Definition of variable 'wrong' */*(&wrong_417) = (false);
			/* Definition of variable 'k' */*(&k_418) = (0);
			while(((k_418) < ((*(&(&(str)->data)->size)) - (1))) && (!(wrong_417)))
			{
				{
					if((*(__nullcIndexUnsizedArray(*(&(__context)->data), (i_416) + (k_418)))) != (*(__nullcIndexUnsizedArray(*(&(str)->data), k_418))))
					{
						*(&wrong_417) = (true);
					}
;
					// Closures
					/*empty sequence*/;
				};
continue_12:;
				// Increment
				{
					/*empty sequence*/;
					(*(&k_418))++;
				};
			}
break_12:
			;
			if(!(wrong_417))
			{
				return i_416;;
			}
;
			// Closures
			/*empty sequence*/;
		};
continue_11:;
		// Increment
		{
			/*empty sequence*/;
			(*(&i_416))++;
		};
	}
break_11:
	;
	return -(1);;
}

int string__find_int_ref_char___int_(NULLCArray< char > str, int offset, string* __context)
{
	string __temp13;
	string __temp14;
	int __nullcReturnValue_28;
	return string__find_int_ref_string_ref_int_((
		/* Definition of variable '$temp14' */*(&__temp14) = ((
			/* Definition of variable '$temp13' */0, 
			string__string_void_ref_char___(str, &__temp13), 
			__temp13
		)), 
		&__temp14
	), offset, __context);;
}

int string__find_int_ref_char_int_(char ch, int offset, string* __context)
{
	int i_429;
	int __nullcReturnValue_29;
	/* Definition of variable 'i' */*(&i_429) = (offset);
	while((i_429) < ((*(&(&(__context)->data)->size)) - (1)))
	{
		{
			if((*(__nullcIndexUnsizedArray(*(&(__context)->data), i_429))) == (ch))
			{
				return i_429;;
			}
;
			// Closures
			/*empty sequence*/;
		};
continue_13:;
		// Increment
		{
			/*empty sequence*/;
			(*(&i_429))++;
		};
	}
break_13:
	;
	return -(1);;
}

int string__rfind_int_ref_string_ref_int_(string* str, int offset, string* __context)
{
	int i_434;
	bool wrong_435;
	int k_436;
	int __nullcReturnValue_30;
	if((*(&(&(str)->data)->size)) == (0))
	{
		return (((offset) >= (0)) && ((offset) < (*(&(&(__context)->data)->size)))) ? (offset) : (string__size__int_ref___(__context));;
	}
;
	if(((offset) < (0)) || ((offset) >= ((*(&(&(__context)->data)->size)) - (1))))
	{
		*(&offset) = ((*(&(&(__context)->data)->size)) - (2));
	}
;
	/* Definition of variable 'i' */*(&i_434) = (offset);
	while((i_434) >= (0))
	{
		{
			/* Definition of variable 'wrong' */*(&wrong_435) = (false);
			/* Definition of variable 'k' */*(&k_436) = (0);
			while(((k_436) < ((*(&(&(str)->data)->size)) - (1))) && (!(wrong_435)))
			{
				{
					if((*(__nullcIndexUnsizedArray(*(&(__context)->data), (i_434) + (k_436)))) != (*(__nullcIndexUnsizedArray(*(&(str)->data), k_436))))
					{
						*(&wrong_435) = (true);
					}
;
					// Closures
					/*empty sequence*/;
				};
continue_15:;
				// Increment
				{
					/*empty sequence*/;
					(*(&k_436))++;
				};
			}
break_15:
			;
			if(!(wrong_435))
			{
				return i_434;;
			}
;
			// Closures
			/*empty sequence*/;
		};
continue_14:;
		// Increment
		{
			/*empty sequence*/;
			(*(&i_434))--;
		};
	}
break_14:
	;
	return -(1);;
}

int string__rfind_int_ref_char___int_(NULLCArray< char > str, int offset, string* __context)
{
	string __temp15;
	string __temp16;
	int __nullcReturnValue_31;
	return string__rfind_int_ref_string_ref_int_((
		/* Definition of variable '$temp16' */*(&__temp16) = ((
			/* Definition of variable '$temp15' */0, 
			string__string_void_ref_char___(str, &__temp15), 
			__temp15
		)), 
		&__temp16
	), offset, __context);;
}

int string__rfind_int_ref_char_int_(char ch, int offset, string* __context)
{
	int i_447;
	int __nullcReturnValue_32;
	if(((offset) < (0)) || ((offset) >= ((*(&(&(__context)->data)->size)) - (1))))
	{
		*(&offset) = ((*(&(&(__context)->data)->size)) - (2));
	}
;
	/* Definition of variable 'i' */*(&i_447) = (offset);
	while((i_447) >= (0))
	{
		{
			if((*(__nullcIndexUnsizedArray(*(&(__context)->data), i_447))) == (ch))
			{
				return i_447;;
			}
;
			// Closures
			/*empty sequence*/;
		};
continue_16:;
		// Increment
		{
			/*empty sequence*/;
			(*(&i_447))--;
		};
	}
break_16:
	;
	return -(1);;
}

int string__find_first_of_int_ref_string_ref_int_(string* str, int offset, string* __context)
{
	int i_452;
	int k_453;
	int __nullcReturnValue_33;
	/* Definition of variable 'i' */*(&i_452) = (offset);
	while((i_452) < ((*(&(&(__context)->data)->size)) - (1)))
	{
		{
			/* Definition of variable 'k' */*(&k_453) = (0);
			while((k_453) < ((*(&(&(str)->data)->size)) - (1)))
			{
				{
					if((*(__nullcIndexUnsizedArray(*(&(__context)->data), i_452))) == (*(__nullcIndexUnsizedArray(*(&(str)->data), k_453))))
					{
						return i_452;;
					}
;
					// Closures
					/*empty sequence*/;
				};
continue_18:;
				// Increment
				{
					/*empty sequence*/;
					(*(&k_453))++;
				};
			}
break_18:
			;
			// Closures
			/*empty sequence*/;
		};
continue_17:;
		// Increment
		{
			/*empty sequence*/;
			(*(&i_452))++;
		};
	}
break_17:
	;
	return -(1);;
}

int string__find_first_of_int_ref_char___int_(NULLCArray< char > str, int offset, string* __context)
{
	string __temp17;
	string __temp18;
	int __nullcReturnValue_34;
	return string__find_first_of_int_ref_string_ref_int_((
		/* Definition of variable '$temp18' */*(&__temp18) = ((
			/* Definition of variable '$temp17' */0, 
			string__string_void_ref_char___(str, &__temp17), 
			__temp17
		)), 
		&__temp18
	), offset, __context);;
}

int string__find_first_of_int_ref_char_int_(char ch, int offset, string* __context)
{
	int __nullcReturnValue_35;
	return string__find_int_ref_char_int_(ch, offset, __context);;
}

int string__find_last_of_int_ref_string_ref_int_(string* str, int offset, string* __context)
{
	int i_468;
	int k_469;
	int __nullcReturnValue_36;
	if(((offset) < (0)) || ((offset) >= ((*(&(&(__context)->data)->size)) - (1))))
	{
		*(&offset) = ((*(&(&(__context)->data)->size)) - (2));
	}
;
	/* Definition of variable 'i' */*(&i_468) = (offset);
	while((i_468) >= (0))
	{
		{
			/* Definition of variable 'k' */*(&k_469) = (0);
			while((k_469) < ((*(&(&(str)->data)->size)) - (1)))
			{
				{
					if((*(__nullcIndexUnsizedArray(*(&(__context)->data), i_468))) == (*(__nullcIndexUnsizedArray(*(&(str)->data), k_469))))
					{
						return i_468;;
					}
;
					// Closures
					/*empty sequence*/;
				};
continue_20:;
				// Increment
				{
					/*empty sequence*/;
					(*(&k_469))++;
				};
			}
break_20:
			;
			// Closures
			/*empty sequence*/;
		};
continue_19:;
		// Increment
		{
			/*empty sequence*/;
			(*(&i_468))--;
		};
	}
break_19:
	;
	return -(1);;
}

int string__find_last_of_int_ref_char___int_(NULLCArray< char > str, int offset, string* __context)
{
	string __temp19;
	string __temp20;
	int __nullcReturnValue_37;
	return string__find_last_of_int_ref_string_ref_int_((
		/* Definition of variable '$temp20' */*(&__temp20) = ((
			/* Definition of variable '$temp19' */0, 
			string__string_void_ref_char___(str, &__temp19), 
			__temp19
		)), 
		&__temp20
	), offset, __context);;
}

int string__find_last_of_int_ref_char_int_(char ch, int offset, string* __context)
{
	int __nullcReturnValue_38;
	return string__rfind_int_ref_char_int_(ch, offset, __context);;
}

int string__find_first_not_of_int_ref_string_ref_int_(string* str, int offset, string* __context)
{
	int i_484;
	bool found_485;
	int k_486;
	int __nullcReturnValue_39;
	/* Definition of variable 'i' */*(&i_484) = (offset);
	while((i_484) < ((*(&(&(__context)->data)->size)) - (1)))
	{
		{
			/* Definition of variable 'found' */*(&found_485) = (false);
			/* Definition of variable 'k' */*(&k_486) = (0);
			while(((k_486) < ((*(&(&(str)->data)->size)) - (1))) && (!(found_485)))
			{
				{
					if((*(__nullcIndexUnsizedArray(*(&(__context)->data), i_484))) == (*(__nullcIndexUnsizedArray(*(&(str)->data), k_486))))
					{
						*(&found_485) = (true);
					}
;
					// Closures
					/*empty sequence*/;
				};
continue_22:;
				// Increment
				{
					/*empty sequence*/;
					(*(&k_486))++;
				};
			}
break_22:
			;
			if(!(found_485))
			{
				return i_484;;
			}
;
			// Closures
			/*empty sequence*/;
		};
continue_21:;
		// Increment
		{
			/*empty sequence*/;
			(*(&i_484))++;
		};
	}
break_21:
	;
	return -(1);;
}

int string__find_first_not_of_int_ref_char___int_(NULLCArray< char > str, int offset, string* __context)
{
	string __temp21;
	string __temp22;
	int __nullcReturnValue_40;
	return string__find_first_not_of_int_ref_string_ref_int_((
		/* Definition of variable '$temp22' */*(&__temp22) = ((
			/* Definition of variable '$temp21' */0, 
			string__string_void_ref_char___(str, &__temp21), 
			__temp21
		)), 
		&__temp22
	), offset, __context);;
}

int string__find_first_not_of_int_ref_char_int_(char ch, int offset, string* __context)
{
	int i_497;
	int __nullcReturnValue_41;
	/* Definition of variable 'i' */*(&i_497) = (offset);
	while((i_497) < ((*(&(&(__context)->data)->size)) - (1)))
	{
		{
			if((*(__nullcIndexUnsizedArray(*(&(__context)->data), i_497))) != (ch))
			{
				return i_497;;
			}
;
			// Closures
			/*empty sequence*/;
		};
continue_23:;
		// Increment
		{
			/*empty sequence*/;
			(*(&i_497))++;
		};
	}
break_23:
	;
	return -(1);;
}

int string__find_last_not_of_int_ref_string_ref_int_(string* str, int offset, string* __context)
{
	int i_502;
	bool found_503;
	int k_504;
	int __nullcReturnValue_42;
	if(((offset) < (0)) || ((offset) >= ((*(&(&(__context)->data)->size)) - (1))))
	{
		*(&offset) = ((*(&(&(__context)->data)->size)) - (2));
	}
;
	/* Definition of variable 'i' */*(&i_502) = (offset);
	while((i_502) >= (0))
	{
		{
			/* Definition of variable 'found' */*(&found_503) = (false);
			/* Definition of variable 'k' */*(&k_504) = (0);
			while(((k_504) < ((*(&(&(str)->data)->size)) - (1))) && (!(found_503)))
			{
				{
					if((*(__nullcIndexUnsizedArray(*(&(__context)->data), i_502))) == (*(__nullcIndexUnsizedArray(*(&(str)->data), k_504))))
					{
						*(&found_503) = (true);
					}
;
					// Closures
					/*empty sequence*/;
				};
continue_25:;
				// Increment
				{
					/*empty sequence*/;
					(*(&k_504))++;
				};
			}
break_25:
			;
			if(!(found_503))
			{
				return i_502;;
			}
;
			// Closures
			/*empty sequence*/;
		};
continue_24:;
		// Increment
		{
			/*empty sequence*/;
			(*(&i_502))--;
		};
	}
break_24:
	;
	return -(1);;
}

int string__find_last_not_of_int_ref_char___int_(NULLCArray< char > str, int offset, string* __context)
{
	string __temp23;
	string __temp24;
	int __nullcReturnValue_43;
	return string__find_last_not_of_int_ref_string_ref_int_((
		/* Definition of variable '$temp24' */*(&__temp24) = ((
			/* Definition of variable '$temp23' */0, 
			string__string_void_ref_char___(str, &__temp23), 
			__temp23
		)), 
		&__temp24
	), offset, __context);;
}

int string__find_last_not_of_int_ref_char_int_(char ch, int offset, string* __context)
{
	int i_515;
	int __nullcReturnValue_44;
	if(((offset) < (0)) || ((offset) >= ((*(&(&(__context)->data)->size)) - (1))))
	{
		*(&offset) = ((*(&(&(__context)->data)->size)) - (2));
	}
;
	/* Definition of variable 'i' */*(&i_515) = (offset);
	while((i_515) >= (0))
	{
		{
			if((*(__nullcIndexUnsizedArray(*(&(__context)->data), i_515))) != (ch))
			{
				return i_515;;
			}
;
			// Closures
			/*empty sequence*/;
		};
continue_26:;
		// Increment
		{
			/*empty sequence*/;
			(*(&i_515))--;
		};
	}
break_26:
	;
	return -(1);;
}

bool in_bool_ref_char_string_ref_(char ch, string* str, void* __context)
{
	bool __nullcReturnValue_45;
	return (string__find_int_ref_char_int_(ch, 0, str)) != (-(1));;
}

string string__substr_string_ref_int_int_(int start, int length, string* __context)
{
	string __temp25;
	string __nullcReturnValue_46;
	if(((length) < (0)) || (((start) + (length)) >= (*(&(&(__context)->data)->size))))
	{
		*(&length) = (((*(&(&(__context)->data)->size)) - (start)) - (1));
	}
;
	if((length) <= (0))
	{
		return (
			/* Definition of variable '$temp25' */0, 
			string__string_void_ref__(&__temp25), 
			__temp25
		);;
	}
;
	return __operatorIndex_string_ref_string_ref_int_int_(__context, start, ((start) + (length)) - (1), (void*)0);;
}

string __operatorAdd_string_ref_string_ref_string_ref_(string* left, string* right, void* __context)
{
	string __temp26;
	string __temp27;
	string __temp28;
	string __nullcReturnValue_47;
	if(!(*(&(&(left)->data)->size)))
	{
		return (
			/* Definition of variable '$temp26' */0, 
			string__string_void_ref_string_ref_(right, &__temp26), 
			__temp26
		);;
	}
;
	if(!(*(&(&(right)->data)->size)))
	{
		return (
			/* Definition of variable '$temp27' */0, 
			string__string_void_ref_string_ref_(left, &__temp27), 
			__temp27
		);;
	}
;
	return (
		/* Definition of variable '$temp28' */0, 
		string__string_void_ref_char___(__operatorAdd_char___ref_char___char___(*(&(left)->data), *(&(right)->data), (void*)0), &__temp28), 
		__temp28
	);;
}

string __operatorAdd_string_ref_char___string_ref_(NULLCArray< char > left, string* right, void* __context)
{
	string __temp29;
	string __nullcReturnValue_48;
	return (
		/* Definition of variable '$temp29' */0, 
		string__string_void_ref_char___(__operatorAdd_char___ref_char___char___(left, *(&(right)->data), (void*)0), &__temp29), 
		__temp29
	);;
}

string __operatorAdd_string_ref_string_ref_char___(string* left, NULLCArray< char > right, void* __context)
{
	string __temp30;
	string __nullcReturnValue_49;
	return (
		/* Definition of variable '$temp30' */0, 
		string__string_void_ref_char___(__operatorAdd_char___ref_char___char___(*(&(left)->data), right, (void*)0), &__temp30), 
		__temp30
	);;
}

bool __operatorEqual_bool_ref_string_ref_string_ref_(string* left, string* right, void* __context)
{
	bool __nullcReturnValue_50;
	return (bool)(__operatorEqual_int_ref_char___char___(*(&(left)->data), *(&(right)->data), (void*)0));;
}

bool __operatorEqual_bool_ref_string_ref_char___(string* left, NULLCArray< char > right, void* __context)
{
	bool __nullcReturnValue_51;
	if((*(&(&right)->size)) > (1))
	{
		return (bool)(__operatorEqual_int_ref_char___char___(*(&(left)->data), right, (void*)0));;
	}
;
	return (string__size__int_ref___(left)) == (0);;
}

bool __operatorEqual_bool_ref_char___string_ref_(NULLCArray< char > left, string* right, void* __context)
{
	bool __nullcReturnValue_52;
	if((*(&(&left)->size)) > (1))
	{
		return (bool)(__operatorEqual_int_ref_char___char___(left, *(&(right)->data), (void*)0));;
	}
;
	return (string__size__int_ref___(right)) == (0);;
}

bool __operatorNEqual_bool_ref_string_ref_string_ref_(string* left, string* right, void* __context)
{
	bool __nullcReturnValue_53;
	if((string__size__int_ref___(left)) != (string__size__int_ref___(right)))
	{
		return true;;
	}
;
	return (bool)(__operatorNEqual_int_ref_char___char___(*(&(left)->data), *(&(right)->data), (void*)0));;
}

bool __operatorNEqual_bool_ref_string_ref_char___(string* left, NULLCArray< char > right, void* __context)
{
	bool __nullcReturnValue_54;
	if((*(&(&right)->size)) > (1))
	{
		return (bool)(__operatorNEqual_int_ref_char___char___(*(&(left)->data), right, (void*)0));;
	}
;
	return (string__size__int_ref___(left)) != (0);;
}

bool __operatorNEqual_bool_ref_char___string_ref_(NULLCArray< char > left, string* right, void* __context)
{
	bool __nullcReturnValue_55;
	if((*(&(&left)->size)) > (1))
	{
		return (bool)(__operatorNEqual_int_ref_char___char___(left, *(&(right)->data), (void*)0));;
	}
;
	return (string__size__int_ref___(right)) != (0);;
}

int string__erase_3081620873_length__int_ref___(void* __context)
{
	int __nullcReturnValue_56;
	return -(1);;
}

int string__find_2424387209_offset__int_ref___(void* __context)
{
	int __nullcReturnValue_57;
	return 0;;
}

int string__find_1089031307_offset__int_ref___(void* __context)
{
	int __nullcReturnValue_58;
	return 0;;
}

int string__find_28588211_offset__int_ref___(void* __context)
{
	int __nullcReturnValue_59;
	return 0;;
}

int string__rfind_2424387209_offset__int_ref___(void* __context)
{
	int __nullcReturnValue_60;
	return -(1);;
}

int string__rfind_1089031307_offset__int_ref___(void* __context)
{
	int __nullcReturnValue_61;
	return -(1);;
}

int string__rfind_28588211_offset__int_ref___(void* __context)
{
	int __nullcReturnValue_62;
	return -(1);;
}

int string__find_first_of_2424387209_offset__int_ref___(void* __context)
{
	int __nullcReturnValue_63;
	return 0;;
}

int string__find_first_of_1089031307_offset__int_ref___(void* __context)
{
	int __nullcReturnValue_64;
	return 0;;
}

int string__find_first_of_28588211_offset__int_ref___(void* __context)
{
	int __nullcReturnValue_65;
	return 0;;
}

int string__find_last_of_2424387209_offset__int_ref___(void* __context)
{
	int __nullcReturnValue_66;
	return -(1);;
}

int string__find_last_of_1089031307_offset__int_ref___(void* __context)
{
	int __nullcReturnValue_67;
	return -(1);;
}

int string__find_last_of_28588211_offset__int_ref___(void* __context)
{
	int __nullcReturnValue_68;
	return -(1);;
}

int string__find_first_not_of_2424387209_offset__int_ref___(void* __context)
{
	int __nullcReturnValue_69;
	return 0;;
}

int string__find_first_not_of_1089031307_offset__int_ref___(void* __context)
{
	int __nullcReturnValue_70;
	return 0;;
}

int string__find_first_not_of_28588211_offset__int_ref___(void* __context)
{
	int __nullcReturnValue_71;
	return 0;;
}

int string__find_last_not_of_2424387209_offset__int_ref___(void* __context)
{
	int __nullcReturnValue_72;
	return -(1);;
}

int string__find_last_not_of_1089031307_offset__int_ref___(void* __context)
{
	int __nullcReturnValue_73;
	return -(1);;
}

int string__find_last_not_of_28588211_offset__int_ref___(void* __context)
{
	int __nullcReturnValue_74;
	return -(1);;
}

int string__substr_536940012_length__int_ref___(void* __context)
{
	int __nullcReturnValue_75;
	return -(1);;
}


// Module initializers

// Global code
int __init_std_string_nc()
{
	static int moduleInitialized = 0;
	if(moduleInitialized++)
		return 0;
	__nullcFM = __nullcGetFunctionTable();
	int __local = 0;
	__nullcRegisterBase(&__local);
	__nullcInitBaseModule();

	// Initialize modules

	// Register types
	__nullcTR[0] = __nullcRegisterType(2090838615u, "void", 0, __nullcTR[0], 0, NULLC_NONE);
	__nullcTR[1] = __nullcRegisterType(2090120081u, "bool", 1, __nullcTR[0], 0, NULLC_NONE);
	__nullcTR[2] = __nullcRegisterType(2090147939u, "char", 1, __nullcTR[0], 0, NULLC_NONE);
	__nullcTR[3] = __nullcRegisterType(274395349u, "short", 2, __nullcTR[0], 0, NULLC_NONE);
	__nullcTR[4] = __nullcRegisterType(193495088u, "int", 4, __nullcTR[0], 0, NULLC_NONE);
	__nullcTR[5] = __nullcRegisterType(2090479413u, "long", 8, __nullcTR[0], 0, NULLC_NONE);
	__nullcTR[6] = __nullcRegisterType(259121563u, "float", 4, __nullcTR[0], 0, NULLC_NONE);
	__nullcTR[7] = __nullcRegisterType(4181547808u, "double", 8, __nullcTR[0], 0, NULLC_NONE);
	__nullcTR[8] = __nullcRegisterType(524429492u, "typeid", 4, __nullcTR[0], 0, NULLC_NONE);
	__nullcTR[9] = __nullcRegisterType(1211668521u, "__function", 4, __nullcTR[0], 0, NULLC_NONE);
	__nullcTR[10] = __nullcRegisterType(84517172u, "__nullptr", 4, __nullcTR[0], 0, NULLC_NONE);
	__nullcTR[11] = 0; // generic type 'generic'
	__nullcTR[12] = __nullcRegisterType(2090090846u, "auto", 0, __nullcTR[0], 0, NULLC_NONE);
	__nullcTR[13] = __nullcRegisterType(1166360283u, "auto ref", 8, __nullcTR[0], 2, NULLC_CLASS);
	__nullcTR[14] = __nullcRegisterType(3198057556u, "void ref", 4, __nullcTR[0], 1, NULLC_POINTER);
	__nullcTR[15] = __nullcRegisterType(4071234806u, "auto[]", 12, __nullcTR[0], 3, NULLC_CLASS);
	__nullcTR[16] = __nullcRegisterType(2550963152u, "void ref(int)", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[17] = __nullcRegisterType(4133409083u, "char[]", 8, __nullcTR[2], -1, NULLC_ARRAY);
	__nullcTR[18] = __nullcRegisterType(3878423506u, "void ref(int,char[])", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[19] = __nullcRegisterType(1362586038u, "int ref(char[],char[])", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[20] = __nullcRegisterType(3953727713u, "char[] ref(char[],char[])", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[21] = __nullcRegisterType(3214832952u, "char[] ref", 4, __nullcTR[17], 1, NULLC_POINTER);
	__nullcTR[22] = __nullcRegisterType(90259294u, "char[] ref(char[] ref,char[])", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[23] = __nullcRegisterType(1219970027u, "bool ref(bool)", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[24] = __nullcRegisterType(3410585167u, "char ref(char)", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[25] = __nullcRegisterType(1890834067u, "short ref(short)", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[26] = __nullcRegisterType(2745832905u, "int ref(int)", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[27] = __nullcRegisterType(3458960563u, "long ref(long)", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[28] = __nullcRegisterType(4223928607u, "float ref(float)", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[29] = __nullcRegisterType(4226161577u, "double ref(double)", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[30] = __nullcRegisterType(1477022350u, "bool ref", 4, __nullcTR[1], 1, NULLC_POINTER);
	__nullcTR[31] = __nullcRegisterType(2569136689u, "void ref(bool)", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[32] = __nullcRegisterType(154671200u, "char ref", 4, __nullcTR[2], 1, NULLC_POINTER);
	__nullcTR[33] = __nullcRegisterType(2570056003u, "void ref(char)", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[34] = __nullcRegisterType(3010777554u, "short ref", 4, __nullcTR[3], 1, NULLC_POINTER);
	__nullcTR[35] = __nullcRegisterType(3834141397u, "void ref(short)", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[36] = __nullcRegisterType(2671810221u, "int ref", 4, __nullcTR[4], 1, NULLC_POINTER);
	__nullcTR[37] = __nullcRegisterType(2414624818u, "long ref", 4, __nullcTR[5], 1, NULLC_POINTER);
	__nullcTR[38] = __nullcRegisterType(2580994645u, "void ref(long)", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[39] = __nullcRegisterType(1384297880u, "float ref", 4, __nullcTR[6], 1, NULLC_POINTER);
	__nullcTR[40] = __nullcRegisterType(3330106459u, "void ref(float)", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[41] = __nullcRegisterType(3234425245u, "double ref", 4, __nullcTR[7], 1, NULLC_POINTER);
	__nullcTR[42] = __nullcRegisterType(60945760u, "void ref(double)", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[43] = __nullcRegisterType(410823260u, "int ref(char)", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[44] = __nullcRegisterType(1298937614u, "int ref(short)", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[45] = __nullcRegisterType(625310318u, "long ref(int)", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[46] = __nullcRegisterType(3062702681u, "short ref(char[])", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[47] = __nullcRegisterType(2767335131u, "void ref(char[])", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[48] = __nullcRegisterType(3150998963u, "auto ref[]", 8, __nullcTR[13], -1, NULLC_ARRAY);
	__nullcTR[49] = __nullcRegisterType(554739849u, "char[] ref()", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[50] = __nullcRegisterType(709988916u, "int ref(char[])", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[51] = __nullcRegisterType(1094512825u, "long ref(char[])", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[52] = __nullcRegisterType(2198694943u, "float ref(char[])", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[53] = __nullcRegisterType(610894668u, "char[] ref(int,bool)", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[54] = __nullcRegisterType(2637583652u, "double ref(char[])", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[55] = __nullcRegisterType(3461032260u, "void ref ref(int,int)", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[56] = __nullcRegisterType(262756424u, "int[]", 8, __nullcTR[4], -1, NULLC_ARRAY);
	__nullcTR[57] = __nullcRegisterType(2307698191u, "int[] ref(int,int,int)", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[58] = __nullcRegisterType(3724107199u, "auto ref ref(auto ref)", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[59] = __nullcRegisterType(1137649267u, "auto[] ref", 4, __nullcTR[15], 1, NULLC_POINTER);
	__nullcTR[60] = __nullcRegisterType(665024592u, "void ref(auto[] ref,auto[])", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[61] = __nullcRegisterType(2649967381u, "auto[] ref(auto[])", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[62] = __nullcRegisterType(2430896065u, "auto ref ref(auto ref,auto ref)", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[63] = __nullcRegisterType(3364104125u, "void ref(auto ref,auto ref)", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[64] = __nullcRegisterType(4131070326u, "int ref(auto ref,auto ref)", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[65] = __nullcRegisterType(4253285971u, "void ref(auto[],auto[])", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[66] = 0; // generic type 'void ref(generic,int,generic,int,int)'
	__nullcTR[67] = __nullcRegisterType(3761170085u, "void ref()", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[68] = __nullcRegisterType(952062593u, "__function[]", 8, __nullcTR[9], -1, NULLC_ARRAY);
	__nullcTR[69] = __nullcRegisterType(1430923646u, "__function[] ref", 4, __nullcTR[68], 1, NULLC_POINTER);
	__nullcTR[70] = __nullcRegisterType(3427750478u, "void ref() ref(auto ref,__function[] ref)", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[71] = __nullcRegisterType(3474940206u, "auto ref(char[] ref,int[])", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[72] = __nullcRegisterType(4190091973u, "int[] ref", 4, __nullcTR[56], 1, NULLC_POINTER);
	__nullcTR[73] = __nullcRegisterType(2985493640u, "char[] ref ref(char[] ref,int[])", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[74] = __nullcRegisterType(2463794733u, "short[]", 8, __nullcTR[3], -1, NULLC_ARRAY);
	__nullcTR[75] = __nullcRegisterType(3958330154u, "short[] ref", 4, __nullcTR[74], 1, NULLC_POINTER);
	__nullcTR[76] = __nullcRegisterType(1064730272u, "auto ref(short[] ref,int[])", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[77] = __nullcRegisterType(1935747820u, "short[] ref ref(short[] ref,int[])", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[78] = __nullcRegisterType(3010510963u, "float[]", 8, __nullcTR[6], -1, NULLC_ARRAY);
	__nullcTR[79] = __nullcRegisterType(2248491120u, "float[] ref", 4, __nullcTR[78], 1, NULLC_POINTER);
	__nullcTR[80] = __nullcRegisterType(1040232248u, "double[]", 8, __nullcTR[7], -1, NULLC_ARRAY);
	__nullcTR[81] = __nullcRegisterType(552932854u, "auto ref(float[] ref,double[])", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[82] = __nullcRegisterType(2697529781u, "double[] ref", 4, __nullcTR[80], 1, NULLC_POINTER);
	__nullcTR[83] = __nullcRegisterType(2467461000u, "float[] ref ref(float[] ref,double[])", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[84] = __nullcRegisterType(2066091864u, "typeid ref(auto ref)", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[85] = __nullcRegisterType(3504529713u, "typeid ref", 4, __nullcTR[8], 1, NULLC_POINTER);
	__nullcTR[86] = __nullcRegisterType(1908472638u, "int ref()", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[87] = __nullcRegisterType(1268871368u, "int ref(typeid,typeid)", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[88] = __nullcRegisterType(3270246327u, "bool ref(auto ref,auto ref)", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[89] = __nullcRegisterType(3335638996u, "int ref(auto ref)", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[90] = __nullcRegisterType(2688408224u, "int ref(void ref(int),void ref(int))", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[91] = __nullcRegisterType(2050556812u, "int ref(auto[],auto[])", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[92] = __nullcRegisterType(451037873u, "auto[] ref ref(auto[] ref,auto ref)", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[93] = __nullcRegisterType(3824954777u, "auto ref ref(auto ref,auto[] ref)", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[94] = __nullcRegisterType(477490926u, "auto ref ref(auto[] ref,int)", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[95] = __nullcRegisterType(3720955042u, "const_string", 8, __nullcTR[0], 1, NULLC_CLASS);
	__nullcTR[96] = __nullcRegisterType(1951548447u, "const_string ref", 4, __nullcTR[95], 1, NULLC_POINTER);
	__nullcTR[97] = __nullcRegisterType(1626104968u, "auto ref(const_string ref,char[])", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[98] = __nullcRegisterType(3099572969u, "const_string ref ref(const_string ref,char[])", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[99] = __nullcRegisterType(2016055718u, "const_string ref(char[])", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[100] = __nullcRegisterType(195623906u, "char ref(const_string ref,int)", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[101] = __nullcRegisterType(3956827940u, "int ref(const_string,const_string)", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[102] = __nullcRegisterType(3539544093u, "int ref(const_string,char[])", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[103] = __nullcRegisterType(730969981u, "int ref(char[],const_string)", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[104] = __nullcRegisterType(727035222u, "const_string ref(const_string,const_string)", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[105] = __nullcRegisterType(1003630799u, "const_string ref(const_string,char[])", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[106] = __nullcRegisterType(2490023983u, "const_string ref(char[],const_string)", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[107] = __nullcRegisterType(4064539429u, "void ref(auto[] ref,typeid,int)", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[108] = __nullcRegisterType(3726221418u, "auto[] ref(typeid,int)", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[109] = __nullcRegisterType(527603730u, "void ref(auto ref,int)", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[110] = __nullcRegisterType(4086116458u, "void ref(auto[] ref,int)", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[111] = __nullcRegisterType(1812738619u, "void ref(auto ref)", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[112] = __nullcRegisterType(160677633u, "auto ref[] ref()", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[113] = __nullcRegisterType(2002985239u, "__FinalizeProxy", 0, __nullcTR[0], 0, NULLC_CLASS);
	__nullcTR[114] = __nullcRegisterType(3351204628u, "__FinalizeProxy ref", 4, __nullcTR[113], 1, NULLC_POINTER);
	__nullcTR[115] = __nullcRegisterType(3841559984u, "auto ref[] ref", 4, __nullcTR[48], 1, NULLC_POINTER);
	__nullcTR[116] = __nullcRegisterType(4051874520u, "auto ref ref", 4, __nullcTR[13], 1, NULLC_POINTER);
	__nullcTR[117] = __nullcRegisterType(2263080277u, "auto ref ref ref", 4, __nullcTR[116], 1, NULLC_POINTER);
	__nullcTR[118] = 0; // generic type 'generic[]'
	__nullcTR[119] = 0; // generic type 'bool ref(generic,generic[])'
	__nullcTR[120] = __nullcRegisterType(530709260u, "void ref ref(void ref,typeid)", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[121] = 0; // generic type '@T'
	__nullcTR[122] = 0; // generic type '@T ref()'
	__nullcTR[123] = 0; // generic type 'auto ref(@T ref())'
	__nullcTR[124] = 0; // generic type '@T[]'
	__nullcTR[125] = 0; // generic type 'void ref(@T[])'
	__nullcTR[126] = __nullcRegisterType(2810184913u, "void ref ref", 4, __nullcTR[14], 1, NULLC_POINTER);
	__nullcTR[127] = __nullcRegisterType(3164121466u, "void ref(void ref ref,void ref,int,int)", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[128] = __nullcRegisterType(2159571807u, "bool ref()", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[129] = __nullcRegisterType(1706951462u, "__function ref", 4, __nullcTR[9], 1, NULLC_POINTER);
	__nullcTR[130] = __nullcRegisterType(2426382347u, "bool ref ref", 4, __nullcTR[30], 1, NULLC_POINTER);
	__nullcTR[131] = __nullcRegisterType(2657142493u, "char ref ref", 4, __nullcTR[32], 1, NULLC_POINTER);
	__nullcTR[132] = __nullcRegisterType(576776527u, "short ref ref", 4, __nullcTR[34], 1, NULLC_POINTER);
	__nullcTR[133] = __nullcRegisterType(3857294250u, "int ref ref", 4, __nullcTR[36], 1, NULLC_POINTER);
	__nullcTR[134] = __nullcRegisterType(799573935u, "long ref ref", 4, __nullcTR[37], 1, NULLC_POINTER);
	__nullcTR[135] = __nullcRegisterType(2577874965u, "float ref ref", 4, __nullcTR[39], 1, NULLC_POINTER);
	__nullcTR[136] = __nullcRegisterType(1954705050u, "double ref ref", 4, __nullcTR[41], 1, NULLC_POINTER);
	__nullcTR[137] = __nullcRegisterType(2816069557u, "char[] ref ref", 4, __nullcTR[21], 1, NULLC_POINTER);
	__nullcTR[138] = __nullcRegisterType(745297575u, "short[] ref ref", 4, __nullcTR[75], 1, NULLC_POINTER);
	__nullcTR[139] = __nullcRegisterType(2393077485u, "float[] ref ref", 4, __nullcTR[79], 1, NULLC_POINTER);
	__nullcTR[140] = __nullcRegisterType(504936988u, "const_string ref ref", 4, __nullcTR[96], 1, NULLC_POINTER);
	__nullcTR[141] = __nullcRegisterType(1570945374u, "int ref(char[],char)", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[142] = __nullcRegisterType(479440892u, "string", 8, __nullcTR[0], 1, NULLC_CLASS);
	__nullcTR[143] = __nullcRegisterType(2662780025u, "string ref", 4, __nullcTR[142], 1, NULLC_POINTER);
	__nullcTR[144] = __nullcRegisterType(43000954u, "void ref(int,char)", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[145] = __nullcRegisterType(3751069017u, "void ref(string ref)", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[146] = __nullcRegisterType(3353711771u, "string ref ref(string ref,string ref)", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[147] = __nullcRegisterType(1829350685u, "string ref ref(string ref,char[])", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[148] = __nullcRegisterType(1433335557u, "string ref ref(string ref,char)", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[149] = __nullcRegisterType(853264057u, "char ref ref(string ref,int)", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[150] = __nullcRegisterType(16213804u, "string ref(string ref,int,int)", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[151] = __nullcRegisterType(3115186030u, "char ref ref()", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[152] = __nullcRegisterType(1432857842u, "string ref ref(int,string ref)", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[153] = __nullcRegisterType(3359060468u, "string ref ref(int,char[])", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[154] = __nullcRegisterType(186798547u, "string ref ref(int,int,char)", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[155] = __nullcRegisterType(3081620873u, "string ref ref(int,int)", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[156] = __nullcRegisterType(2727432681u, "string ref ref(int,int,string ref)", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[157] = __nullcRegisterType(1560212331u, "string ref ref(int,int,char[])", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[158] = __nullcRegisterType(4041231626u, "string ref ref(int,int,int,char)", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[159] = __nullcRegisterType(2424387209u, "int ref(string ref,int)", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[160] = __nullcRegisterType(1089031307u, "int ref(char[],int)", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[161] = __nullcRegisterType(28588211u, "int ref(char,int)", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[162] = __nullcRegisterType(4196859613u, "bool ref(char,string ref)", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[163] = __nullcRegisterType(536940012u, "string ref(int,int)", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[164] = __nullcRegisterType(3314042430u, "string ref(string ref,string ref)", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[165] = __nullcRegisterType(451608576u, "string ref(char[],string ref)", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[166] = __nullcRegisterType(1497826624u, "string ref(string ref,char[])", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[167] = __nullcRegisterType(4256369843u, "bool ref(string ref,string ref)", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[168] = __nullcRegisterType(1517214005u, "bool ref(string ref,char[])", 8, __nullcTR[0], 0, NULLC_FUNCTION);
	__nullcTR[169] = __nullcRegisterType(470995957u, "bool ref(char[],string ref)", 8, __nullcTR[0], 0, NULLC_FUNCTION);

	// Register type members
	__nullcRegisterMembers(__nullcTR[13], 2, __nullcTR[8], 0, __nullcTR[14], 4); // type 'auto ref' members
	__nullcRegisterMembers(__nullcTR[15], 3, __nullcTR[8], 0, __nullcTR[14], 4, __nullcTR[4], 8); // type 'auto[]' members
	__nullcRegisterMembers(__nullcTR[17], 1, __nullcTR[4], 4); // type 'char[]' members
	__nullcRegisterMembers(__nullcTR[48], 1, __nullcTR[4], 4); // type 'auto ref[]' members
	__nullcRegisterMembers(__nullcTR[56], 1, __nullcTR[4], 4); // type 'int[]' members
	__nullcRegisterMembers(__nullcTR[68], 1, __nullcTR[4], 4); // type '__function[]' members
	__nullcRegisterMembers(__nullcTR[74], 1, __nullcTR[4], 4); // type 'short[]' members
	__nullcRegisterMembers(__nullcTR[78], 1, __nullcTR[4], 4); // type 'float[]' members
	__nullcRegisterMembers(__nullcTR[80], 1, __nullcTR[4], 4); // type 'double[]' members
	__nullcRegisterMembers(__nullcTR[95], 1, __nullcTR[17], 0); // type 'const_string' members
	__nullcRegisterMembers(__nullcTR[113], 0); // type '__FinalizeProxy' members
	__nullcRegisterMembers(__nullcTR[142], 1, __nullcTR[17], 0); // type 'string' members

	// Register globals

	// Register functions
	__nullcFR[0] = __nullcRegisterFunction("assert_void_ref_int_", (void*)assert_void_ref_int_, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[1] = __nullcRegisterFunction("assert_void_ref_int_char___", (void*)assert_void_ref_int_char___, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[2] = __nullcRegisterFunction("__operatorEqual_int_ref_char___char___", (void*)__operatorEqual_int_ref_char___char___, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[3] = __nullcRegisterFunction("__operatorNEqual_int_ref_char___char___", (void*)__operatorNEqual_int_ref_char___char___, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[4] = __nullcRegisterFunction("__operatorAdd_char___ref_char___char___", (void*)__operatorAdd_char___ref_char___char___, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[5] = __nullcRegisterFunction("__operatorAddSet_char___ref_char___ref_char___", (void*)__operatorAddSet_char___ref_char___ref_char___, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[6] = __nullcRegisterFunction("bool_bool_ref_bool_", (void*)bool_bool_ref_bool_, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[7] = __nullcRegisterFunction("char_char_ref_char_", (void*)char_char_ref_char_, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[8] = __nullcRegisterFunction("short_short_ref_short_", (void*)short_short_ref_short_, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[9] = __nullcRegisterFunction("int_int_ref_int_", (void*)int_int_ref_int_, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[10] = __nullcRegisterFunction("long_long_ref_long_", (void*)long_long_ref_long_, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[11] = __nullcRegisterFunction("float_float_ref_float_", (void*)float_float_ref_float_, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[12] = __nullcRegisterFunction("double_double_ref_double_", (void*)double_double_ref_double_, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[13] = __nullcRegisterFunction("bool__bool_void_ref_bool_", (void*)bool__bool_void_ref_bool_, __nullcTR[30], FunctionCategory::THISCALL);
	__nullcFR[14] = __nullcRegisterFunction("char__char_void_ref_char_", (void*)char__char_void_ref_char_, __nullcTR[32], FunctionCategory::THISCALL);
	__nullcFR[15] = __nullcRegisterFunction("short__short_void_ref_short_", (void*)short__short_void_ref_short_, __nullcTR[34], FunctionCategory::THISCALL);
	__nullcFR[16] = __nullcRegisterFunction("int__int_void_ref_int_", (void*)int__int_void_ref_int_, __nullcTR[36], FunctionCategory::THISCALL);
	__nullcFR[17] = __nullcRegisterFunction("long__long_void_ref_long_", (void*)long__long_void_ref_long_, __nullcTR[37], FunctionCategory::THISCALL);
	__nullcFR[18] = __nullcRegisterFunction("float__float_void_ref_float_", (void*)float__float_void_ref_float_, __nullcTR[39], FunctionCategory::THISCALL);
	__nullcFR[19] = __nullcRegisterFunction("double__double_void_ref_double_", (void*)double__double_void_ref_double_, __nullcTR[41], FunctionCategory::THISCALL);
	__nullcFR[20] = __nullcRegisterFunction("as_unsigned_int_ref_char_", (void*)as_unsigned_int_ref_char_, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[21] = __nullcRegisterFunction("as_unsigned_int_ref_short_", (void*)as_unsigned_int_ref_short_, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[22] = __nullcRegisterFunction("as_unsigned_long_ref_int_", (void*)as_unsigned_long_ref_int_, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[23] = __nullcRegisterFunction("short_short_ref_char___", (void*)short_short_ref_char___, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[24] = __nullcRegisterFunction("short__short_void_ref_char___", (void*)short__short_void_ref_char___, __nullcTR[34], FunctionCategory::THISCALL);
	__nullcFR[25] = __nullcRegisterFunction("short__str_char___ref__", (void*)short__str_char___ref__, __nullcTR[34], FunctionCategory::THISCALL);
	__nullcFR[26] = __nullcRegisterFunction("int_int_ref_char___", (void*)int_int_ref_char___, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[27] = __nullcRegisterFunction("int__int_void_ref_char___", (void*)int__int_void_ref_char___, __nullcTR[36], FunctionCategory::THISCALL);
	__nullcFR[28] = __nullcRegisterFunction("int__str_char___ref__", (void*)int__str_char___ref__, __nullcTR[36], FunctionCategory::THISCALL);
	__nullcFR[29] = __nullcRegisterFunction("long_long_ref_char___", (void*)long_long_ref_char___, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[30] = __nullcRegisterFunction("long__long_void_ref_char___", (void*)long__long_void_ref_char___, __nullcTR[37], FunctionCategory::THISCALL);
	__nullcFR[31] = __nullcRegisterFunction("long__str_char___ref__", (void*)long__str_char___ref__, __nullcTR[37], FunctionCategory::THISCALL);
	__nullcFR[32] = __nullcRegisterFunction("float_float_ref_char___", (void*)float_float_ref_char___, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[33] = __nullcRegisterFunction("float__float_void_ref_char___", (void*)float__float_void_ref_char___, __nullcTR[39], FunctionCategory::THISCALL);
	__nullcFR[34] = __nullcRegisterFunction("float__str_char___ref_int_bool_", (void*)float__str_char___ref_int_bool_, __nullcTR[39], FunctionCategory::THISCALL);
	__nullcFR[35] = __nullcRegisterFunction("double_double_ref_char___", (void*)double_double_ref_char___, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[36] = __nullcRegisterFunction("double__double_void_ref_char___", (void*)double__double_void_ref_char___, __nullcTR[41], FunctionCategory::THISCALL);
	__nullcFR[37] = __nullcRegisterFunction("double__str_char___ref_int_bool_", (void*)double__str_char___ref_int_bool_, __nullcTR[41], FunctionCategory::THISCALL);
	__nullcFR[38] = __nullcRegisterFunction("__newS_void_ref_ref_int_int_", (void*)__newS_void_ref_ref_int_int_, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[39] = __nullcRegisterFunction("__newA_int___ref_int_int_int_", (void*)__newA_int___ref_int_int_int_, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[40] = __nullcRegisterFunction("duplicate_auto_ref_ref_auto_ref_", (void*)duplicate_auto_ref_ref_auto_ref_, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[41] = __nullcRegisterFunction("__duplicate_array_void_ref_auto___ref_auto___", (void*)__duplicate_array_void_ref_auto___ref_auto___, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[42] = __nullcRegisterFunction("duplicate_auto___ref_auto___", (void*)duplicate_auto___ref_auto___, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[43] = __nullcRegisterFunction("replace_auto_ref_ref_auto_ref_auto_ref_", (void*)replace_auto_ref_ref_auto_ref_auto_ref_, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[44] = __nullcRegisterFunction("swap_void_ref_auto_ref_auto_ref_", (void*)swap_void_ref_auto_ref_auto_ref_, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[45] = __nullcRegisterFunction("equal_int_ref_auto_ref_auto_ref_", (void*)equal_int_ref_auto_ref_auto_ref_, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[46] = __nullcRegisterFunction("assign_void_ref_auto_ref_auto_ref_", (void*)assign_void_ref_auto_ref_auto_ref_, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[47] = __nullcRegisterFunction("array_copy_void_ref_auto___auto___", (void*)array_copy_void_ref_auto___auto___, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[48] = 0; // generic function 'array_copy'
	__nullcFR[49] = __nullcRegisterFunction("__redirect_void_ref___ref_auto_ref___function___ref_", (void*)__redirect_void_ref___ref_auto_ref___function___ref_, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[50] = __nullcRegisterFunction("__redirect_ptr_void_ref___ref_auto_ref___function___ref_", (void*)__redirect_ptr_void_ref___ref_auto_ref___function___ref_, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[51] = __nullcRegisterFunction("__operatorSet_char___ref_ref_char___ref_int___", (void*)__operatorSet_char___ref_ref_char___ref_int___, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[52] = __nullcRegisterFunction("__operatorSet_short___ref_ref_short___ref_int___", (void*)__operatorSet_short___ref_ref_short___ref_int___, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[53] = __nullcRegisterFunction("__operatorSet_float___ref_ref_float___ref_double___", (void*)__operatorSet_float___ref_ref_float___ref_double___, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[54] = __nullcRegisterFunction("typeid_typeid_ref_auto_ref_", (void*)typeid_typeid_ref_auto_ref_, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[55] = __nullcRegisterFunction("typeid__size__int_ref___", (void*)typeid__size__int_ref___, __nullcTR[85], FunctionCategory::THISCALL);
	__nullcFR[56] = __nullcRegisterFunction("__operatorEqual_int_ref_typeid_typeid_", (void*)__operatorEqual_int_ref_typeid_typeid_, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[57] = __nullcRegisterFunction("__operatorNEqual_int_ref_typeid_typeid_", (void*)__operatorNEqual_int_ref_typeid_typeid_, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[58] = __nullcRegisterFunction("__rcomp_int_ref_auto_ref_auto_ref_", (void*)__rcomp_int_ref_auto_ref_auto_ref_, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[59] = __nullcRegisterFunction("__rncomp_int_ref_auto_ref_auto_ref_", (void*)__rncomp_int_ref_auto_ref_auto_ref_, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[60] = __nullcRegisterFunction("__operatorLess_bool_ref_auto_ref_auto_ref_", (void*)__operatorLess_bool_ref_auto_ref_auto_ref_, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[61] = __nullcRegisterFunction("__operatorLEqual_bool_ref_auto_ref_auto_ref_", (void*)__operatorLEqual_bool_ref_auto_ref_auto_ref_, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[62] = __nullcRegisterFunction("__operatorGreater_bool_ref_auto_ref_auto_ref_", (void*)__operatorGreater_bool_ref_auto_ref_auto_ref_, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[63] = __nullcRegisterFunction("__operatorGEqual_bool_ref_auto_ref_auto_ref_", (void*)__operatorGEqual_bool_ref_auto_ref_auto_ref_, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[64] = __nullcRegisterFunction("hash_value_int_ref_auto_ref_", (void*)hash_value_int_ref_auto_ref_, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[65] = __nullcRegisterFunction("__pcomp_int_ref_void_ref_int__void_ref_int__", (void*)__pcomp_int_ref_void_ref_int__void_ref_int__, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[66] = __nullcRegisterFunction("__pncomp_int_ref_void_ref_int__void_ref_int__", (void*)__pncomp_int_ref_void_ref_int__void_ref_int__, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[67] = __nullcRegisterFunction("__acomp_int_ref_auto___auto___", (void*)__acomp_int_ref_auto___auto___, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[68] = __nullcRegisterFunction("__ancomp_int_ref_auto___auto___", (void*)__ancomp_int_ref_auto___auto___, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[69] = __nullcRegisterFunction("__typeCount_int_ref__", (void*)__typeCount_int_ref__, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[70] = __nullcRegisterFunction("__operatorSet_auto___ref_ref_auto___ref_auto_ref_", (void*)__operatorSet_auto___ref_ref_auto___ref_auto_ref_, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[71] = __nullcRegisterFunction("__aaassignrev_auto_ref_ref_auto_ref_auto___ref_", (void*)__aaassignrev_auto_ref_ref_auto_ref_auto___ref_, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[72] = __nullcRegisterFunction("__operatorIndex_auto_ref_ref_auto___ref_int_", (void*)__operatorIndex_auto_ref_ref_auto___ref_int_, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[73] = __nullcRegisterFunction("const_string__size__int_ref___", (void*)const_string__size__int_ref___, __nullcTR[96], FunctionCategory::THISCALL);
	__nullcFR[74] = __nullcRegisterFunction("__operatorSet_const_string_ref_ref_const_string_ref_char___", (void*)__operatorSet_const_string_ref_ref_const_string_ref_char___, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[75] = __nullcRegisterFunction("const_string_const_string_ref_char___", (void*)const_string_const_string_ref_char___, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[76] = __nullcRegisterFunction("__operatorIndex_char_ref_const_string_ref_int_", (void*)__operatorIndex_char_ref_const_string_ref_int_, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[77] = __nullcRegisterFunction("__operatorEqual_int_ref_const_string_const_string_", (void*)__operatorEqual_int_ref_const_string_const_string_, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[78] = __nullcRegisterFunction("__operatorEqual_int_ref_const_string_char___", (void*)__operatorEqual_int_ref_const_string_char___, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[79] = __nullcRegisterFunction("__operatorEqual_int_ref_char___const_string_", (void*)__operatorEqual_int_ref_char___const_string_, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[80] = __nullcRegisterFunction("__operatorNEqual_int_ref_const_string_const_string_", (void*)__operatorNEqual_int_ref_const_string_const_string_, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[81] = __nullcRegisterFunction("__operatorNEqual_int_ref_const_string_char___", (void*)__operatorNEqual_int_ref_const_string_char___, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[82] = __nullcRegisterFunction("__operatorNEqual_int_ref_char___const_string_", (void*)__operatorNEqual_int_ref_char___const_string_, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[83] = __nullcRegisterFunction("__operatorAdd_const_string_ref_const_string_const_string_", (void*)__operatorAdd_const_string_ref_const_string_const_string_, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[84] = __nullcRegisterFunction("__operatorAdd_const_string_ref_const_string_char___", (void*)__operatorAdd_const_string_ref_const_string_char___, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[85] = __nullcRegisterFunction("__operatorAdd_const_string_ref_char___const_string_", (void*)__operatorAdd_const_string_ref_char___const_string_, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[86] = __nullcRegisterFunction("isStackPointer_int_ref_auto_ref_", (void*)isStackPointer_int_ref_auto_ref_, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[87] = __nullcRegisterFunction("auto_array_impl_void_ref_auto___ref_typeid_int_", (void*)auto_array_impl_void_ref_auto___ref_typeid_int_, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[88] = __nullcRegisterFunction("auto_array_auto___ref_typeid_int_", (void*)auto_array_auto___ref_typeid_int_, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[89] = __nullcRegisterFunction("auto____set_void_ref_auto_ref_int_", (void*)auto____set_void_ref_auto_ref_int_, __nullcTR[59], FunctionCategory::THISCALL);
	__nullcFR[90] = __nullcRegisterFunction("__force_size_void_ref_auto___ref_int_", (void*)__force_size_void_ref_auto___ref_int_, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[91] = __nullcRegisterFunction("isCoroutineReset_int_ref_auto_ref_", (void*)isCoroutineReset_int_ref_auto_ref_, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[92] = __nullcRegisterFunction("__assertCoroutine_void_ref_auto_ref_", (void*)__assertCoroutine_void_ref_auto_ref_, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[93] = __nullcRegisterFunction("__getFinalizeList_auto_ref___ref__", (void*)__getFinalizeList_auto_ref___ref__, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[94] = __nullcRegisterFunction("__FinalizeProxy__finalize_void_ref__", (void*)__FinalizeProxy__finalize_void_ref__, __nullcTR[114], FunctionCategory::THISCALL);
	__nullcFR[95] = __nullcRegisterFunction("__finalizeObjects_void_ref__", (void*)__finalizeObjects_void_ref__, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[96] = 0; // generic function 'in'
	__nullcFR[97] = __nullcRegisterFunction("assert_derived_from_base_void_ref_ref_void_ref_typeid_", (void*)assert_derived_from_base_void_ref_ref_void_ref_typeid_, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[98] = 0; // generic function '__gen_list'
	__nullcFR[99] = 0; // generic function '__init_array'
	__nullcFR[100] = __nullcRegisterFunction("__closeUpvalue_void_ref_void_ref_ref_void_ref_int_int_", (void*)__closeUpvalue_void_ref_void_ref_ref_void_ref_int_int_, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[101] = __nullcRegisterFunction("float__str_610894668_precision__int_ref___", (void*)float__str_610894668_precision__int_ref___, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[102] = __nullcRegisterFunction("float__str_610894668_showExponent__bool_ref___", (void*)float__str_610894668_showExponent__bool_ref___, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[103] = __nullcRegisterFunction("double__str_610894668_precision__int_ref___", (void*)double__str_610894668_precision__int_ref___, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[104] = __nullcRegisterFunction("double__str_610894668_showExponent__bool_ref___", (void*)double__str_610894668_showExponent__bool_ref___, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[105] = __nullcRegisterFunction("strstr_int_ref_char___char___", (void*)strstr_int_ref_char___char___, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[106] = __nullcRegisterFunction("strchr_int_ref_char___char_", (void*)strchr_int_ref_char___char_, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[107] = __nullcRegisterFunction("strcmp_int_ref_char___char___", (void*)strcmp_int_ref_char___char___, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[108] = __nullcRegisterFunction("string__string_void_ref__", (void*)string__string_void_ref__, __nullcTR[143], FunctionCategory::THISCALL);
	__nullcFR[109] = __nullcRegisterFunction("string__string_void_ref_char___", (void*)string__string_void_ref_char___, __nullcTR[143], FunctionCategory::THISCALL);
	__nullcFR[110] = __nullcRegisterFunction("string__string_void_ref_int_char_", (void*)string__string_void_ref_int_char_, __nullcTR[143], FunctionCategory::THISCALL);
	__nullcFR[111] = __nullcRegisterFunction("string__string_void_ref_string_ref_", (void*)string__string_void_ref_string_ref_, __nullcTR[143], FunctionCategory::THISCALL);
	__nullcFR[112] = __nullcRegisterFunction("__operatorSet_string_ref_ref_string_ref_string_ref_", (void*)__operatorSet_string_ref_ref_string_ref_string_ref_, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[113] = __nullcRegisterFunction("__operatorSet_string_ref_ref_string_ref_char___", (void*)__operatorSet_string_ref_ref_string_ref_char___, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[114] = __nullcRegisterFunction("__operatorSet_string_ref_ref_string_ref_char_", (void*)__operatorSet_string_ref_ref_string_ref_char_, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[115] = __nullcRegisterFunction("string__size__int_ref___", (void*)string__size__int_ref___, __nullcTR[143], FunctionCategory::THISCALL);
	__nullcFR[116] = __nullcRegisterFunction("string__length_int_ref__", (void*)string__length_int_ref__, __nullcTR[143], FunctionCategory::THISCALL);
	__nullcFR[117] = __nullcRegisterFunction("string__clear_void_ref__", (void*)string__clear_void_ref__, __nullcTR[143], FunctionCategory::THISCALL);
	__nullcFR[118] = __nullcRegisterFunction("string__empty_bool_ref__", (void*)string__empty_bool_ref__, __nullcTR[143], FunctionCategory::THISCALL);
	__nullcFR[119] = __nullcRegisterFunction("__operatorIndex_char_ref_ref_string_ref_int_", (void*)__operatorIndex_char_ref_ref_string_ref_int_, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[120] = __nullcRegisterFunction("__operatorIndex_string_ref_string_ref_int_int_", (void*)__operatorIndex_string_ref_string_ref_int_int_, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[121] = __nullcRegisterFunction("string__front_char_ref_ref__", (void*)string__front_char_ref_ref__, __nullcTR[143], FunctionCategory::THISCALL);
	__nullcFR[122] = __nullcRegisterFunction("string__back_char_ref_ref__", (void*)string__back_char_ref_ref__, __nullcTR[143], FunctionCategory::THISCALL);
	__nullcFR[123] = __nullcRegisterFunction("__operatorAddSet_string_ref_ref_string_ref_string_ref_", (void*)__operatorAddSet_string_ref_ref_string_ref_string_ref_, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[124] = __nullcRegisterFunction("__operatorAddSet_string_ref_ref_string_ref_char___", (void*)__operatorAddSet_string_ref_ref_string_ref_char___, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[125] = __nullcRegisterFunction("string__insert_string_ref_ref_int_string_ref_", (void*)string__insert_string_ref_ref_int_string_ref_, __nullcTR[143], FunctionCategory::THISCALL);
	__nullcFR[126] = __nullcRegisterFunction("string__insert_string_ref_ref_int_char___", (void*)string__insert_string_ref_ref_int_char___, __nullcTR[143], FunctionCategory::THISCALL);
	__nullcFR[127] = __nullcRegisterFunction("string__insert_string_ref_ref_int_int_char_", (void*)string__insert_string_ref_ref_int_int_char_, __nullcTR[143], FunctionCategory::THISCALL);
	__nullcFR[128] = __nullcRegisterFunction("string__erase_string_ref_ref_int_int_", (void*)string__erase_string_ref_ref_int_int_, __nullcTR[143], FunctionCategory::THISCALL);
	__nullcFR[129] = __nullcRegisterFunction("string__replace_string_ref_ref_int_int_string_ref_", (void*)string__replace_string_ref_ref_int_int_string_ref_, __nullcTR[143], FunctionCategory::THISCALL);
	__nullcFR[130] = __nullcRegisterFunction("string__replace_string_ref_ref_int_int_char___", (void*)string__replace_string_ref_ref_int_int_char___, __nullcTR[143], FunctionCategory::THISCALL);
	__nullcFR[131] = __nullcRegisterFunction("string__replace_string_ref_ref_int_int_int_char_", (void*)string__replace_string_ref_ref_int_int_int_char_, __nullcTR[143], FunctionCategory::THISCALL);
	__nullcFR[132] = __nullcRegisterFunction("string__swap_void_ref_string_ref_", (void*)string__swap_void_ref_string_ref_, __nullcTR[143], FunctionCategory::THISCALL);
	__nullcFR[133] = __nullcRegisterFunction("string__swap_void_ref_char___", (void*)string__swap_void_ref_char___, __nullcTR[143], FunctionCategory::THISCALL);
	__nullcFR[134] = __nullcRegisterFunction("string__find_int_ref_string_ref_int_", (void*)string__find_int_ref_string_ref_int_, __nullcTR[143], FunctionCategory::THISCALL);
	__nullcFR[135] = __nullcRegisterFunction("string__find_int_ref_char___int_", (void*)string__find_int_ref_char___int_, __nullcTR[143], FunctionCategory::THISCALL);
	__nullcFR[136] = __nullcRegisterFunction("string__find_int_ref_char_int_", (void*)string__find_int_ref_char_int_, __nullcTR[143], FunctionCategory::THISCALL);
	__nullcFR[137] = __nullcRegisterFunction("string__rfind_int_ref_string_ref_int_", (void*)string__rfind_int_ref_string_ref_int_, __nullcTR[143], FunctionCategory::THISCALL);
	__nullcFR[138] = __nullcRegisterFunction("string__rfind_int_ref_char___int_", (void*)string__rfind_int_ref_char___int_, __nullcTR[143], FunctionCategory::THISCALL);
	__nullcFR[139] = __nullcRegisterFunction("string__rfind_int_ref_char_int_", (void*)string__rfind_int_ref_char_int_, __nullcTR[143], FunctionCategory::THISCALL);
	__nullcFR[140] = __nullcRegisterFunction("string__find_first_of_int_ref_string_ref_int_", (void*)string__find_first_of_int_ref_string_ref_int_, __nullcTR[143], FunctionCategory::THISCALL);
	__nullcFR[141] = __nullcRegisterFunction("string__find_first_of_int_ref_char___int_", (void*)string__find_first_of_int_ref_char___int_, __nullcTR[143], FunctionCategory::THISCALL);
	__nullcFR[142] = __nullcRegisterFunction("string__find_first_of_int_ref_char_int_", (void*)string__find_first_of_int_ref_char_int_, __nullcTR[143], FunctionCategory::THISCALL);
	__nullcFR[143] = __nullcRegisterFunction("string__find_last_of_int_ref_string_ref_int_", (void*)string__find_last_of_int_ref_string_ref_int_, __nullcTR[143], FunctionCategory::THISCALL);
	__nullcFR[144] = __nullcRegisterFunction("string__find_last_of_int_ref_char___int_", (void*)string__find_last_of_int_ref_char___int_, __nullcTR[143], FunctionCategory::THISCALL);
	__nullcFR[145] = __nullcRegisterFunction("string__find_last_of_int_ref_char_int_", (void*)string__find_last_of_int_ref_char_int_, __nullcTR[143], FunctionCategory::THISCALL);
	__nullcFR[146] = __nullcRegisterFunction("string__find_first_not_of_int_ref_string_ref_int_", (void*)string__find_first_not_of_int_ref_string_ref_int_, __nullcTR[143], FunctionCategory::THISCALL);
	__nullcFR[147] = __nullcRegisterFunction("string__find_first_not_of_int_ref_char___int_", (void*)string__find_first_not_of_int_ref_char___int_, __nullcTR[143], FunctionCategory::THISCALL);
	__nullcFR[148] = __nullcRegisterFunction("string__find_first_not_of_int_ref_char_int_", (void*)string__find_first_not_of_int_ref_char_int_, __nullcTR[143], FunctionCategory::THISCALL);
	__nullcFR[149] = __nullcRegisterFunction("string__find_last_not_of_int_ref_string_ref_int_", (void*)string__find_last_not_of_int_ref_string_ref_int_, __nullcTR[143], FunctionCategory::THISCALL);
	__nullcFR[150] = __nullcRegisterFunction("string__find_last_not_of_int_ref_char___int_", (void*)string__find_last_not_of_int_ref_char___int_, __nullcTR[143], FunctionCategory::THISCALL);
	__nullcFR[151] = __nullcRegisterFunction("string__find_last_not_of_int_ref_char_int_", (void*)string__find_last_not_of_int_ref_char_int_, __nullcTR[143], FunctionCategory::THISCALL);
	__nullcFR[152] = __nullcRegisterFunction("in_bool_ref_char_string_ref_", (void*)in_bool_ref_char_string_ref_, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[153] = __nullcRegisterFunction("string__substr_string_ref_int_int_", (void*)string__substr_string_ref_int_int_, __nullcTR[143], FunctionCategory::THISCALL);
	__nullcFR[154] = __nullcRegisterFunction("__operatorAdd_string_ref_string_ref_string_ref_", (void*)__operatorAdd_string_ref_string_ref_string_ref_, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[155] = __nullcRegisterFunction("__operatorAdd_string_ref_char___string_ref_", (void*)__operatorAdd_string_ref_char___string_ref_, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[156] = __nullcRegisterFunction("__operatorAdd_string_ref_string_ref_char___", (void*)__operatorAdd_string_ref_string_ref_char___, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[157] = __nullcRegisterFunction("__operatorEqual_bool_ref_string_ref_string_ref_", (void*)__operatorEqual_bool_ref_string_ref_string_ref_, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[158] = __nullcRegisterFunction("__operatorEqual_bool_ref_string_ref_char___", (void*)__operatorEqual_bool_ref_string_ref_char___, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[159] = __nullcRegisterFunction("__operatorEqual_bool_ref_char___string_ref_", (void*)__operatorEqual_bool_ref_char___string_ref_, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[160] = __nullcRegisterFunction("__operatorNEqual_bool_ref_string_ref_string_ref_", (void*)__operatorNEqual_bool_ref_string_ref_string_ref_, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[161] = __nullcRegisterFunction("__operatorNEqual_bool_ref_string_ref_char___", (void*)__operatorNEqual_bool_ref_string_ref_char___, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[162] = __nullcRegisterFunction("__operatorNEqual_bool_ref_char___string_ref_", (void*)__operatorNEqual_bool_ref_char___string_ref_, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[163] = __nullcRegisterFunction("string__erase_3081620873_length__int_ref___", (void*)string__erase_3081620873_length__int_ref___, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[164] = __nullcRegisterFunction("string__find_2424387209_offset__int_ref___", (void*)string__find_2424387209_offset__int_ref___, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[165] = __nullcRegisterFunction("string__find_1089031307_offset__int_ref___", (void*)string__find_1089031307_offset__int_ref___, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[166] = __nullcRegisterFunction("string__find_28588211_offset__int_ref___", (void*)string__find_28588211_offset__int_ref___, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[167] = __nullcRegisterFunction("string__rfind_2424387209_offset__int_ref___", (void*)string__rfind_2424387209_offset__int_ref___, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[168] = __nullcRegisterFunction("string__rfind_1089031307_offset__int_ref___", (void*)string__rfind_1089031307_offset__int_ref___, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[169] = __nullcRegisterFunction("string__rfind_28588211_offset__int_ref___", (void*)string__rfind_28588211_offset__int_ref___, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[170] = __nullcRegisterFunction("string__find_first_of_2424387209_offset__int_ref___", (void*)string__find_first_of_2424387209_offset__int_ref___, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[171] = __nullcRegisterFunction("string__find_first_of_1089031307_offset__int_ref___", (void*)string__find_first_of_1089031307_offset__int_ref___, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[172] = __nullcRegisterFunction("string__find_first_of_28588211_offset__int_ref___", (void*)string__find_first_of_28588211_offset__int_ref___, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[173] = __nullcRegisterFunction("string__find_last_of_2424387209_offset__int_ref___", (void*)string__find_last_of_2424387209_offset__int_ref___, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[174] = __nullcRegisterFunction("string__find_last_of_1089031307_offset__int_ref___", (void*)string__find_last_of_1089031307_offset__int_ref___, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[175] = __nullcRegisterFunction("string__find_last_of_28588211_offset__int_ref___", (void*)string__find_last_of_28588211_offset__int_ref___, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[176] = __nullcRegisterFunction("string__find_first_not_of_2424387209_offset__int_ref___", (void*)string__find_first_not_of_2424387209_offset__int_ref___, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[177] = __nullcRegisterFunction("string__find_first_not_of_1089031307_offset__int_ref___", (void*)string__find_first_not_of_1089031307_offset__int_ref___, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[178] = __nullcRegisterFunction("string__find_first_not_of_28588211_offset__int_ref___", (void*)string__find_first_not_of_28588211_offset__int_ref___, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[179] = __nullcRegisterFunction("string__find_last_not_of_2424387209_offset__int_ref___", (void*)string__find_last_not_of_2424387209_offset__int_ref___, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[180] = __nullcRegisterFunction("string__find_last_not_of_1089031307_offset__int_ref___", (void*)string__find_last_not_of_1089031307_offset__int_ref___, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[181] = __nullcRegisterFunction("string__find_last_not_of_28588211_offset__int_ref___", (void*)string__find_last_not_of_28588211_offset__int_ref___, __nullcTR[14], FunctionCategory::NORMAL);
	__nullcFR[182] = __nullcRegisterFunction("string__substr_536940012_length__int_ref___", (void*)string__substr_536940012_length__int_ref___, __nullcTR[14], FunctionCategory::NORMAL);

	// Setup
	{
	};

	// Expressions
	(
		(NULLCFuncPtr<__typeProxy_int_ref_char___char___>)__nullcMakeFunction(__nullcFR[105], 0), 
		(NULLCFuncPtr<__typeProxy_int_ref_char___char___>)__nullcMakeFunction(__nullcFR[105], (void*)0)
	);
	(
		(NULLCFuncPtr<__typeProxy_int_ref_char___char_>)__nullcMakeFunction(__nullcFR[106], 0), 
		(NULLCFuncPtr<__typeProxy_int_ref_char___char_>)__nullcMakeFunction(__nullcFR[106], (void*)0)
	);
	(
		(NULLCFuncPtr<__typeProxy_int_ref_char___char___>)__nullcMakeFunction(__nullcFR[107], 0), 
		(NULLCFuncPtr<__typeProxy_int_ref_char___char___>)__nullcMakeFunction(__nullcFR[107], (void*)0)
	);
	/* Definition of class 'string' */0;
	(NULLCFuncPtr<__typeProxy_void_ref__>)__nullcMakeFunction(__nullcFR[108], 0);
	(NULLCFuncPtr<__typeProxy_void_ref_char___>)__nullcMakeFunction(__nullcFR[109], 0);
	(NULLCFuncPtr<__typeProxy_void_ref_int_char_>)__nullcMakeFunction(__nullcFR[110], 0);
	(NULLCFuncPtr<__typeProxy_void_ref_string_ref_>)__nullcMakeFunction(__nullcFR[111], 0);
	(
		(NULLCFuncPtr<__typeProxy_string_ref_ref_string_ref_string_ref_>)__nullcMakeFunction(__nullcFR[112], 0), 
		(NULLCFuncPtr<__typeProxy_string_ref_ref_string_ref_string_ref_>)__nullcMakeFunction(__nullcFR[112], (void*)0)
	);
	(
		(NULLCFuncPtr<__typeProxy_string_ref_ref_string_ref_char___>)__nullcMakeFunction(__nullcFR[113], 0), 
		(NULLCFuncPtr<__typeProxy_string_ref_ref_string_ref_char___>)__nullcMakeFunction(__nullcFR[113], (void*)0)
	);
	(
		(NULLCFuncPtr<__typeProxy_string_ref_ref_string_ref_char_>)__nullcMakeFunction(__nullcFR[114], 0), 
		(NULLCFuncPtr<__typeProxy_string_ref_ref_string_ref_char_>)__nullcMakeFunction(__nullcFR[114], (void*)0)
	);
	(NULLCFuncPtr<__typeProxy_int_ref__>)__nullcMakeFunction(__nullcFR[115], 0);
	(NULLCFuncPtr<__typeProxy_int_ref__>)__nullcMakeFunction(__nullcFR[116], 0);
	(NULLCFuncPtr<__typeProxy_void_ref__>)__nullcMakeFunction(__nullcFR[117], 0);
	(NULLCFuncPtr<__typeProxy_bool_ref__>)__nullcMakeFunction(__nullcFR[118], 0);
	(
		(NULLCFuncPtr<__typeProxy_char_ref_ref_string_ref_int_>)__nullcMakeFunction(__nullcFR[119], 0), 
		(NULLCFuncPtr<__typeProxy_char_ref_ref_string_ref_int_>)__nullcMakeFunction(__nullcFR[119], (void*)0)
	);
	(
		(NULLCFuncPtr<__typeProxy_string_ref_string_ref_int_int_>)__nullcMakeFunction(__nullcFR[120], 0), 
		(NULLCFuncPtr<__typeProxy_string_ref_string_ref_int_int_>)__nullcMakeFunction(__nullcFR[120], (void*)0)
	);
	(NULLCFuncPtr<__typeProxy_char_ref_ref__>)__nullcMakeFunction(__nullcFR[121], 0);
	(NULLCFuncPtr<__typeProxy_char_ref_ref__>)__nullcMakeFunction(__nullcFR[122], 0);
	(
		(NULLCFuncPtr<__typeProxy_string_ref_ref_string_ref_string_ref_>)__nullcMakeFunction(__nullcFR[123], 0), 
		(NULLCFuncPtr<__typeProxy_string_ref_ref_string_ref_string_ref_>)__nullcMakeFunction(__nullcFR[123], (void*)0)
	);
	(
		(NULLCFuncPtr<__typeProxy_string_ref_ref_string_ref_char___>)__nullcMakeFunction(__nullcFR[124], 0), 
		(NULLCFuncPtr<__typeProxy_string_ref_ref_string_ref_char___>)__nullcMakeFunction(__nullcFR[124], (void*)0)
	);
	(NULLCFuncPtr<__typeProxy_string_ref_ref_int_string_ref_>)__nullcMakeFunction(__nullcFR[125], 0);
	(NULLCFuncPtr<__typeProxy_string_ref_ref_int_char___>)__nullcMakeFunction(__nullcFR[126], 0);
	(NULLCFuncPtr<__typeProxy_string_ref_ref_int_int_char_>)__nullcMakeFunction(__nullcFR[127], 0);
	(NULLCFuncPtr<__typeProxy_string_ref_ref_int_int_>)__nullcMakeFunction(__nullcFR[128], 0);
	(NULLCFuncPtr<__typeProxy_string_ref_ref_int_int_string_ref_>)__nullcMakeFunction(__nullcFR[129], 0);
	(NULLCFuncPtr<__typeProxy_string_ref_ref_int_int_char___>)__nullcMakeFunction(__nullcFR[130], 0);
	(NULLCFuncPtr<__typeProxy_string_ref_ref_int_int_int_char_>)__nullcMakeFunction(__nullcFR[131], 0);
	(NULLCFuncPtr<__typeProxy_void_ref_string_ref_>)__nullcMakeFunction(__nullcFR[132], 0);
	(NULLCFuncPtr<__typeProxy_void_ref_char___>)__nullcMakeFunction(__nullcFR[133], 0);
	(NULLCFuncPtr<__typeProxy_int_ref_string_ref_int_>)__nullcMakeFunction(__nullcFR[134], 0);
	(NULLCFuncPtr<__typeProxy_int_ref_char___int_>)__nullcMakeFunction(__nullcFR[135], 0);
	(NULLCFuncPtr<__typeProxy_int_ref_char_int_>)__nullcMakeFunction(__nullcFR[136], 0);
	(NULLCFuncPtr<__typeProxy_int_ref_string_ref_int_>)__nullcMakeFunction(__nullcFR[137], 0);
	(NULLCFuncPtr<__typeProxy_int_ref_char___int_>)__nullcMakeFunction(__nullcFR[138], 0);
	(NULLCFuncPtr<__typeProxy_int_ref_char_int_>)__nullcMakeFunction(__nullcFR[139], 0);
	(NULLCFuncPtr<__typeProxy_int_ref_string_ref_int_>)__nullcMakeFunction(__nullcFR[140], 0);
	(NULLCFuncPtr<__typeProxy_int_ref_char___int_>)__nullcMakeFunction(__nullcFR[141], 0);
	(NULLCFuncPtr<__typeProxy_int_ref_char_int_>)__nullcMakeFunction(__nullcFR[142], 0);
	(NULLCFuncPtr<__typeProxy_int_ref_string_ref_int_>)__nullcMakeFunction(__nullcFR[143], 0);
	(NULLCFuncPtr<__typeProxy_int_ref_char___int_>)__nullcMakeFunction(__nullcFR[144], 0);
	(NULLCFuncPtr<__typeProxy_int_ref_char_int_>)__nullcMakeFunction(__nullcFR[145], 0);
	(NULLCFuncPtr<__typeProxy_int_ref_string_ref_int_>)__nullcMakeFunction(__nullcFR[146], 0);
	(NULLCFuncPtr<__typeProxy_int_ref_char___int_>)__nullcMakeFunction(__nullcFR[147], 0);
	(NULLCFuncPtr<__typeProxy_int_ref_char_int_>)__nullcMakeFunction(__nullcFR[148], 0);
	(NULLCFuncPtr<__typeProxy_int_ref_string_ref_int_>)__nullcMakeFunction(__nullcFR[149], 0);
	(NULLCFuncPtr<__typeProxy_int_ref_char___int_>)__nullcMakeFunction(__nullcFR[150], 0);
	(NULLCFuncPtr<__typeProxy_int_ref_char_int_>)__nullcMakeFunction(__nullcFR[151], 0);
	(
		(NULLCFuncPtr<__typeProxy_bool_ref_char_string_ref_>)__nullcMakeFunction(__nullcFR[152], 0), 
		(NULLCFuncPtr<__typeProxy_bool_ref_char_string_ref_>)__nullcMakeFunction(__nullcFR[152], (void*)0)
	);
	(NULLCFuncPtr<__typeProxy_string_ref_int_int_>)__nullcMakeFunction(__nullcFR[153], 0);
	(
		(NULLCFuncPtr<__typeProxy_string_ref_string_ref_string_ref_>)__nullcMakeFunction(__nullcFR[154], 0), 
		(NULLCFuncPtr<__typeProxy_string_ref_string_ref_string_ref_>)__nullcMakeFunction(__nullcFR[154], (void*)0)
	);
	(
		(NULLCFuncPtr<__typeProxy_string_ref_char___string_ref_>)__nullcMakeFunction(__nullcFR[155], 0), 
		(NULLCFuncPtr<__typeProxy_string_ref_char___string_ref_>)__nullcMakeFunction(__nullcFR[155], (void*)0)
	);
	(
		(NULLCFuncPtr<__typeProxy_string_ref_string_ref_char___>)__nullcMakeFunction(__nullcFR[156], 0), 
		(NULLCFuncPtr<__typeProxy_string_ref_string_ref_char___>)__nullcMakeFunction(__nullcFR[156], (void*)0)
	);
	(
		(NULLCFuncPtr<__typeProxy_bool_ref_string_ref_string_ref_>)__nullcMakeFunction(__nullcFR[157], 0), 
		(NULLCFuncPtr<__typeProxy_bool_ref_string_ref_string_ref_>)__nullcMakeFunction(__nullcFR[157], (void*)0)
	);
	(
		(NULLCFuncPtr<__typeProxy_bool_ref_string_ref_char___>)__nullcMakeFunction(__nullcFR[158], 0), 
		(NULLCFuncPtr<__typeProxy_bool_ref_string_ref_char___>)__nullcMakeFunction(__nullcFR[158], (void*)0)
	);
	(
		(NULLCFuncPtr<__typeProxy_bool_ref_char___string_ref_>)__nullcMakeFunction(__nullcFR[159], 0), 
		(NULLCFuncPtr<__typeProxy_bool_ref_char___string_ref_>)__nullcMakeFunction(__nullcFR[159], (void*)0)
	);
	(
		(NULLCFuncPtr<__typeProxy_bool_ref_string_ref_string_ref_>)__nullcMakeFunction(__nullcFR[160], 0), 
		(NULLCFuncPtr<__typeProxy_bool_ref_string_ref_string_ref_>)__nullcMakeFunction(__nullcFR[160], (void*)0)
	);
	(
		(NULLCFuncPtr<__typeProxy_bool_ref_string_ref_char___>)__nullcMakeFunction(__nullcFR[161], 0), 
		(NULLCFuncPtr<__typeProxy_bool_ref_string_ref_char___>)__nullcMakeFunction(__nullcFR[161], (void*)0)
	);
	(
		(NULLCFuncPtr<__typeProxy_bool_ref_char___string_ref_>)__nullcMakeFunction(__nullcFR[162], 0), 
		(NULLCFuncPtr<__typeProxy_bool_ref_char___string_ref_>)__nullcMakeFunction(__nullcFR[162], (void*)0)
	);
	return 0;
}