src/scripting/fif.hpp - main - SneakBug8/Project-Alice

src/scripting/fif.hpp
9 934 строки367 KB
schombert
migration target functions
17 авг 2024, 13:20
17 авг 2024, 13:200a229e0
#pragma once
#include "unordered_dense.h"
#include <vector>
#include <optional>
#include <variant>
#include "stdint.h"
#include <string>
#include <string_view>
#include <assert.h>
#include <charconv>
#include <span>
#include <limits>

#ifdef _WIN64
#define USE_LLVM
#else
#endif

#ifdef USE_LLVM

#include "llvm-c/Core.h"
#include "llvm-c/Types.h"
#include "llvm-c/LLJIT.h"
#include "llvm-c/LLJITUtils.h"
#include "llvm-c/Analysis.h"
#include "llvm-c/Error.h"
#include "llvm-c/ExecutionEngine.h"
#include "llvm-c/Orc.h"
#include "llvm-c/OrcEE.h"
#include "llvm-c/Linker.h"
#include "llvm-c/lto.h"
#include "llvm-c/Support.h"
#include "llvm-c/Target.h"
#include "llvm-c/TargetMachine.h"
#include "llvm-c/Transforms/PassBuilder.h"

#ifdef _WIN64
#define NATIVE_CC LLVMCallConv::LLVMWin64CallConv
#else
#define NATIVE_CC LLVMCallConv::LLVMX8664SysVCallConv
#endif

#endif
namespace fif {

enum class stack_type {
	interpreter_stack = 0,
	bytecode_compiler = 1,
	llvm_compiler = 2
};

struct indirect_string_hash {
	using is_avalanching = void;
	using is_transparent = void;

	indirect_string_hash() {
	}
	auto operator()(std::string_view sv) const noexcept -> uint64_t {
		return ankerl::unordered_dense::detail::wyhash::hash(sv.data(), sv.size());
	}
	auto operator()(std::unique_ptr<char[]> const& str) const noexcept -> uint64_t {
		return ankerl::unordered_dense::detail::wyhash::hash(str.get(), std::string_view{ str.get() }.size());
	}
};
struct indirect_string_eq {
	using is_transparent = void;


	indirect_string_eq() {
	}

	bool operator()(std::unique_ptr<char[]> const& l, std::unique_ptr<char[]> const& r) const noexcept {
		return std::string_view{ l.get() } == std::string_view{ r.get() };
	}
	bool operator()(std::unique_ptr<char[]> const& l, std::string_view r) const noexcept {
		return std::string_view{ l.get() } == r;
	}
	bool operator()(std::string_view r, std::unique_ptr<char[]> const& l) const noexcept {
		return std::string_view{ l.get() } == r;
	}
	bool operator()(std::unique_ptr<char[]> const& l, std::string const& r) const noexcept {
		return std::string_view{ l.get() } == r;
	}
	bool operator()(std::string const& r, std::unique_ptr<char[]> const& l) const noexcept {
		return std::string_view{ l.get() } == r;
	}
};

#ifdef USE_LLVM
#else
#define LLVMValueRef void*
#define LLVMBasicBlockRef void*
#define LLVMTypeRef void*
#endif

class state_stack {
protected:
	std::vector<int32_t> main_types;
	std::vector<int32_t> return_types;
public:
	size_t min_main_depth = 0;
	size_t min_return_depth = 0;

	void mark_used_from_main(size_t count) {
		min_main_depth = std::min(std::max(main_types.size(), count) - count, min_main_depth);
	}
	void mark_used_from_return(size_t count) {
		min_return_depth = std::min(std::max(return_types.size(), count) - count, min_return_depth);
	}

	state_stack() = default;
	state_stack(state_stack&&) = default;
	state_stack(const state_stack&) = default;
	virtual ~state_stack() = default;

	virtual void pop_main() = 0;
	virtual void pop_return() = 0;
	virtual int64_t main_data(size_t index) const = 0;
	virtual int64_t return_data(size_t index) const = 0;
	virtual LLVMValueRef main_ex(size_t index) const = 0;
	virtual LLVMValueRef return_ex(size_t index) const = 0;
	virtual int64_t main_data_back(size_t index) const = 0;
	virtual int64_t return_data_back(size_t index) const = 0;
	virtual LLVMValueRef main_ex_back(size_t index) const = 0;
	virtual LLVMValueRef return_ex_back(size_t index) const = 0;
	virtual void set_main_data(size_t index, int64_t value) = 0;
	virtual void set_return_data(size_t index, int64_t value)  = 0;
	virtual void set_main_ex(size_t index, LLVMValueRef value)  = 0;
	virtual void set_return_ex(size_t index, LLVMValueRef value)  = 0;
	virtual void set_main_data_back(size_t index, int64_t value)  = 0;
	virtual void set_return_data_back(size_t index, int64_t value)  = 0;
	virtual void set_main_ex_back(size_t index, LLVMValueRef value)  = 0;
	virtual void set_return_ex_back(size_t index, LLVMValueRef value)  = 0;
	virtual stack_type get_type() const = 0;
	virtual void move_into(state_stack&& other) = 0;
	virtual void copy_into(state_stack const& other) = 0;
	virtual void push_back_main(int32_t type, int64_t data, LLVMValueRef expr) = 0;
	virtual void push_back_return(int32_t type, int64_t data, LLVMValueRef expr) = 0;
	virtual std::unique_ptr< state_stack> copy() const = 0;
	virtual void resize(size_t main_sz, size_t return_sz) = 0;

	size_t main_size() const {
		return main_types.size();
	}
	size_t return_size()const {
		return return_types.size();
	}
	int32_t main_type(size_t index) const {
		return std::abs(main_types[index]);
	}
	int32_t return_type(size_t index) const {
		return std::abs(return_types[index]);
	}
	int32_t main_type_back(size_t index) const {
		return std::abs(main_types[main_types.size() - (index + 1)]);
	}
	int32_t return_type_back(size_t index) const {
		return std::abs(return_types[return_types.size() - (index + 1)]);
	}
	void set_main_type(size_t index, int32_t type) {
		main_types[index] = type;
		min_main_depth = std::min(min_main_depth, index);
	}
	void set_return_type(size_t index, int32_t type) {
		return_types[index] = type;
		min_return_depth = std::min(min_return_depth, index);
	}
	void set_main_type_back(size_t index, int32_t type) {
		main_types[main_types.size() - (index + 1)] = type;
		min_main_depth = std::min(min_main_depth, main_types.size() - (index + 1));
	}
	void set_return_type_back(size_t index, int32_t type) {
		return_types[return_types.size() - (index + 1)] = type;
		min_return_depth = std::min(min_return_depth, return_types.size() - (index + 1));
	}
};

class llvm_stack : public state_stack {
public:
	std::vector<LLVMValueRef> main_exs;
	std::vector<LLVMValueRef> return_exs;

	virtual void pop_main() override {
		if(main_exs.empty())
			return;
		main_exs.pop_back();
		main_types.pop_back();
		min_main_depth = std::min(min_main_depth, main_types.size());
	}
	virtual void pop_return() override {
		if(return_exs.empty())
			return;
		return_exs.pop_back();
		return_types.pop_back();
		min_return_depth = std::min(min_return_depth, return_types.size());
	}
	virtual void resize(size_t main_sz, size_t return_sz) override {
		min_return_depth = std::min(min_return_depth, return_sz);
		min_main_depth = std::min(min_main_depth, main_sz);
		return_types.resize(return_sz);
		return_exs.resize(return_sz);
		main_types.resize(main_sz);
		main_exs.resize(main_sz);
	}
	virtual int64_t main_data(size_t index) const  override {
		return 0;
	}
	virtual int64_t return_data(size_t index) const override {
		return 0;
	}
	virtual LLVMValueRef main_ex(size_t index) const override {
		return main_exs[index];
	}
	virtual LLVMValueRef return_ex(size_t index) const override {
		return return_exs[index];
	}
	virtual int64_t main_data_back(size_t index)const override {
		return 0;
	}
	virtual int64_t return_data_back(size_t index)const override {
		return 0;
	}
	virtual LLVMValueRef main_ex_back(size_t index)const override {
		return main_exs[main_exs.size() - (index + 1)];
	}
	virtual LLVMValueRef return_ex_back(size_t index) const override {
		return return_exs[return_exs.size() - (index + 1)];
	}
	virtual void set_main_data(size_t index, int64_t value) override {
		min_main_depth = std::min(min_main_depth, index);
	}
	virtual void set_return_data(size_t index, int64_t value)override {
		min_return_depth = std::min(min_return_depth, index);
	}
	virtual void set_main_ex(size_t index, LLVMValueRef value) override {
		main_exs[index] = value;
		min_main_depth = std::min(min_main_depth, index);
	}
	virtual void set_return_ex(size_t index, LLVMValueRef value) override {
		return_exs[index] = value;
		min_return_depth = std::min(min_return_depth, index);
	}
	virtual void set_main_data_back(size_t index, int64_t value)override {
		min_main_depth = std::min(min_main_depth, main_types.size() - (index + 1));
	}
	virtual void set_return_data_back(size_t index, int64_t value) override {
		min_return_depth = std::min(min_return_depth, return_types.size() - (index + 1));
	}
	virtual void set_main_ex_back(size_t index, LLVMValueRef value)override {
		main_exs[main_exs.size() - (index + 1)] = value;
		min_main_depth = std::min(min_main_depth, main_types.size() - (index + 1));
	}
	virtual void set_return_ex_back(size_t index, LLVMValueRef value)override {
		return_exs[return_exs.size() - (index + 1)] = value;
		min_return_depth = std::min(min_return_depth, return_types.size() - (index + 1));
	}
	virtual stack_type get_type() const override {
		return stack_type::llvm_compiler;
	}
	virtual void move_into(state_stack&& other)override {
		if(other.get_type() != stack_type::llvm_compiler)
			std::abort();

		llvm_stack&& o = static_cast<llvm_stack&&>(other);
		main_exs = std::move(o.main_exs);
		return_exs = std::move(o.return_exs);
		main_types = std::move(o.main_types);
		return_types = std::move(o.return_types);
		min_main_depth = std::min(min_main_depth, o.min_main_depth);
		min_return_depth = std::min(min_return_depth, o.min_return_depth);
	}
	virtual void copy_into(state_stack const& other)override {
		if(other.get_type() != stack_type::llvm_compiler)
			std::abort();

		llvm_stack const& o = static_cast<llvm_stack const&>(other);
		main_exs = o.main_exs;
		return_exs = o.return_exs;
		main_types = o.main_types;
		return_types = o.return_types;
		min_main_depth = std::min(min_main_depth, o.min_main_depth);
		min_return_depth = std::min(min_return_depth, o.min_return_depth);
	}
	virtual void push_back_main(int32_t type, int64_t data, LLVMValueRef expr)override {
		main_exs.push_back(expr);
		main_types.push_back(type);
	}
	virtual void push_back_return(int32_t type, int64_t data, LLVMValueRef expr)override {
		return_exs.push_back(expr);
		return_types.push_back(type);
	}
	virtual std::unique_ptr<state_stack> copy() const override {
		auto temp_new = std::make_unique<llvm_stack>(*this);
		temp_new->min_main_depth = main_types.size();
		temp_new->min_return_depth = return_types.size();
		return temp_new;
	}
};

class type_stack : public state_stack {
public:
	virtual void pop_main() override {
		if(main_types.empty())
			return;
		main_types.pop_back();
		min_main_depth = std::min(min_main_depth, main_types.size());
	}
	virtual void pop_return()override {
		if(return_types.empty())
			return;
		return_types.pop_back();
		min_return_depth = std::min(min_return_depth, return_types.size());
	}
	virtual void resize(size_t main_sz, size_t return_sz) override {
		min_return_depth = std::min(min_return_depth, return_sz);
		min_main_depth = std::min(min_main_depth, main_sz);
		return_types.resize(return_sz);
		main_types.resize(main_sz);
	}
	virtual int64_t main_data(size_t index) const override {
		return 0;
	}
	virtual int64_t return_data(size_t index) const override {
		return 0;
	}
	virtual LLVMValueRef main_ex(size_t index) const override {
		return nullptr;
	}
	virtual LLVMValueRef return_ex(size_t index) const override {
		return nullptr;
	}
	virtual int64_t main_data_back(size_t index)const override {
		return 0;
	}
	virtual int64_t return_data_back(size_t index)const override {
		return 0;
	}
	virtual LLVMValueRef main_ex_back(size_t index)const override {
		return nullptr;
	}
	virtual LLVMValueRef return_ex_back(size_t index) const override {
		return nullptr;
	}
	virtual stack_type get_type() const override {
		return stack_type::bytecode_compiler;
	}
	virtual void set_main_data(size_t index, int64_t value)override {
		min_main_depth = std::min(min_main_depth, index);
	}
	virtual void set_return_data(size_t index, int64_t value) override {
		min_return_depth = std::min(min_return_depth, index);
	}
	virtual void set_main_ex(size_t index, LLVMValueRef value) override {
		min_main_depth = std::min(min_main_depth, index);
	}
	virtual void set_return_ex(size_t index, LLVMValueRef value)override {
		min_return_depth = std::min(min_return_depth, index);
	}
	virtual void set_main_data_back(size_t index, int64_t value) override {
		min_main_depth = std::min(min_main_depth, main_types.size() - (index + 1));
	}
	virtual void set_return_data_back(size_t index, int64_t value) override {
		min_return_depth = std::min(min_return_depth, return_types.size() - (index + 1));
	}
	virtual void set_main_ex_back(size_t index, LLVMValueRef value) override {
		min_main_depth = std::min(min_main_depth, main_types.size() - (index + 1));
	}
	virtual void set_return_ex_back(size_t index, LLVMValueRef value) override {
		min_return_depth = std::min(min_return_depth, return_types.size() - (index + 1));
	}
	virtual void move_into(state_stack&& other) override {
		if(other.get_type() != stack_type::bytecode_compiler)
			std::abort();

		type_stack&& o = static_cast<type_stack&&>(other);
		main_types = std::move(o.main_types);
		return_types = std::move(o.return_types);
		min_main_depth = std::min(min_main_depth, o.min_main_depth);
		min_return_depth = std::min(min_return_depth, o.min_return_depth);
	}
	virtual void copy_into(state_stack const& other) override {
		if(other.get_type() != stack_type::bytecode_compiler)
			std::abort();

		type_stack const& o = static_cast<type_stack const&>(other);
		main_types = o.main_types;
		return_types = o.return_types;
		min_main_depth = std::min(min_main_depth, o.min_main_depth);
		min_return_depth = std::min(min_return_depth, o.min_return_depth);
	}
	virtual void push_back_main(int32_t type, int64_t data, LLVMValueRef expr) override {
		main_types.push_back(type);
	}
	virtual void push_back_return(int32_t type, int64_t data, LLVMValueRef expr) override {
		return_types.push_back(type);
	}
	virtual std::unique_ptr<state_stack> copy() const override {
		auto temp_new = std::make_unique<type_stack>(*this);
		temp_new->min_main_depth = main_types.size();
		temp_new->min_return_depth = return_types.size();
		return temp_new;
	}
};


class environment;
struct type;

using fif_call = int32_t * (*)(state_stack&, int32_t*, environment*);

struct interpreted_word_instance {
	std::vector<int32_t> compiled_bytecode;
	LLVMValueRef llvm_function = nullptr;
	int32_t stack_types_start = 0;
	int32_t stack_types_count = 0;
	int32_t typechecking_level = 0;
	bool being_compiled = false;
	bool llvm_compilation_finished = false;
	bool is_imported_function = false;
};

struct compiled_word_instance {
	fif_call implementation = nullptr;
	int32_t stack_types_start = 0;
	int32_t stack_types_count = 0;
};

using word_types = std::variant<interpreted_word_instance, compiled_word_instance>;

struct word {
	std::vector<int32_t> instances;
	std::string source;
	int32_t specialization_of = -1;
	int32_t stack_types_start = 0;
	int32_t stack_types_count = 0;
	bool treat_as_base = false;
	bool immediate =  false;
	bool being_typechecked = false;
};

inline LLVMValueRef empty_type_fn(LLVMValueRef r, int32_t type, environment*) {
	return r;
}

#ifdef USE_LLVM
using llvm_zero_expr = LLVMValueRef (*)(LLVMContextRef, int32_t t, environment*);
#endif
using interpreter_zero_expr = int64_t(*)(int32_t t, environment*);
using interpreted_new = int64_t(*)();

struct type {
	static constexpr uint32_t FLAG_REFCOUNTED = 0x00000001;
	static constexpr uint32_t FLAG_SINGLE_MEMBER = 0x00000002;
	static constexpr uint32_t FLAG_TEMPLATE = 0x00000004;

#ifdef USE_LLVM
	LLVMTypeRef llvm_type = nullptr;
	llvm_zero_expr zero_constant = nullptr;
#else
	void* llvm_type = nullptr;
	void* zero_constant = nullptr;
#endif
	interpreter_zero_expr interpreter_zero = nullptr;

	int32_t type_slots = 0;
	int32_t non_member_types = 0;
	int32_t decomposed_types_start = 0;
	int32_t decomposed_types_count = 0;

	uint32_t flags = 0;

	bool refcounted_type() const {
		return (flags & FLAG_REFCOUNTED) != 0;
	}
	bool single_member_struct() const {
		return (flags & FLAG_SINGLE_MEMBER) != 0;
	}
	bool is_struct_template() const {
		return (flags & FLAG_TEMPLATE) != 0;
	}
};

constexpr inline int32_t fif_i32 = 0;
constexpr inline int32_t fif_f32 = 1;
constexpr inline int32_t fif_bool = 2;
constexpr inline int32_t fif_type = 3;
constexpr inline int32_t fif_i64 = 4;
constexpr inline int32_t fif_f64 = 5;
constexpr inline int32_t fif_u32 = 6;
constexpr inline int32_t fif_u64 = 7;
constexpr inline int32_t fif_i16 = 8;
constexpr inline int32_t fif_u16 = 9;
constexpr inline int32_t fif_i8 = 10;
constexpr inline int32_t fif_u8 = 11;
constexpr inline int32_t fif_nil = 12;
constexpr inline int32_t fif_ptr = 13;
constexpr inline int32_t fif_opaque_ptr = 14;
constexpr inline int32_t fif_struct = 15;

class environment;

class dictionary {
public:
	ankerl::unordered_dense::map<std::string, int32_t> words;
	ankerl::unordered_dense::map<std::string, int32_t> types;
	std::vector<word> word_array;
	std::vector<type> type_array;
	std::vector<word_types> all_instances;
	std::vector<int32_t> all_compiled;
	std::vector<int32_t> all_stack_types;

#ifdef USE_LLVM
	void ready_llvm_types(LLVMContextRef llvm_context) {
		type_array[fif_i32].llvm_type = LLVMInt32TypeInContext(llvm_context);
		type_array[fif_i32].zero_constant = +[](LLVMContextRef c, int32_t t, environment*) {
			return LLVMConstInt(LLVMInt32TypeInContext(c), 0, true);
		};
		type_array[fif_type].llvm_type = LLVMInt32TypeInContext(llvm_context);
		type_array[fif_type].zero_constant = +[](LLVMContextRef c, int32_t t, environment*) {
			return LLVMConstInt(LLVMInt32TypeInContext(c), 0, true);
		};
		type_array[fif_f32].llvm_type = LLVMFloatTypeInContext(llvm_context);
		type_array[fif_f32].zero_constant = +[](LLVMContextRef c, int32_t t, environment*) {
			return LLVMConstReal(LLVMFloatTypeInContext(c), 0.0);
		};
		type_array[fif_i64].llvm_type = LLVMInt64TypeInContext(llvm_context);
		type_array[fif_i64].zero_constant = +[](LLVMContextRef c, int32_t t, environment*) {
			return LLVMConstInt(LLVMInt64TypeInContext(c), 0, true);
		};
		type_array[fif_f64].llvm_type = LLVMDoubleTypeInContext(llvm_context);
		type_array[fif_f64].zero_constant = +[](LLVMContextRef c, int32_t t, environment*) {
			return LLVMConstReal(LLVMDoubleTypeInContext(c), 0.0);
		};
		type_array[fif_bool].llvm_type =  LLVMInt1TypeInContext(llvm_context);
		type_array[fif_bool].zero_constant = +[](LLVMContextRef c, int32_t t, environment*) {
			return LLVMConstInt(LLVMInt1TypeInContext(c), 0, true);
		};
		type_array[fif_u32].llvm_type = LLVMInt32TypeInContext(llvm_context);
		type_array[fif_u32].zero_constant = +[](LLVMContextRef c, int32_t t, environment*) {
			return LLVMConstInt(LLVMInt32TypeInContext(c), 0, false);
		};
		type_array[fif_u64].llvm_type = LLVMInt64TypeInContext(llvm_context);
		type_array[fif_u64].zero_constant = +[](LLVMContextRef c, int32_t t, environment*) {
			return LLVMConstInt(LLVMInt64TypeInContext(c), 0, false);
		};
		type_array[fif_u16].llvm_type = LLVMInt16TypeInContext(llvm_context);
		type_array[fif_u16].zero_constant = +[](LLVMContextRef c, int32_t t, environment*) {
			return LLVMConstInt(LLVMInt16TypeInContext(c), 0, false);
		};
		type_array[fif_u8].llvm_type = LLVMInt8TypeInContext(llvm_context);
		type_array[fif_u8].zero_constant = +[](LLVMContextRef c, int32_t t, environment*) {
			return LLVMConstInt(LLVMInt8TypeInContext(c), 0, false);
		};
		type_array[fif_i16].llvm_type = LLVMInt16TypeInContext(llvm_context);
		type_array[fif_i16].zero_constant = +[](LLVMContextRef c, int32_t t, environment*) {
			return LLVMConstInt(LLVMInt16TypeInContext(c), 0, true);
		};
		type_array[fif_i8].llvm_type = LLVMInt8TypeInContext(llvm_context);
		type_array[fif_i8].zero_constant = +[](LLVMContextRef c, int32_t t, environment*) {
			return LLVMConstInt(LLVMInt8TypeInContext(c), 0, true);
		};
		type_array[fif_nil].llvm_type = LLVMVoidTypeInContext(llvm_context);
		type_array[fif_nil].zero_constant = +[](LLVMContextRef c, int32_t t, environment*) {
			return LLVMGetUndef(LLVMVoidTypeInContext(c));
		};
		type_array[fif_ptr].llvm_type = LLVMPointerTypeInContext(llvm_context, 0);
		type_array[fif_ptr].zero_constant = +[](LLVMContextRef c, int32_t t, environment*) {
			return LLVMGetUndef(LLVMPointerTypeInContext(c, 0));
		};
		type_array[fif_opaque_ptr].llvm_type = LLVMPointerTypeInContext(llvm_context, 0);
		type_array[fif_opaque_ptr].zero_constant = +[](LLVMContextRef c, int32_t t, environment*) {
			return LLVMGetUndef(LLVMPointerTypeInContext(c, 0));
		};
		type_array[fif_struct].llvm_type = LLVMVoidTypeInContext(llvm_context);
		type_array[fif_struct].zero_constant = +[](LLVMContextRef c, int32_t t, environment*) {
			return LLVMGetUndef(LLVMVoidTypeInContext(c));
		};
	}
#endif
	dictionary() {
		types.insert_or_assign(std::string("i32"), fif_i32);
		type_array.push_back(type{ nullptr, nullptr, nullptr, 0, 0, 0, 0 });
		types.insert_or_assign(std::string("f32"), fif_f32);
		type_array.push_back(type{ nullptr, nullptr, nullptr, 0, 0, 0, 0 });
		types.insert_or_assign(std::string("bool"), fif_bool);
		type_array.push_back(type{ nullptr, nullptr, nullptr, 0, 0, 0, 0 });
		types.insert_or_assign(std::string("type"), fif_type);
		type_array.push_back(type{ nullptr, nullptr, nullptr, 0, 0, 0, 0 });
		types.insert_or_assign(std::string("i64"), fif_i64);
		type_array.push_back(type{ nullptr, nullptr, nullptr, 0, 0, 0, 0 });
		types.insert_or_assign(std::string("f64"), fif_f64);
		type_array.push_back(type{ nullptr, nullptr, nullptr, 0, 0, 0, 0 });
		types.insert_or_assign(std::string("u32"), fif_u32);
		type_array.push_back(type{ nullptr, nullptr, nullptr, 0, 0, 0, 0 });
		types.insert_or_assign(std::string("u64"), fif_u64);
		type_array.push_back(type{ nullptr, nullptr, nullptr, 0, 0, 0, 0 });
		types.insert_or_assign(std::string("i16"), fif_i16);
		type_array.push_back(type{ nullptr, nullptr, nullptr, 0, 0, 0, 0 });
		types.insert_or_assign(std::string("u16"), fif_u16);
		type_array.push_back(type{ nullptr, nullptr, nullptr, 0, 0, 0, 0 });
		types.insert_or_assign(std::string("i8"), fif_i8);
		type_array.push_back(type{ nullptr, nullptr, nullptr, 0, 0, 0, 0 });
		types.insert_or_assign(std::string("u8"), fif_u8);
		type_array.push_back(type{ nullptr, nullptr, nullptr, 0, 0, 0, 0 });
		types.insert_or_assign(std::string("nil"), fif_nil);
		type_array.push_back(type{ nullptr, nullptr, nullptr, 0, 0, 0, 0 });
		types.insert_or_assign(std::string("ptr"), fif_ptr);
		type_array.push_back(type{ nullptr, nullptr, nullptr, 1, 0, 0, 0 });
		types.insert_or_assign(std::string("opaque_ptr"), fif_nil);
		type_array.push_back(type{ nullptr, nullptr, nullptr, 0, 0, 0, 0 });
		types.insert_or_assign(std::string("struct"), fif_struct);
		type_array.push_back(type{ nullptr, nullptr, nullptr, 0, 0, 0, 0 });
	}
};


enum class control_structure : uint8_t {
	none, function, str_if, str_while_loop, str_do_loop, mode_switch, globals
};

class compiler_state;

struct typecheck_3_record {
	int32_t stack_height_added_at = 0;
	int32_t rstack_height_added_at = 0;
	int32_t stack_consumed = 0;
	int32_t rstack_consumed = 0;
};

struct var_data {
	int64_t data; // only in interpreter mode -- first so that we can treat the address as the data addres
	LLVMValueRef alloc; // only in llvm mode
	int32_t type;
};
struct let_data {
	int64_t data; // only in interpreter mode
	LLVMValueRef expression; // only in llvm mode
	int32_t type;
};

class opaque_compiler_data {
protected:
	opaque_compiler_data* parent = nullptr;
public:
	opaque_compiler_data(opaque_compiler_data* parent) : parent(parent) { }

	virtual ~opaque_compiler_data() = default;
	virtual control_structure get_type() {
		return control_structure::none;
	}
	virtual LLVMValueRef llvm_function() {
		return parent ? parent->llvm_function() : nullptr;
	}
	virtual LLVMBasicBlockRef* llvm_block() {
		return parent ? parent->llvm_block() : nullptr;
	}
	virtual int32_t word_id() {
		return parent ? parent->word_id() : -1;
	}
	virtual int32_t instance_id() {
		return parent ? parent->instance_id() : -1;
	}
	virtual std::vector<int32_t>* bytecode_compilation_progress() {
		return parent ? parent->bytecode_compilation_progress() : nullptr;
	}
	virtual ankerl::unordered_dense::map<uint64_t, typecheck_3_record>* typecheck_record() {
		return parent ? parent->typecheck_record() : nullptr;
	}
	virtual state_stack* working_state() {
		return parent ? parent->working_state() : nullptr;
	}
	virtual void set_working_state(std::unique_ptr<state_stack> p) {
		if(parent) 
			parent->set_working_state(std::move(p));
	}
	virtual bool finish(environment& env) {
		return true;
	}
	virtual var_data* get_var(std::string const& name) {
		return parent ? parent->get_var(name) : nullptr;
	}
	virtual let_data* get_let(std::string const& name) {
		return parent ? parent->get_let(name) : nullptr;
	}
	virtual var_data* create_var(std::string const& name, int32_t type) {
		return parent ? parent->create_var(name, type) : nullptr;
	}
	virtual let_data* create_let(std::string const& name, int32_t type, int64_t data, LLVMValueRef expression) {
		return parent ? parent->create_let(name, type, data, expression) : nullptr;
	}
	virtual std::vector<int32_t>* type_substitutions() {
		return parent ? parent->type_substitutions() : nullptr;
	}
};


class compiler_state {
public:
	std::unique_ptr<opaque_compiler_data> data;
};

enum class fif_mode {
	interpreting = 0,
	compiling_bytecode = 1,
	compiling_llvm = 2,
	terminated = 3,
	error = 4,
	typechecking_lvl_1 = 5,
	typechecking_lvl_2 = 6,
	typechecking_lvl_3 = 7,
	typechecking_lvl1_failed = 8,
	typechecking_lvl2_failed = 9,
	typechecking_lvl3_failed = 10
};

inline bool non_immediate_mode(fif_mode m) {
	return m != fif_mode::error && m != fif_mode::terminated && m != fif_mode::interpreting;
}
inline bool typechecking_mode(fif_mode m) {
	return m == fif_mode::typechecking_lvl_1 || m == fif_mode::typechecking_lvl_2 || m == fif_mode::typechecking_lvl_3
		|| m == fif_mode::typechecking_lvl1_failed || m == fif_mode::typechecking_lvl2_failed || m == fif_mode::typechecking_lvl3_failed;
}
inline bool typechecking_failed(fif_mode m) {
	return m == fif_mode::typechecking_lvl1_failed || m == fif_mode::typechecking_lvl2_failed || m == fif_mode::typechecking_lvl3_failed;
}
inline fif_mode reset_typechecking(fif_mode m) {
	if(m == fif_mode::typechecking_lvl1_failed)
		return fif_mode::typechecking_lvl_1;
	return m;
}
inline fif_mode fail_typechecking(fif_mode m) {
	if(m == fif_mode::typechecking_lvl_1)
		return fif_mode::typechecking_lvl1_failed;
	if(m == fif_mode::typechecking_lvl_2)
		return fif_mode::typechecking_lvl2_failed;
	if(m == fif_mode::typechecking_lvl_3)
		return fif_mode::typechecking_lvl3_failed;
	return m;
}
struct import_item {
	std::string name;
	void* ptr = nullptr;
};
class environment {
public:
	ankerl::unordered_dense::set<std::unique_ptr<char[]>, indirect_string_hash, indirect_string_eq> string_constants;
	std::vector<LLVMValueRef> exported_functions;
	std::vector<import_item> imported_functions;
#ifdef USE_LLVM
	LLVMOrcThreadSafeContextRef llvm_ts_context = nullptr;
	LLVMContextRef llvm_context = nullptr;
	LLVMModuleRef llvm_module = nullptr;
	LLVMBuilderRef llvm_builder = nullptr;
	LLVMTargetRef llvm_target = nullptr;
	LLVMTargetMachineRef llvm_target_machine = nullptr;
	LLVMTargetDataRef llvm_target_data = nullptr;
	LLVMOrcLLJITRef llvm_jit = nullptr;
	char* llvm_target_triple = nullptr;
	char* llvm_target_cpu = nullptr;
	char* llvm_target_cpu_features = nullptr;
#endif
	dictionary dict;

	std::vector<std::unique_ptr<opaque_compiler_data>> compiler_stack;
	std::vector<std::string_view> source_stack;

	fif_mode mode = fif_mode::interpreting;
	std::function<void(std::string_view)> report_error = [](std::string_view) { std::abort(); };

	environment();
	~environment() {
#ifdef USE_LLVM
		LLVMDisposeMessage(llvm_target_triple);
		LLVMDisposeMessage(llvm_target_cpu);
		LLVMDisposeMessage(llvm_target_cpu_features);

		if(llvm_jit)
			LLVMOrcDisposeLLJIT(llvm_jit);
		if(llvm_target_data)
			LLVMDisposeTargetData(llvm_target_data);
		if(llvm_target_machine)
			LLVMDisposeTargetMachine(llvm_target_machine);
		if(llvm_builder)
			LLVMDisposeBuilder(llvm_builder);
		if(llvm_module)
			LLVMDisposeModule(llvm_module);
		if(llvm_ts_context)
			LLVMOrcDisposeThreadSafeContext(llvm_ts_context);
#endif
	}

	std::string_view get_string_constant(std::string_view data) {
		if(auto it = string_constants.find(data); it != string_constants.end()) {
			return std::string_view{ it->get() };
		}
		std::unique_ptr<char[]> temp = std::unique_ptr<char[]>(new char[data.length() + 1 ]);
		memcpy(temp.get(), data.data(), data.length());
		temp.get()[data.length()] = 0;
		auto data_ptr = temp.get();
		string_constants.insert(std::move(temp));
		return std::string_view{ data_ptr };
	}
};

class compiler_globals_layer : public opaque_compiler_data {
public:
	ankerl::unordered_dense::map<std::string, std::unique_ptr<var_data>> global_vars;
	ankerl::unordered_dense::map<std::string, std::unique_ptr<let_data>> global_lets;
	environment& env;
	compiler_globals_layer(opaque_compiler_data* p, environment& env) : opaque_compiler_data(p), env(env) {
	}

	virtual control_structure get_type() override {
		return control_structure::globals;
	}

	var_data* get_global_var(std::string const& name) {
		if(auto it = global_vars.find(name); it != global_vars.end()) {
			return it->second.get();
		}
		return nullptr;
	}
	var_data* create_global_var(std::string const& name, int32_t type) {
		if(auto it = global_vars.find(name); it != global_vars.end()) {
			if(it->second->type == type)
				return it->second.get();
			else
				return nullptr;
		}
		auto added = global_vars.insert_or_assign(name, std::make_unique<var_data>());
		added.first->second->type = type;
		added.first->second->data = 0;
#ifdef USE_LLVM
		added.first->second->alloc = LLVMAddGlobal(env.llvm_module, env.dict.type_array[type].llvm_type, name.c_str());
		LLVMSetInitializer(added.first->second->alloc, env.dict.type_array[type].zero_constant(env.llvm_context, type, &env));
#endif
		return added.first->second.get();
	}
	let_data* get_global_let(std::string const& name) {
		if(auto it = global_lets.find(name); it != global_lets.end()) {
			return it->second.get();
		}
		return nullptr;
	}
	let_data* create_global_let(std::string const& name, int32_t type, int64_t data, LLVMValueRef expression) {
		if(auto it = global_lets.find(name); it != global_lets.end()) {
			return nullptr;
		}
		auto added = global_lets.insert_or_assign(name, std::make_unique<let_data>());
		added.first->second->type = type;
		added.first->second->data = data;
		added.first->second->expression = expression;
		if(auto it = global_lets.find(name); it != global_lets.end()) {
			return it->second.get();
		}
		return nullptr;
	}
};

inline environment::environment() {
#ifdef USE_LLVM
	llvm_ts_context = LLVMOrcCreateNewThreadSafeContext();
	llvm_context = LLVMOrcThreadSafeContextGetContext(llvm_ts_context);
	llvm_module = LLVMModuleCreateWithNameInContext("module_main", llvm_context);
	llvm_builder = LLVMCreateBuilderInContext(llvm_context);

	LLVMInitializeNativeTarget();
	LLVMInitializeNativeAsmPrinter();

	llvm_target = LLVMGetFirstTarget();
	llvm_target_triple = LLVMGetDefaultTargetTriple();
	llvm_target_cpu = LLVMGetHostCPUName();
	llvm_target_cpu_features = LLVMGetHostCPUFeatures();

	llvm_target_machine = LLVMCreateTargetMachine(llvm_target, llvm_target_triple, llvm_target_cpu, llvm_target_cpu_features, LLVMCodeGenOptLevel::LLVMCodeGenLevelAggressive, LLVMRelocMode::LLVMRelocDefault, LLVMCodeModel::LLVMCodeModelJITDefault);

	LLVMSetTarget(llvm_module, llvm_target_triple);
	llvm_target_data = LLVMCreateTargetDataLayout(llvm_target_machine);
	LLVMSetModuleDataLayout(llvm_module, llvm_target_data);

	dict.ready_llvm_types(llvm_context);
#endif

	compiler_stack.push_back(std::make_unique<compiler_globals_layer>(nullptr, *this));
}

class interpreter_stack : public state_stack {
public:
	std::vector<int64_t> main_datas;
	std::vector<int64_t> return_datas;

	interpreter_stack() { }

	virtual void pop_main() override {
		if(main_datas.empty())
			return;

		main_datas.pop_back();
		main_types.pop_back();

		min_main_depth = std::min(min_main_depth, main_types.size());
	}
	virtual void pop_return() override {
		if(return_datas.empty())
			return;

		return_datas.pop_back();
		return_types.pop_back();

		min_return_depth = std::min(min_return_depth, return_types.size());
	}
	virtual void resize(size_t main_sz, size_t return_sz) override {
		min_return_depth = std::min(min_return_depth, return_sz);
		min_main_depth = std::min(min_main_depth, main_sz);

		return_types.resize(return_sz);
		return_datas.resize(return_sz);
		main_types.resize(main_sz);
		main_datas.resize(main_sz);
	}
	virtual int64_t main_data(size_t index) const override {
		return main_datas[index];
	}
	virtual int64_t return_data(size_t index) const override {
		return return_datas[index];
	}
	virtual LLVMValueRef main_ex(size_t index) const override {
		return nullptr;
	}
	virtual LLVMValueRef return_ex(size_t index) const override {
		return nullptr;
	}
	virtual int64_t main_data_back(size_t index)const override {
		return main_datas[main_datas.size() - (index + 1)];
	}
	virtual int64_t return_data_back(size_t index)const override {
		return return_datas[return_datas.size() - (index + 1)];
	}
	virtual LLVMValueRef main_ex_back(size_t index)const override {
		return nullptr;
	}
	virtual LLVMValueRef return_ex_back(size_t index) const override {
		return nullptr;
	}
	virtual void set_main_data(size_t index, int64_t value) override {
		main_datas[index] = value;
		min_main_depth = std::min(min_main_depth, index);
	}
	virtual void set_return_data(size_t index, int64_t value) override {
		return_datas[index] = value;
		min_return_depth = std::min(min_return_depth, index);
	}
	virtual void set_main_ex(size_t index, LLVMValueRef value)override {
		min_main_depth = std::min(min_main_depth, index);
	}
	virtual void set_return_ex(size_t index, LLVMValueRef value)override {
		min_return_depth = std::min(min_return_depth, index);
	}
	virtual void set_main_data_back(size_t index, int64_t value) override {
		main_datas[main_datas.size() - (index + 1)] = value;
		min_main_depth = std::min(min_main_depth, main_datas.size() - (index + 1));
	}
	virtual void set_return_data_back(size_t index, int64_t value) override {
		return_datas[return_datas.size() - (index + 1)] = value;
		min_return_depth = std::min(min_return_depth, return_datas.size() - (index + 1));
	}
	virtual void set_main_ex_back(size_t index, LLVMValueRef value) override {
		min_main_depth = std::min(min_main_depth, main_datas.size() - (index + 1));
	}
	virtual void set_return_ex_back(size_t index, LLVMValueRef value) override {
		min_return_depth = std::min(min_return_depth, return_datas.size() - (index + 1));
	}
	virtual stack_type get_type() const override {
		return stack_type::interpreter_stack;
	}
	virtual void move_into(state_stack&& other) override {
		if(other.get_type() != stack_type::interpreter_stack)
			std::abort();

		interpreter_stack&& o = static_cast<interpreter_stack&&>(other);
		main_datas = std::move(o.main_datas);
		return_datas = std::move(o.return_datas);
		main_types = std::move(o.main_types);
		return_types = std::move(o.return_types);
		min_main_depth = std::min(min_main_depth, o.min_main_depth);
		min_return_depth = std::min(min_return_depth, o.min_return_depth);
		o.main_datas.clear();
		o.return_datas.clear();
		o.main_types.clear();
		o.return_types.clear();
	}
	virtual void copy_into(state_stack const& other) override {
		if(other.get_type() != stack_type::interpreter_stack)
			std::abort();
		interpreter_stack const& o = static_cast<interpreter_stack const&>(other);
		main_datas = o.main_datas;
		return_datas = o.return_datas;
		main_types = o.main_types;
		return_types = o.return_types;
		min_main_depth = std::min(min_main_depth, o.min_main_depth);
		min_return_depth = std::min(min_return_depth, o.min_return_depth);
	}
	virtual void push_back_main(int32_t type, int64_t data, LLVMValueRef expr) override {
		main_datas.push_back(data);
		main_types.push_back(type);
	}
	virtual void push_back_return(int32_t type, int64_t data, LLVMValueRef expr) override {
		return_datas.push_back(data);
		return_types.push_back(type);
	}
	virtual std::unique_ptr<state_stack> copy() const override {
		auto temp_new = std::make_unique< interpreter_stack>(*this);
		temp_new->min_main_depth = main_types.size();
		temp_new->min_return_depth = return_types.size();
		return temp_new;
	}
};

inline std::string word_name_from_id(int32_t w, environment const& e) {
	for(auto& p : e.dict.words) {
		if(p.second == w)
			return p.first;
	}
	return "@unknown (" + std::to_string(w)  + ")";
}

inline int32_t* illegal_interpretation(state_stack& s, int32_t* p, environment* e) {
	e->report_error("attempted to perform an illegal operation under interpretation");
	e->mode = fif_mode::error;
	return nullptr;
}

struct type_match_result {
	bool matched = false;
	int32_t stack_consumed = 0;
	int32_t ret_stack_consumed = 0;
};
struct type_match {
	int32_t type = 0;
	uint32_t end_match_pos = 0;
};


inline bool is_positive_integer(char const* start, char const* end) {
	if(start == end)
		return false;
	while(start < end) {
		if(!isdigit(*start))
			return false;
		++start;
	}
	return true;
}

inline bool is_integer(char const* start, char const* end) {
	if(start == end)
		return false;
	if(*start == '-')
		return is_positive_integer(start + 1, end);
	else
		return is_positive_integer(start, end);
}

inline bool is_positive_fp(char const* start, char const* end) {
	auto const decimal = std::find(start, end, '.');
	if(decimal == end) {
		return is_positive_integer(start, end);
	} else if(decimal == start) {
		return is_positive_integer(decimal + 1, end);
	} else {
		return is_positive_integer(start, decimal) && (decimal + 1 == end || is_positive_integer(decimal + 1, end));
	}
}

inline bool is_fp(char const* start, char const* end) {
	if(start == end)
		return false;
	if(*start == '-')
		return is_positive_fp(start + 1, end);
	else
		return is_positive_fp(start, end);
}

inline double pow_10(int n) {
	static double const e[] = {// 1e-0...1e308: 309 * 8 bytes = 2472 bytes
		1e+0, 1e+1, 1e+2, 1e+3, 1e+4, 1e+5, 1e+6, 1e+7, 1e+8, 1e+9, 1e+10, 1e+11, 1e+12, 1e+13, 1e+14, 1e+15, 1e+16, 1e+17, 1e+18,
		1e+19, 1e+20, 1e+21, 1e+22, 1e+23, 1e+24, 1e+25, 1e+26, 1e+27, 1e+28, 1e+29, 1e+30, 1e+31, 1e+32, 1e+33, 1e+34, 1e+35,
		1e+36, 1e+37, 1e+38, 1e+39, 1e+40, 1e+41, 1e+42, 1e+43, 1e+44, 1e+45, 1e+46, 1e+47, 1e+48, 1e+49, 1e+50, 1e+51, 1e+52,
		1e+53, 1e+54, 1e+55, 1e+56, 1e+57, 1e+58, 1e+59, 1e+60, 1e+61, 1e+62, 1e+63, 1e+64, 1e+65, 1e+66, 1e+67, 1e+68, 1e+69,
		1e+70, 1e+71, 1e+72, 1e+73, 1e+74, 1e+75, 1e+76, 1e+77, 1e+78, 1e+79, 1e+80, 1e+81, 1e+82, 1e+83, 1e+84, 1e+85, 1e+86,
		1e+87, 1e+88, 1e+89, 1e+90, 1e+91, 1e+92, 1e+93, 1e+94, 1e+95, 1e+96, 1e+97, 1e+98, 1e+99, 1e+100, 1e+101, 1e+102, 1e+103,
		1e+104, 1e+105, 1e+106, 1e+107, 1e+108, 1e+109, 1e+110, 1e+111, 1e+112, 1e+113, 1e+114, 1e+115, 1e+116, 1e+117, 1e+118,
		1e+119, 1e+120, 1e+121, 1e+122, 1e+123, 1e+124, 1e+125, 1e+126, 1e+127, 1e+128, 1e+129, 1e+130, 1e+131, 1e+132, 1e+133,
		1e+134, 1e+135, 1e+136, 1e+137, 1e+138, 1e+139, 1e+140, 1e+141, 1e+142, 1e+143, 1e+144, 1e+145, 1e+146, 1e+147, 1e+148,
		1e+149, 1e+150, 1e+151, 1e+152, 1e+153, 1e+154, 1e+155, 1e+156, 1e+157, 1e+158, 1e+159, 1e+160, 1e+161, 1e+162, 1e+163,
		1e+164, 1e+165, 1e+166, 1e+167, 1e+168, 1e+169, 1e+170, 1e+171, 1e+172, 1e+173, 1e+174, 1e+175, 1e+176, 1e+177, 1e+178,
		1e+179, 1e+180, 1e+181, 1e+182, 1e+183, 1e+184, 1e+185, 1e+186, 1e+187, 1e+188, 1e+189, 1e+190, 1e+191, 1e+192, 1e+193,
		1e+194, 1e+195, 1e+196, 1e+197, 1e+198, 1e+199, 1e+200, 1e+201, 1e+202, 1e+203, 1e+204, 1e+205, 1e+206, 1e+207, 1e+208,
		1e+209, 1e+210, 1e+211, 1e+212, 1e+213, 1e+214, 1e+215, 1e+216, 1e+217, 1e+218, 1e+219, 1e+220, 1e+221, 1e+222, 1e+223,
		1e+224, 1e+225, 1e+226, 1e+227, 1e+228, 1e+229, 1e+230, 1e+231, 1e+232, 1e+233, 1e+234, 1e+235, 1e+236, 1e+237, 1e+238,
		1e+239, 1e+240, 1e+241, 1e+242, 1e+243, 1e+244, 1e+245, 1e+246, 1e+247, 1e+248, 1e+249, 1e+250, 1e+251, 1e+252, 1e+253,
		1e+254, 1e+255, 1e+256, 1e+257, 1e+258, 1e+259, 1e+260, 1e+261, 1e+262, 1e+263, 1e+264, 1e+265, 1e+266, 1e+267, 1e+268,
		1e+269, 1e+270, 1e+271, 1e+272, 1e+273, 1e+274, 1e+275, 1e+276, 1e+277, 1e+278, 1e+279, 1e+280, 1e+281, 1e+282, 1e+283,
		1e+284, 1e+285, 1e+286, 1e+287, 1e+288, 1e+289, 1e+290, 1e+291, 1e+292, 1e+293, 1e+294, 1e+295, 1e+296, 1e+297, 1e+298,
		1e+299, 1e+300, 1e+301, 1e+302, 1e+303, 1e+304, 1e+305, 1e+306, 1e+307, 1e+308 };
	return e[n];
}

inline bool float_from_chars(char const* start, char const* end, float& float_out) { // returns true on success
	// first read the chars into an int, keeping track of the magnitude
	// multiply by a pow of 10

	int32_t magnitude = 0;
	int64_t accumulated = 0;
	bool after_decimal = false;

	if(start == end) {
		float_out = 0.0f;
		return true;
	}

	bool is_negative = false;
	if(*start == '-') {
		is_negative = true;
		++start;
	} else if(*start == '+') {
		++start;
	}

	for(; start < end; ++start) {
		if(*start >= '0' && *start <= '9') {
			accumulated = accumulated * 10 + (*start - '0');
			magnitude += int32_t(after_decimal);
		} else if(*start == '.') {
			after_decimal = true;
		} else {
			// maybe check for non space and throw an error?
		}
	}
	if(!is_negative) {
		if(magnitude > 0)
			float_out = float(double(accumulated) / pow_10(magnitude));
		else
			float_out = float(accumulated);
	} else {
		if(magnitude > 0)
			float_out = -float(double(accumulated) / pow_10(magnitude));
		else
			float_out = -float(accumulated);
	}
	return true;
}

inline int32_t parse_int(std::string_view content) {
	int32_t rvalue = 0;
	auto result = std::from_chars(content.data(), content.data() + content.length(), rvalue);
	if(result.ec == std::errc::invalid_argument) {
		return 0;
	}
	return rvalue;
}
inline float parse_float(std::string_view content) {
	float rvalue = 0.0f;
	if(!float_from_chars(content.data(), content.data() + content.length(), rvalue)) {
		return 0.0f;
	}
	return rvalue;
}
struct variable_match_result {
	bool match_result = false;
	uint32_t match_end = 0;
};

inline type_match resolve_span_type(std::span<int32_t const> tlist, std::vector<int32_t> const& type_subs, environment& env);
inline variable_match_result fill_in_variable_types(int32_t source_type, std::span<int32_t const> match_span, std::vector<int32_t>& type_subs, environment& env);

#ifdef USE_LLVM
inline LLVMValueRef struct_zero_constant(LLVMContextRef c, int32_t t, environment* e) {
	std::vector<LLVMValueRef> zvals;
	for(int32_t j = 1; j < e->dict.type_array[t].decomposed_types_count; ++j) {
		auto st = e->dict.all_stack_types[e->dict.type_array[t].decomposed_types_start + j];
		zvals.push_back(e->dict.type_array[st].zero_constant(c, st, e));
	}
	return LLVMConstNamedStruct(e->dict.type_array[t].llvm_type, zvals.data(), uint32_t(zvals.size()));
}
#endif

inline int32_t interepreter_size(int32_t type, environment& env) {
	if(env.dict.type_array[type].decomposed_types_count == 0)
		return 8;
	auto main_type = env.dict.all_stack_types[env.dict.type_array[type].decomposed_types_start];
	return 8 * (env.dict.type_array[type].decomposed_types_count - 1 - env.dict.type_array[main_type].non_member_types);
}

inline int32_t struct_child_count(int32_t type, environment& env) {
	if(env.dict.type_array[type].decomposed_types_count == 0)
		return 0;
	auto main_type = env.dict.all_stack_types[env.dict.type_array[type].decomposed_types_start];
	return (env.dict.type_array[type].decomposed_types_count - 1 - env.dict.type_array[main_type].non_member_types);
}

inline int64_t interpreter_struct_zero_constant(int32_t t, environment* e) {
	if(e->dict.type_array[t].single_member_struct()) {
		auto child_index = e->dict.type_array[t].decomposed_types_start + 1 + 0;
		auto child_type = e->dict.all_stack_types[child_index];
		if(e->dict.type_array[child_type].interpreter_zero)
			return e->dict.type_array[child_type].interpreter_zero(child_type, e);
		else
			return 0;
	} else {
		auto bytes = interepreter_size(t, *e);
		auto mem = (char*)malloc(bytes);
		memset(mem, 0, bytes);
		return (int64_t)mem;
	}
}

inline uint32_t next_encoded_stack_type(std::span<int32_t const> desc) {
	if(desc.size() == 0)
		return 0;
	if(desc.size() == 1)
		return 1;
	if(desc[1] != std::numeric_limits<int32_t>::max())
		return 1;
	uint32_t i = 2;
	while(i < desc.size() && desc[i] != -1) {
		i += next_encoded_stack_type(desc.subspan(i));
	}
	if(i < desc.size() && desc[i] == -1)
		++i;
	return i;
}

inline int32_t instantiate_templated_struct_full(int32_t template_base, std::vector<int32_t> const& final_subtype_list, environment& env) {

	auto desc = std::span<int32_t const>(env.dict.all_stack_types.data() + env.dict.type_array[template_base].decomposed_types_start, size_t(env.dict.type_array[template_base].decomposed_types_count));

	uint32_t match_pos = 0;
	uint32_t mem_count = 0;
	std::vector<int32_t> type_subs_out;
	while(match_pos < desc.size()) {
		if(mem_count > final_subtype_list.size()) {
			env.report_error("attempted to instantiate a struct template with the wrong number of members");
			env.mode = fif_mode::error;
			return -1;
		}
		
		auto mr = fill_in_variable_types(final_subtype_list[mem_count], desc.subspan(match_pos), type_subs_out, env);
		if(!mr.match_result) {
			env.report_error("attempted to instantiate a struct template with types that do not match its definition");
			env.mode = fif_mode::error;
			return -1;
		}

		match_pos += next_encoded_stack_type(desc.subspan(match_pos));
		++mem_count;
	}
	if(mem_count < final_subtype_list.size()) {
		env.report_error("attempted to instantiate a struct template with the wrong number of members");
		env.mode = fif_mode::error;
		return -1;
	}

	for(uint32_t i = 0; i < env.dict.type_array.size(); ++i) {
		if(env.dict.type_array[i].decomposed_types_count == int32_t(final_subtype_list.size() + 1)) {
			auto ta_start = env.dict.type_array[i].decomposed_types_start;
			bool match = env.dict.all_stack_types[ta_start] == template_base;

			for(uint32_t j = 0; match && j < final_subtype_list.size(); ++j) {
				if(env.dict.all_stack_types[ta_start + j + 1] != final_subtype_list[j]) {
					match = false;
				}
			}

			if(match) 
				return  int32_t(i);
		}
	}
	
	int32_t new_type = int32_t(env.dict.type_array.size());
	env.dict.type_array.emplace_back();

	std::vector<LLVMTypeRef> ctypes;
	for(uint32_t j = 0; j < final_subtype_list.size(); ++j) {
		ctypes.push_back(env.dict.type_array[final_subtype_list[j]].llvm_type);
	}
	for(int32_t j = 0; j < env.dict.type_array[template_base].non_member_types; ++j)
		ctypes.pop_back();

	if(ctypes.size() != 1) {
		std::string autoname = "struct#" + std::to_string(env.dict.type_array.size());
#ifdef USE_LLVM
		auto ty = LLVMStructCreateNamed(env.llvm_context, autoname.c_str());
		LLVMStructSetBody(ty, ctypes.data(), uint32_t(ctypes.size()), false);
		env.dict.type_array.back().llvm_type = ty;
		env.dict.type_array.back().zero_constant = struct_zero_constant;
#endif
		env.dict.type_array.back().interpreter_zero = interpreter_struct_zero_constant;
	} else {
#ifdef USE_LLVM
		env.dict.type_array.back().llvm_type = ctypes[0];
		env.dict.type_array.back().zero_constant = env.dict.type_array[final_subtype_list[0]].zero_constant;
#endif
		env.dict.type_array.back().interpreter_zero = env.dict.type_array[final_subtype_list[0]].interpreter_zero;
	}

	env.dict.type_array.back().decomposed_types_count = uint32_t(final_subtype_list.size() + 1);
	env.dict.type_array.back().decomposed_types_start = uint32_t(env.dict.all_stack_types.size());
	
	if(ctypes.size() == 1)
		env.dict.type_array.back().flags |= type::FLAG_SINGLE_MEMBER;

	env.dict.type_array.back().flags &= ~(type::FLAG_TEMPLATE);
	env.dict.type_array.back().flags |= type::FLAG_REFCOUNTED;
	env.dict.type_array.back().type_slots = 0;
	env.dict.all_stack_types.push_back(template_base);
	env.dict.all_stack_types.insert(env.dict.all_stack_types.end(), final_subtype_list.begin(), final_subtype_list.end());

	return new_type;
}

inline int32_t instantiate_templated_struct(int32_t template_base, std::vector<int32_t> const& subtypes, environment& env) {
	std::vector<int32_t> final_subtype_list;
	final_subtype_list.push_back(template_base);

	auto desc = std::span<int32_t const>(env.dict.all_stack_types.data() + env.dict.type_array[template_base].decomposed_types_start, size_t(env.dict.type_array[template_base].decomposed_types_count));

	uint32_t match_pos = 0;
	while(match_pos < desc.size()) {
		auto mresult = resolve_span_type(desc.subspan(match_pos), subtypes, env);
		match_pos += mresult.end_match_pos;
		final_subtype_list.push_back(mresult.type);
	}

	for(uint32_t i = 0; i < env.dict.type_array.size(); ++i) {
		if(env.dict.type_array[i].decomposed_types_count == int32_t(final_subtype_list.size())) {
			auto ta_start = env.dict.type_array[i].decomposed_types_start;
			bool match = true;

			for(uint32_t j = 0; j < final_subtype_list.size(); ++j) {
				if(env.dict.all_stack_types[ta_start + j] != final_subtype_list[j]) {
					match = false;
					break;
				}
			}

			if(match)
				return  int32_t(i);
		}
	}

	int32_t new_type = int32_t(env.dict.type_array.size());
	env.dict.type_array.emplace_back();

	std::vector<LLVMTypeRef> ctypes;
	for(uint32_t j = 1; j < final_subtype_list.size(); ++j) {
		ctypes.push_back(env.dict.type_array[final_subtype_list[j]].llvm_type);
	}
	for(int32_t j = 0; j < env.dict.type_array[template_base].non_member_types; ++j)
		ctypes.pop_back();

	if(ctypes.size() != 1) {
		std::string autoname = "struct#" + std::to_string(env.dict.type_array.size());
#ifdef USE_LLVM
		auto ty = LLVMStructCreateNamed(env.llvm_context, autoname.c_str());
		LLVMStructSetBody(ty, ctypes.data(), uint32_t(ctypes.size()), false);
		env.dict.type_array.back().llvm_type = ty;
		env.dict.type_array.back().zero_constant = struct_zero_constant;
#endif
		env.dict.type_array.back().interpreter_zero = interpreter_struct_zero_constant;
	} else {
#ifdef USE_LLVM
		env.dict.type_array.back().llvm_type = ctypes[0];
		env.dict.type_array.back().zero_constant = env.dict.type_array[final_subtype_list[0]].zero_constant;
#endif
		env.dict.type_array.back().interpreter_zero = env.dict.type_array[final_subtype_list[0]].interpreter_zero;
	}
	env.dict.type_array.back().decomposed_types_count = uint32_t(final_subtype_list.size());
	env.dict.type_array.back().decomposed_types_start = uint32_t(env.dict.all_stack_types.size());

	env.dict.type_array.back().flags &= ~(type::FLAG_TEMPLATE);
	env.dict.type_array.back().flags |= type::FLAG_REFCOUNTED;
	if(ctypes.size() == 1)
		env.dict.type_array.back().flags |= type::FLAG_SINGLE_MEMBER;

	env.dict.type_array.back().type_slots = 0;
	env.dict.all_stack_types.insert(env.dict.all_stack_types.end(), final_subtype_list.begin(), final_subtype_list.end());

	return new_type;
}

inline int32_t make_struct_type(std::string_view name, std::span<int32_t const> subtypes, std::vector<std::string_view> const& member_names, environment& env, int32_t template_types, int32_t extra_count) {

	int32_t new_type = int32_t(env.dict.type_array.size());
	env.dict.type_array.emplace_back();
	env.dict.types.insert_or_assign(std::string(name), new_type);

	if(template_types == 0 && extra_count == 0) {
		std::vector<LLVMTypeRef> ctypes;
		for(uint32_t j = 0; j < subtypes.size(); ++j) {
			ctypes.push_back(env.dict.type_array[subtypes[j]].llvm_type);
		}
		if(ctypes.size() != 1) {
			std::string autoname = "struct#" + std::to_string(env.dict.type_array.size());
#ifdef USE_LLVM
			auto ty = LLVMStructCreateNamed(env.llvm_context, autoname.c_str());
			LLVMStructSetBody(ty, ctypes.data(), uint32_t(ctypes.size()), false);
			env.dict.type_array.back().llvm_type = ty;
			env.dict.type_array.back().zero_constant = struct_zero_constant;
#endif
			env.dict.type_array.back().interpreter_zero = interpreter_struct_zero_constant;
		} else {
#ifdef USE_LLVM
			env.dict.type_array.back().llvm_type = ctypes[0];
			env.dict.type_array.back().zero_constant = env.dict.type_array[subtypes[0]].zero_constant;
#endif
			env.dict.type_array.back().interpreter_zero = env.dict.type_array[subtypes[0]].interpreter_zero;
		}
	} else {
#ifdef USE_LLVM
		env.dict.type_array.back().llvm_type = LLVMVoidTypeInContext(env.llvm_context);
		env.dict.type_array.back().zero_constant = struct_zero_constant;
#endif
		env.dict.type_array.back().interpreter_zero = interpreter_struct_zero_constant;
		env.dict.type_array.back().non_member_types = extra_count;
	}

	env.dict.type_array.back().decomposed_types_count = uint32_t(subtypes.size() + (template_types + extra_count == 0 ? 1 : extra_count));
	env.dict.type_array.back().decomposed_types_start = uint32_t(env.dict.all_stack_types.size());

	auto add_child_types = [&]() {
		if(template_types + extra_count > 0) {
			env.dict.all_stack_types.push_back(std::numeric_limits<int32_t>::max());
			env.dict.all_stack_types.insert(env.dict.all_stack_types.end(), subtypes.begin(), subtypes.end());
			for(int32_t e = 0; e < extra_count; ++e) {
				env.dict.all_stack_types.push_back(-(template_types + e + 2));
			}
			env.dict.all_stack_types.push_back(-1);
		}
	};


	if(template_types + extra_count > 0)
		env.dict.type_array.back().flags |= type::FLAG_TEMPLATE;
	else
		env.dict.type_array.back().flags &= ~(type::FLAG_TEMPLATE);

	if(subtypes.size() == 1)
		env.dict.type_array.back().flags |= type::FLAG_SINGLE_MEMBER;

	env.dict.type_array.back().flags |= type::FLAG_REFCOUNTED;
	env.dict.type_array.back().type_slots = template_types + extra_count;
	if(template_types + extra_count == 0)
		env.dict.all_stack_types.push_back(fif_struct);
	env.dict.all_stack_types.insert(env.dict.all_stack_types.end(), subtypes.begin(), subtypes.end());
	for(int32_t e = 0; e < extra_count; ++e) {
		env.dict.all_stack_types.push_back(-(template_types + e + 2));
	}

	int32_t start_types = int32_t(env.dict.all_stack_types.size());
	env.dict.all_stack_types.push_back(new_type);
	add_child_types();
	int32_t end_zero = int32_t(env.dict.all_stack_types.size());
	env.dict.all_stack_types.push_back(-1);
	env.dict.all_stack_types.push_back(new_type);
	add_child_types();
	int32_t end_one = int32_t(env.dict.all_stack_types.size());
	env.dict.all_stack_types.push_back(new_type);
	add_child_types();

	int32_t end_two = int32_t(env.dict.all_stack_types.size());

	auto bury_word = [&](std::string const& name, int32_t id) { 
		int32_t start_word = 0;
		int32_t preceding_word = -1;
		if(auto it = env.dict.words.find(name); it != env.dict.words.end()) {
			start_word = it->second;
		} else {
			env.dict.words.insert_or_assign(name, id);
			return;
		}
		while(env.dict.word_array[start_word].specialization_of != -1) {
			preceding_word = start_word;
			start_word = env.dict.word_array[start_word].specialization_of;
		}
		if(preceding_word == -1) {
			env.dict.words.insert_or_assign(name, id);
			env.dict.word_array[id].specialization_of = start_word;
			assert(id != start_word);
		} else {
			env.dict.word_array[preceding_word].specialization_of = id;
			env.dict.word_array[id].specialization_of = start_word;
			assert(id != start_word);
		}
	};

	{
		env.dict.word_array.emplace_back();
		env.dict.word_array.back().source = std::string("struct-map2 copy");
		env.dict.word_array.back().stack_types_start = start_types;
		env.dict.word_array.back().stack_types_count = end_two - start_types;
		env.dict.word_array.back().treat_as_base = true;
		bury_word("copy", int32_t(env.dict.word_array.size() - 1));
	}
	{
		env.dict.word_array.emplace_back();
		env.dict.word_array.back().source = std::string("struct-map2 dup");
		env.dict.word_array.back().stack_types_start = start_types;
		env.dict.word_array.back().stack_types_count = end_two - start_types;
		env.dict.word_array.back().treat_as_base = true;
		bury_word("dup", int32_t(env.dict.word_array.size() - 1));
	}
	{
		env.dict.word_array.emplace_back();
		env.dict.word_array.back().source = std::string("struct-map1 init");
		env.dict.word_array.back().stack_types_start = start_types;
		env.dict.word_array.back().stack_types_count = end_one - start_types;
		env.dict.word_array.back().treat_as_base = true;
		bury_word("init", int32_t(env.dict.word_array.size() - 1));
	}
	{
		env.dict.word_array.emplace_back();
		env.dict.word_array.back().source = std::string("struct-map0 drop");
		env.dict.word_array.back().stack_types_start = start_types;
		env.dict.word_array.back().stack_types_count = end_zero - start_types;
		env.dict.word_array.back().treat_as_base = true;
		bury_word("drop", int32_t(env.dict.word_array.size() - 1));
	}

	uint32_t index = 0;
	auto desc = subtypes;
	while(desc.size() > 0) {
		auto next = next_encoded_stack_type(desc);

		{
			int32_t start_types_i = int32_t(env.dict.all_stack_types.size());
			env.dict.all_stack_types.push_back(new_type);
			add_child_types();
			env.dict.all_stack_types.push_back(-1);
			for(uint32_t j = 0; j < next; ++j)
				env.dict.all_stack_types.push_back(desc[j]);
			int32_t end_types_i = int32_t(env.dict.all_stack_types.size());

			env.dict.word_array.emplace_back();
			env.dict.word_array.back().source = std::string("forth.extract ") + std::to_string(index);
			env.dict.word_array.back().stack_types_start = start_types_i;
			env.dict.word_array.back().stack_types_count = end_types_i - start_types_i;
			env.dict.word_array.back().treat_as_base = true;

			bury_word(std::string(".") + std::string{ member_names[index] }, int32_t(env.dict.word_array.size() - 1));
		}
		{
			int32_t start_types_i = int32_t(env.dict.all_stack_types.size());
			env.dict.all_stack_types.push_back(new_type);
			add_child_types();
			env.dict.all_stack_types.push_back(-1);
			env.dict.all_stack_types.push_back(new_type);
			add_child_types();
			for(uint32_t j = 0; j < next; ++j)
				env.dict.all_stack_types.push_back(desc[j]);
			int32_t end_types_i = int32_t(env.dict.all_stack_types.size());

			env.dict.word_array.emplace_back();
			env.dict.word_array.back().source = std::string("forth.extract-copy ") + std::to_string(index);
			env.dict.word_array.back().stack_types_start = start_types_i;
			env.dict.word_array.back().stack_types_count = end_types_i - start_types_i;
			env.dict.word_array.back().treat_as_base = true;

			bury_word(std::string(".") + std::string{ member_names[index] } + "@", int32_t(env.dict.word_array.size() - 1));
		}
		{
			int32_t start_types_i = int32_t(env.dict.all_stack_types.size());
			env.dict.all_stack_types.push_back(new_type);
			add_child_types();
			for(uint32_t j = 0; j < next; ++j)
				env.dict.all_stack_types.push_back(desc[j]);
			env.dict.all_stack_types.push_back(-1);
			env.dict.all_stack_types.push_back(new_type);
			add_child_types();
			int32_t end_types_i = int32_t(env.dict.all_stack_types.size());

			env.dict.word_array.emplace_back();
			env.dict.word_array.back().source = std::string("forth.insert ") + std::to_string(index);
			env.dict.word_array.back().stack_types_start = start_types_i;
			env.dict.word_array.back().stack_types_count = end_types_i - start_types_i;
			env.dict.word_array.back().treat_as_base = true;

			bury_word(std::string(".") + std::string{ member_names[index] } + "!", int32_t(env.dict.word_array.size() - 1));
		}
		{
			int32_t start_types_i = int32_t(env.dict.all_stack_types.size());
			env.dict.all_stack_types.push_back(fif_ptr);
			env.dict.all_stack_types.push_back(std::numeric_limits<int32_t>::max());
			env.dict.all_stack_types.push_back(new_type);
			add_child_types();
			env.dict.all_stack_types.push_back(-1);
			env.dict.all_stack_types.push_back(-1);
			env.dict.all_stack_types.push_back(fif_ptr);
			env.dict.all_stack_types.push_back(std::numeric_limits<int32_t>::max());
			for(uint32_t j = 0; j < next; ++j)
				env.dict.all_stack_types.push_back(desc[j]);
			env.dict.all_stack_types.push_back(-1);
			int32_t end_types_i = int32_t(env.dict.all_stack_types.size());

			env.dict.word_array.emplace_back();
			env.dict.word_array.back().source = std::string("forth.gep ") + std::to_string(index);
			env.dict.word_array.back().stack_types_start = start_types_i;
			env.dict.word_array.back().stack_types_count = end_types_i - start_types_i;
			env.dict.word_array.back().treat_as_base = true;

			bury_word(std::string(".") + std::string{ member_names[index] }, int32_t(env.dict.word_array.size() - 1));
		}

		++index;
		desc = desc.subspan(next);
	}

	return new_type;
}

inline type_match internal_resolve_type(std::string_view text, environment& env, std::vector<int32_t>* type_subs) {
	uint32_t mt_end = 0;
	if(text.starts_with("ptr(nil)")) {
		return type_match{ fif_opaque_ptr, 8 };
	}
	for(; mt_end < text.size(); ++mt_end) {
		if(text[mt_end] == '(' || text[mt_end] == ')' || text[mt_end] == ',')
			break;
	}

	if(text.size() > 0 && text[0] == '$') {
		if(is_integer(text.data() + 1, text.data() + mt_end)) {
			auto v = parse_int(text.substr(1));
			if(type_subs && v >= 0 && size_t(v) < type_subs->size()) {
				return type_match{ (*type_subs)[v], mt_end };
			}
			return type_match{ fif_nil, mt_end };
		}
	}
	if(text.substr(0, mt_end) == "struct") { // prevent "generic" struct matching
		return type_match{ -1, uint32_t(text.length()) };
	}
	if(auto it = env.dict.types.find(std::string(text.substr(0, mt_end))); it != env.dict.types.end()) {
		if(mt_end >= text.size() || text[mt_end] == ',' ||  text[mt_end] == ')') {	// case: plain type
			return type_match{ it->second, mt_end };
		}
		//followed by type list
		++mt_end;
		std::vector<int32_t> subtypes;
		while(mt_end < text.size() && text[mt_end] != ')') {
			auto sub_match = internal_resolve_type(text.substr(mt_end), env, type_subs);
			subtypes.push_back(sub_match.type);
			mt_end += sub_match.end_match_pos;
			if(mt_end < text.size() && text[mt_end] == ',')
				++mt_end;
		}
		if(mt_end < text.size() && text[mt_end] == ')')
			++mt_end;

		if(env.dict.type_array[it->second].type_slots != int32_t(subtypes.size())) {
			env.report_error("attempted to instantiate a type with the wrong number of parameters");
			env.mode = fif_mode::error;
			return type_match{ -1, mt_end };
		} else if(env.dict.type_array[it->second].is_struct_template()) {
			return type_match{ instantiate_templated_struct(it->second, subtypes, env), mt_end };
		} else {
			for(uint32_t i = 0; i < env.dict.type_array.size(); ++i) {
				if(env.dict.type_array[i].decomposed_types_count == int32_t(1 + subtypes.size())) {
					auto ta_start = env.dict.type_array[i].decomposed_types_start;
					if(env.dict.all_stack_types[ta_start] == it->second) {
						bool match = true;
						for(uint32_t j = 0; j < subtypes.size(); ++j) {
							if(env.dict.all_stack_types[ta_start + 1 + j] != subtypes[j]) {
								match = false;
								break;
							}
						}

						if(match) {
							return type_match{ int32_t(i), mt_end };
						}
					}
				}
			}

			int32_t new_type = int32_t(env.dict.type_array.size());
			env.dict.type_array.emplace_back();
			env.dict.type_array.back().llvm_type = env.dict.type_array[it->second].llvm_type;
			env.dict.type_array.back().decomposed_types_count = uint32_t(1 + subtypes.size());
			env.dict.type_array.back().decomposed_types_start = uint32_t(env.dict.all_stack_types.size());
			env.dict.type_array.back().flags = env.dict.type_array[it->second].flags;
			env.dict.type_array.back().zero_constant = env.dict.type_array[it->second].zero_constant;
			env.dict.type_array.back().type_slots = 0;

			env.dict.all_stack_types.push_back(it->second);
			for(auto t : subtypes) {
				env.dict.all_stack_types.push_back(t);
			}

			return type_match{ new_type, mt_end };
		}
	}

	return type_match{ -1, mt_end };
}

inline int32_t resolve_type(std::string_view text, environment& env, std::vector<int32_t>* type_subs) {
	return internal_resolve_type(text, env, type_subs).type;
}

struct type_span_gen_result {
	std::vector<int32_t> type_array;
	uint32_t end_match_pos = 0;
	int32_t max_variable = -1;
};

inline type_span_gen_result internal_generate_type(std::string_view text, environment& env) {
	uint32_t mt_end = 0;
	type_span_gen_result r;

	if(text.starts_with("ptr(nil)")) {
		r.type_array.push_back(fif_opaque_ptr);
		r.end_match_pos = 8;
		return r;
	}
	for(; mt_end < text.size(); ++mt_end) {
		if(text[mt_end] == '(' || text[mt_end] == ')' || text[mt_end] == ',')
			break;
	}

	if(text.size() > 0 && text[0] == '$') {
		if(is_integer(text.data() + 1, text.data() + mt_end)) {
			auto v = parse_int(text.substr(1));
			r.max_variable = std::max(r.max_variable, v);
			r.type_array.push_back( -(v + 2) );
			r.end_match_pos = mt_end;
			return r;
		}
	}
	if(auto it = env.dict.types.find(std::string(text.substr(0, mt_end))); it != env.dict.types.end()) {
		r.type_array.push_back(it->second);
		if(mt_end >= text.size() || text[mt_end] == ',' || text[mt_end] == ')') {	// case: plain type
			r.end_match_pos = mt_end;
			return r;
		}
		//followed by type list
		++mt_end;
		r.type_array.push_back(std::numeric_limits<int32_t>::max());
		if((env.dict.type_array[it->second].flags & type::FLAG_TEMPLATE) != 0) {
			std::vector<type_span_gen_result> sub_matches;
			while(mt_end < text.size() && text[mt_end] != ')') {
				auto sub_match = internal_generate_type(text.substr(mt_end), env);
				r.max_variable = std::max(r.max_variable, sub_match.max_variable);
				sub_matches.push_back(std::move(sub_match));
				mt_end += sub_match.end_match_pos;
				if(mt_end < text.size() && text[mt_end] == ',')
					++mt_end;
			}
			auto desc = std::span<int32_t const>(env.dict.all_stack_types.data() + env.dict.type_array[it->second].decomposed_types_start, size_t(env.dict.type_array[it->second].decomposed_types_count));
			for(auto v : desc) {
				if(v < -1) {
					auto index = -(v + 2);
					if(size_t(index) < sub_matches.size()) {
						r.type_array.insert(r.type_array.end(), sub_matches[index].type_array.begin(), sub_matches[index].type_array.end());
					} else {
						r.type_array.push_back(fif_nil);
					}
				} else {
					r.type_array.push_back(v);
				}
			}

		} else {
			while(mt_end < text.size() && text[mt_end] != ')') {
				auto sub_match = internal_generate_type(text.substr(mt_end), env);
				r.type_array.insert(r.type_array.end(), sub_match.type_array.begin(), sub_match.type_array.end());
				r.max_variable = std::max(r.max_variable, sub_match.max_variable);
				mt_end += sub_match.end_match_pos;
				if(mt_end < text.size() && text[mt_end] == ',')
					++mt_end;
			}
		}
		r.type_array.push_back(-1);
		if(mt_end < text.size() && text[mt_end] == ')')
			++mt_end;
	}
	r.end_match_pos = mt_end;
	if(r.max_variable == -1) {
		std::vector<int32_t> type_subs;
		auto resolved_type = resolve_span_type(std::span<int32_t const>(r.type_array.begin(), r.type_array.end()), type_subs, env);
		r.type_array.clear();
		r.type_array.push_back(resolved_type.type);
	}
	return r;
}

inline type_match resolve_span_type(std::span<int32_t const> tlist, std::vector<int32_t> const& type_subs, environment& env) {

	auto make_sub = [&](int32_t type_in) {
		if(type_in < -1) {
			auto slot = -(type_in + 2);
			if(slot < int32_t(type_subs.size()))
				return type_subs[slot];
			return -1;
		}
		return type_in;
	};

	if(tlist.size() == 0) {
		return type_match{ -1, 0 };
	}
	if(tlist.size() == 1) {
		return type_match{ make_sub(tlist[0]), 1 };
	}
	if(tlist[1] != std::numeric_limits<int32_t>::max()) {
		return type_match{ make_sub(tlist[0]), 1 };
	}
	int32_t base_type = tlist[0];
	assert(base_type >= 0);
	uint32_t mt_end = 2;

	//followed by type list
	std::vector<int32_t> subtypes;
	while(mt_end < tlist.size() && tlist[mt_end] != -1) {
		auto sub_match = resolve_span_type(tlist.subspan(mt_end), type_subs, env);
		subtypes.push_back(sub_match.type);
		mt_end += sub_match.end_match_pos;
	}
	if(mt_end < tlist.size() && tlist[mt_end] == -1)
		++mt_end;

	
	 if(base_type == fif_ptr && !subtypes.empty() && subtypes[0] == fif_nil) {
		return type_match{ fif_opaque_ptr, mt_end };
	} else if(env.dict.type_array[base_type].is_struct_template()) {
		return type_match{ instantiate_templated_struct_full(base_type, subtypes, env), mt_end };
	} else {
		for(uint32_t i = 0; i < env.dict.type_array.size(); ++i) {
			if(env.dict.type_array[i].decomposed_types_count == int32_t(1 + subtypes.size())) {
				auto ta_start = env.dict.type_array[i].decomposed_types_start;
				if(env.dict.all_stack_types[ta_start] == base_type) {
					bool match = true;
					for(uint32_t j = 0; j < subtypes.size(); ++j) {
						if(env.dict.all_stack_types[ta_start + 1 + j] != subtypes[j]) {
							match = false;
							break;
						}
					}

					if(match) {
						return type_match{ int32_t(i), mt_end };
					}
				}
			}
		}

		int32_t new_type = int32_t(env.dict.type_array.size());
		env.dict.type_array.emplace_back();

		env.dict.type_array.back().llvm_type = env.dict.type_array[base_type].llvm_type;
		env.dict.type_array.back().decomposed_types_count = uint32_t(1 + subtypes.size());
		env.dict.type_array.back().decomposed_types_start = uint32_t(env.dict.all_stack_types.size());
		env.dict.type_array.back().zero_constant = env.dict.type_array[base_type].zero_constant;
		env.dict.type_array.back().flags = env.dict.type_array[base_type].flags;
		env.dict.type_array.back().type_slots = 0;

		env.dict.all_stack_types.push_back(base_type);
		for(auto t : subtypes) {
			env.dict.all_stack_types.push_back(t);
		}

		return type_match{ new_type, mt_end };
	}
}

inline variable_match_result fill_in_variable_types(int32_t source_type, std::span<int32_t const> match_span, std::vector<int32_t>& type_subs, environment& env) { 
	if(match_span.size() == 0)
		return variable_match_result{ true, 0 };

	auto match_to_slot = [&](int32_t matching_type, int32_t matching_against) { 
		if(matching_type < -1) {
			auto slot = -(matching_type + 2);
			if(slot >= int32_t(type_subs.size())) {
				type_subs.resize(size_t(slot + 1), -2);
				type_subs[slot] = matching_against;
				return true;
			} else if(type_subs[slot] == -2 || type_subs[slot] == matching_against) {
				type_subs[slot] = matching_against;
				return true;
			} else {
				return false;
			}
		} else {
			return matching_type == matching_against;
		}
	};

	if(match_span.size() == 1) {
		return variable_match_result{ match_to_slot(match_span[0], source_type), 1 };
	}

	if(match_span[1] != std::numeric_limits<int32_t>::max()) {
		return variable_match_result{ match_to_slot(match_span[0], source_type), 1 };
	}

	uint32_t sub_offset = 2;
	
	std::span<const int32_t> destructured_source{ };
	if(source_type >= 0) {
		auto const& t = env.dict.type_array[source_type];
		destructured_source = std::span<const int32_t>(env.dict.all_stack_types.data() + t.decomposed_types_start, size_t(t.decomposed_types_count));
	}

	bool result = destructured_source.size() > 0 ? match_to_slot(match_span[0], destructured_source[0]) : false;
	uint32_t dest_offset = 1;
	while(sub_offset < match_span.size() && match_span[sub_offset] != -1) {
		auto dmatch = dest_offset < destructured_source.size() ? destructured_source[dest_offset] : -1;
		auto sub_result = fill_in_variable_types(dmatch, match_span.subspan(sub_offset), type_subs, env);
		sub_offset += sub_result.match_end;
		result &= sub_result.match_result;
		++dest_offset;
	}
	if(dest_offset < destructured_source.size())
		result = false;
	if(sub_offset < match_span.size() && match_span[sub_offset] == -1)
		++sub_offset;

	return variable_match_result{ result, sub_offset };
}

inline type_match_result match_stack_description(std::span<int32_t const> desc, state_stack& ts, environment& env, std::vector<int32_t>& type_subs) { // ret: true if function matched
	int32_t match_position = 0;
	// stack matching

	auto const ssize = int32_t(ts.main_size());
	int32_t consumed_stack_cells = 0;
	while(match_position < int32_t(desc.size()) && desc[match_position] != -1) {
		if(consumed_stack_cells >= ssize)
			return type_match_result{ false, 0, 0 };
		auto match_result = fill_in_variable_types(ts.main_type_back(size_t(consumed_stack_cells)), desc.subspan(match_position), type_subs, env);
		if(!match_result.match_result)
			return type_match_result{ false, 0, 0 };
		match_position += match_result.match_end;
		++consumed_stack_cells;
	}

	++match_position; // skip -1

	// skip over output stack
	int32_t first_output_stack = match_position;
	//int32_t output_stack_types = 0;
	while(match_position < int32_t(desc.size()) && desc[match_position] != -1) {
		match_position += next_encoded_stack_type(desc.subspan(match_position));
		//++output_stack_types;
	}
	//int32_t last_output_stack = match_position;
	++match_position; // skip -1

	// return stack matching
	auto const rsize = int32_t(ts.return_size());
	int32_t consumed_rstack_cells = 0;
	while(match_position < int32_t(desc.size()) && desc[match_position] != -1) {
		if(consumed_rstack_cells >= rsize)
			return type_match_result{ false, 0, 0 }; 
		auto match_result = fill_in_variable_types(ts.return_type_back(size_t(consumed_rstack_cells)), desc.subspan(match_position), type_subs, env);
		if(!match_result.match_result)
			return type_match_result{ false, 0, 0 };
		match_position += match_result.match_end;
		++consumed_rstack_cells;
	}

	++match_position; // skip -1

	// output ret stack
	//int32_t ret_added = 0;
	while(match_position < int32_t(desc.size()) && desc[match_position] != -1) {
		auto result = resolve_span_type(desc.subspan(match_position), type_subs, env);
		match_position += result.end_match_pos;
		//++ret_added;
	}

	return type_match_result{ true, consumed_stack_cells, consumed_rstack_cells };
}


inline void apply_stack_description(std::span<int32_t const> desc, state_stack& ts, environment& env) { // ret: true if function matched
	int32_t match_position = 0;
	// stack matching

	std::vector<int32_t> type_subs;

	auto const ssize = int32_t(ts.main_size());
	int32_t consumed_stack_cells = 0;
	while(match_position < int32_t(desc.size()) && desc[match_position] != -1) {
		if(consumed_stack_cells >= ssize)
			return;
		auto match_result = fill_in_variable_types(ts.main_type_back(consumed_stack_cells), desc.subspan(match_position), type_subs, env);
		if(!match_result.match_result)
			return;
		match_position += match_result.match_end;
		++consumed_stack_cells;
	}

	++match_position; // skip -1

	// skip over output stack
	int32_t first_output_stack = match_position;
	//int32_t output_stack_types = 0;
	while(match_position < int32_t(desc.size()) && desc[match_position] != -1) {
		match_position += next_encoded_stack_type(desc.subspan(match_position));
		//++output_stack_types;
	}
	//int32_t last_output_stack = match_position;
	++match_position; // skip -1

	// return stack matching
	auto const rsize = int32_t(ts.return_size());
	int32_t consumed_rstack_cells = 0;
	while(match_position < int32_t(desc.size()) && desc[match_position] != -1) {
		if(consumed_rstack_cells >= rsize)
			return;
		auto match_result = fill_in_variable_types(ts.return_type_back(consumed_rstack_cells), desc.subspan(match_position), type_subs, env);
		if(!match_result.match_result)
			return;
		match_position += match_result.match_end;
		++consumed_rstack_cells;
	}

	++match_position; // skip -1

	// drop consumed types
	ts.resize(ssize - consumed_stack_cells, rsize - consumed_rstack_cells);

	// add returned stack types
	while(first_output_stack < int32_t(desc.size()) && desc[first_output_stack] != -1) {
		auto result = resolve_span_type(desc.subspan(first_output_stack), type_subs, env);
		first_output_stack += result.end_match_pos;
		ts.push_back_main(result.type, 0, nullptr);
	}

	// output ret stack
	// add new types
	//int32_t ret_added = 0;
	while(match_position < int32_t(desc.size()) && desc[match_position] != -1) {
		auto result = resolve_span_type(desc.subspan(match_position), type_subs, env);
		ts.push_back_return(result.type, 0, nullptr);
		match_position += result.end_match_pos;
		//++ret_added;
	}
}


struct stack_consumption {
	int32_t stack;
	int32_t rstack;
};
inline stack_consumption get_stack_consumption(int32_t word, int32_t alternative, environment& env) {
	int32_t count_desc = 0;
	int32_t desc_offset = 0;
	if(std::holds_alternative<interpreted_word_instance>(env.dict.all_instances[alternative])) {
		count_desc = std::get<interpreted_word_instance>(env.dict.all_instances[alternative]).stack_types_count;
		desc_offset = std::get<interpreted_word_instance>(env.dict.all_instances[alternative]).stack_types_start;
	} else if(std::holds_alternative<compiled_word_instance>(env.dict.all_instances[alternative])) {
		count_desc = std::get<compiled_word_instance>(env.dict.all_instances[alternative]).stack_types_count;
		desc_offset = std::get<compiled_word_instance>(env.dict.all_instances[alternative]).stack_types_start;
	}

	std::span<const int> desc = std::span<const int>(env.dict.all_stack_types.data() + desc_offset, size_t(count_desc));

	int32_t match_position = 0;
	// stack matching

	int32_t consumed_stack_cells = 0;
	while(match_position < int32_t(desc.size()) && desc[match_position] != -1) {
		match_position += next_encoded_stack_type(desc.subspan(match_position));
		++consumed_stack_cells;
	}

	++match_position; // skip -1

	// skip over output stack
	int32_t first_output_stack = match_position;
	//int32_t output_stack_types = 0;
	while(match_position < int32_t(desc.size()) && desc[match_position] != -1) {
		match_position += next_encoded_stack_type(desc.subspan(match_position));
		//++output_stack_types;
	}

	++match_position; // skip -1

	// return stack matching
	
	int32_t consumed_rstack_cells = 0;
	while(match_position < int32_t(desc.size()) && desc[match_position] != -1) {
		match_position += next_encoded_stack_type(desc.subspan(match_position));
		++consumed_rstack_cells;
	}

	return stack_consumption{ consumed_stack_cells, consumed_rstack_cells };
}

struct word_match_result {
	bool matched = false;
	int32_t stack_consumed = 0;
	int32_t ret_stack_consumed = 0;
	int32_t word_index = 0;
	int32_t substitution_version = 0;
};

inline word_match_result match_word(word const& w, state_stack& ts, std::vector<word_types> const& all_instances, std::vector<int32_t> const& all_stack_types, environment& env) {
	std::vector<int32_t> type_subs;
	for(uint32_t i = 0; i < w.instances.size(); ++i) {
		if(std::holds_alternative<interpreted_word_instance>(all_instances[w.instances[i]])) {
			interpreted_word_instance const& s = std::get<interpreted_word_instance>(all_instances[w.instances[i]]);
			auto mr = match_stack_description(std::span<int32_t const>(all_stack_types.data() + s.stack_types_start, size_t(s.stack_types_count)), ts, env, type_subs);
			if(mr.matched) {
				return word_match_result{ mr.matched, mr.stack_consumed, mr.ret_stack_consumed, w.instances[i], 0 };
			}
			type_subs.clear();
		} else if(std::holds_alternative<compiled_word_instance>(all_instances[w.instances[i]])) {
			compiled_word_instance const& s = std::get<compiled_word_instance>(all_instances[w.instances[i]]);
			auto mr = match_stack_description(std::span<int32_t const>(all_stack_types.data() + s.stack_types_start, size_t(s.stack_types_count)), ts, env, type_subs);
			if(mr.matched) {
				return word_match_result{ mr.matched, mr.stack_consumed, mr.ret_stack_consumed, w.instances[i], 0 };
			}
			type_subs.clear();
		}
	}
	return word_match_result{ false, 0, 0, 0, 0 };
}

inline std::string_view read_word(std::string_view source, uint32_t& read_position) {
	uint32_t first_non_space = read_position;
	while(first_non_space < source.length() && (source[first_non_space] == ' ' || source[first_non_space] == '\t'))
		++first_non_space;

	auto word_end = first_non_space;
	while(word_end < source.length() && source[word_end] != ' ' && source[word_end] != '\t')
		++word_end;

	read_position = word_end;

	return source.substr(first_non_space, word_end - first_non_space);
}

inline void execute_fif_word(interpreted_word_instance& wi, state_stack& ss, environment& env) {
	int32_t* ptr = wi.compiled_bytecode.data();
	while(ptr) {
		fif_call fn = nullptr;
		memcpy(&fn, ptr, 8);
		ptr = fn(ss, ptr, &env);
#ifdef HEAP_CHECKS
		assert(_CrtCheckMemory());
#endif
	}
}
inline void execute_fif_word(compiled_word_instance& wi, state_stack& ss, environment& env) {
	wi.implementation(ss, nullptr, &env);
}
inline void execute_fif_word(state_stack& ss, int32_t* ptr, environment& env) {
	while(ptr) {
		fif_call fn = nullptr;
		memcpy(&fn, ptr, 8);
		ptr = fn(ss, ptr, &env);
#ifdef HEAP_CHECKS
		assert(_CrtCheckMemory());
#endif
	}
}

inline int32_t* immediate_i32(state_stack& s, int32_t* p, environment*) {
	int32_t data = 0;
	memcpy(&data, p + 2, 4);
	s.push_back_main(fif_i32, data, nullptr);
	return p + 3;
}
inline int32_t* immediate_f32(state_stack& s, int32_t* p, environment*) {
	int64_t data = 0;
	memcpy(&data, p + 2, 4);
	s.push_back_main(fif_f32, data, nullptr);
	return p + 3;
}
inline int32_t* immediate_bool(state_stack& s, int32_t* p, environment*) {
	int32_t data = 0;
	memcpy(&data, p + 2, 4);
	s.push_back_main(fif_bool, data, nullptr);
	return p + 3;
}
inline void do_immediate_i32(state_stack& s, int32_t value, environment* e) {
	if(typechecking_failed(e->mode))
		return;

	auto compile_bytes = e->compiler_stack.back()->bytecode_compilation_progress();
	if(compile_bytes && e->mode == fif_mode::compiling_bytecode) {
		fif_call imm = immediate_i32;
		uint64_t imm_bytes = 0;
		memcpy(&imm_bytes, &imm, 8);
		compile_bytes->push_back(int32_t(imm_bytes & 0xFFFFFFFF));
		compile_bytes->push_back(int32_t((imm_bytes >> 32) & 0xFFFFFFFF));
		compile_bytes->push_back(value);
	}
	LLVMValueRef val = nullptr;
#ifdef USE_LLVM
	if(e->mode == fif_mode::compiling_llvm) {
		val = LLVMConstInt(LLVMInt32TypeInContext(e->llvm_context), uint32_t(value), true);
	}
#endif
	s.push_back_main(fif_i32, value, val);
}
inline int32_t* immediate_type(state_stack& s, int32_t* p, environment*) {
	int32_t data = 0;
	memcpy(&data, p + 2, 4);
	s.push_back_main(fif_type, data, nullptr);
	return p + 3;
}
inline void do_immediate_type(state_stack& s, int32_t value, environment* e) {
	if(typechecking_failed(e->mode))
		return;

	auto compile_bytes = e->compiler_stack.back()->bytecode_compilation_progress();
	if(compile_bytes && e->mode == fif_mode::compiling_bytecode) {
		fif_call imm = immediate_type;
		uint64_t imm_bytes = 0;
		memcpy(&imm_bytes, &imm, 8);
		compile_bytes->push_back(int32_t(imm_bytes & 0xFFFFFFFF));
		compile_bytes->push_back(int32_t((imm_bytes >> 32) & 0xFFFFFFFF));
		compile_bytes->push_back(value);
	}
	LLVMValueRef val = nullptr;
#ifdef USE_LLVM
	if(e->mode == fif_mode::compiling_llvm) {
		val = LLVMConstInt(LLVMInt32TypeInContext(e->llvm_context), uint32_t(value), true);
	}
#endif
	s.push_back_main(fif_type, value, val);
}
inline void do_immediate_bool(state_stack& s, bool value, environment* e) {
	if(typechecking_failed(e->mode))
		return;

	auto compile_bytes = e->compiler_stack.back()->bytecode_compilation_progress();
	if(compile_bytes && e->mode == fif_mode::compiling_bytecode) {
		fif_call imm = immediate_bool;
		uint64_t imm_bytes = 0;
		memcpy(&imm_bytes, &imm, 8);
		compile_bytes->push_back(int32_t(imm_bytes & 0xFFFFFFFF));
		compile_bytes->push_back(int32_t((imm_bytes >> 32) & 0xFFFFFFFF));
		compile_bytes->push_back(int32_t(value));
	}
	LLVMValueRef val = nullptr;
#ifdef USE_LLVM
	if(e->mode == fif_mode::compiling_llvm) {
		val = LLVMConstInt(LLVMInt1TypeInContext(e->llvm_context), uint32_t(value), true);
	}
#endif
	s.push_back_main(fif_bool, int64_t(value), val);
}
inline void do_immediate_f32(state_stack& s, float value, environment* e) {
	if(typechecking_failed(e->mode))
		return;

	int32_t v4 = 0;
	int64_t v8 = 0;
	memcpy(&v4, &value, 4);
	memcpy(&v8, &value, 4);

	auto compile_bytes = e->compiler_stack.back()->bytecode_compilation_progress();
	if(compile_bytes && e->mode == fif_mode::compiling_bytecode) {
		fif_call imm = immediate_f32;
		uint64_t imm_bytes = 0;
		memcpy(&imm_bytes, &imm, 8);
		compile_bytes->push_back(int32_t(imm_bytes & 0xFFFFFFFF));
		compile_bytes->push_back(int32_t((imm_bytes >> 32) & 0xFFFFFFFF));
		compile_bytes->push_back(v4);
	}
	LLVMValueRef val = nullptr;
#ifdef USE_LLVM
	if(e->mode == fif_mode::compiling_llvm) {
		val = LLVMConstReal(LLVMFloatTypeInContext(e->llvm_context), value);
	}
#endif
	s.push_back_main(fif_f32, v8, val);
}
inline int32_t* function_return(state_stack& s, int32_t* p, environment*) {
	return nullptr;
}

struct parse_result {
	std::string_view content;
	bool is_string = false;
};

inline void execute_fif_word(parse_result word, environment& env, bool ignore_specializations);

#ifdef USE_LLVM
inline LLVMTypeRef llvm_function_type_from_desc(environment& env, std::span<int32_t const> desc) {
	std::vector<LLVMTypeRef> parameter_group;
	std::vector<LLVMTypeRef> returns_group;

	/*
	* NOTE: function assumes that description is fully resolved
	*/

	int32_t match_position = 0;
	// stack matching

	//int32_t consumed_stack_cells = 0;
	while(match_position < int32_t(desc.size()) && desc[match_position] != -1) {
		parameter_group.push_back(env.dict.type_array[desc[match_position]].llvm_type);
		++match_position;
		//++consumed_stack_cells;
	}

	++match_position; // skip -1

	// output stack
	int32_t first_output_stack = match_position;
	//int32_t output_stack_types = 0;
	while(match_position < int32_t(desc.size()) && desc[match_position] != -1) {
		returns_group.push_back(env.dict.type_array[desc[match_position]].llvm_type);
		++match_position;
		//++output_stack_types;
	}
	++match_position; // skip -1

	// return stack matching
	//int32_t consumed_rstack_cells = 0;
	while(match_position < int32_t(desc.size()) && desc[match_position] != -1) {
		parameter_group.push_back(env.dict.type_array[desc[match_position]].llvm_type);
		++match_position;
		//++consumed_rstack_cells;
	}

	++match_position; // skip -1

	// output ret stack
	//int32_t ret_added = 0;
	while(match_position < int32_t(desc.size()) && desc[match_position] != -1) {
		returns_group.push_back(env.dict.type_array[desc[match_position]].llvm_type);
		++match_position;
		//++ret_added;
	}

	LLVMTypeRef ret_type = nullptr;
	if(returns_group.size() == 0) {
		ret_type = LLVMVoidTypeInContext(env.llvm_context);
	} else if(returns_group.size() == 1) {
		ret_type = returns_group[0];
	} else {
		ret_type = LLVMStructTypeInContext(env.llvm_context, returns_group.data(), uint32_t(returns_group.size()), false);
	}
	return LLVMFunctionType(ret_type, parameter_group.data(), uint32_t(parameter_group.size()), false);
}

inline void llvm_make_function_parameters(environment& env, LLVMValueRef fn, state_stack& ws, std::span<int32_t const> desc) {

	/*
	* NOTE: function assumes that description is fully resolved
	*/

	int32_t match_position = 0;
	// stack matching

	int32_t consumed_stack_cells = 0;
	while(match_position < int32_t(desc.size()) && desc[match_position] != -1) {
		ws.set_main_ex_back(consumed_stack_cells, LLVMGetParam(fn, uint32_t(consumed_stack_cells)));
		++match_position;
		++consumed_stack_cells;
	}

	++match_position; // skip -1

	// output stack
	int32_t first_output_stack = match_position;
	//int32_t output_stack_types = 0;
	while(match_position < int32_t(desc.size()) && desc[match_position] != -1) {
		++match_position;
		//++output_stack_types;
	}
	++match_position; // skip -1

	// return stack matching
	int32_t consumed_rstack_cells = 0;
	while(match_position < int32_t(desc.size()) && desc[match_position] != -1) {
		ws.set_return_ex_back(consumed_rstack_cells, LLVMGetParam(fn, uint32_t(consumed_stack_cells + consumed_stack_cells)));
		++match_position;
		++consumed_rstack_cells;
	}

	++match_position; // skip -1

	// output ret stack
	//int32_t ret_added = 0;
	while(match_position < int32_t(desc.size()) && desc[match_position] != -1) {
		++match_position;
		//++ret_added;
	}
}

struct brief_fn_return {
	LLVMTypeRef composite_type = nullptr;
	int32_t num_stack_values;
	int32_t num_rstack_values;
	bool is_struct_type;
};

inline brief_fn_return llvm_function_return_type_from_desc(environment& env, std::span<int32_t const> desc) {
	std::vector<LLVMTypeRef> returns_group;

	/*
	* NOTE: function assumes that description is fully resolved
	*/

	int32_t match_position = 0;
	// stack matching

	//int32_t consumed_stack_cells = 0;
	while(match_position < int32_t(desc.size()) && desc[match_position] != -1) {
		//parameter_group.push_back(env.dict.type_array[desc[match_position]].llvm_type);
		++match_position;
		//++consumed_stack_cells;
	}

	++match_position; // skip -1

	// output stack
	int32_t first_output_stack = match_position;
	int32_t output_stack_types = 0;
	while(match_position < int32_t(desc.size()) && desc[match_position] != -1) {
		returns_group.push_back(env.dict.type_array[desc[match_position]].llvm_type);
		++match_position;
		++output_stack_types;
	}
	++match_position; // skip -1

	// return stack matching
	//int32_t consumed_rstack_cells = 0;
	while(match_position < int32_t(desc.size()) && desc[match_position] != -1) {
		//parameter_group.push_back(env.dict.type_array[desc[match_position]].llvm_type);
		++match_position;
		//++consumed_rstack_cells;
	}

	++match_position; // skip -1

	// output ret stack
	int32_t ret_added = 0;
	while(match_position < int32_t(desc.size()) && desc[match_position] != -1) {
		returns_group.push_back(env.dict.type_array[desc[match_position]].llvm_type);
		++match_position;
		++ret_added;
	}

	LLVMTypeRef ret_type = nullptr;
	if(returns_group.size() == 0) {
		// leave as nullptr
	} else if(returns_group.size() == 1) {
		ret_type = returns_group[0];
	} else {
		ret_type = LLVMStructTypeInContext(env.llvm_context, returns_group.data(), uint32_t(returns_group.size()), false);
	}
	return brief_fn_return{ ret_type , output_stack_types, ret_added, returns_group.size()  > 1};
}

inline void llvm_make_function_return(environment& env, std::span<int32_t const> desc) {
	auto rsummary = llvm_function_return_type_from_desc( env, desc);
	
	if(rsummary.composite_type == nullptr) {
		LLVMBuildRetVoid(env.llvm_builder);
		return;
	}
	if(rsummary.is_struct_type == false) {
		if(rsummary.num_stack_values == 0) {
			LLVMBuildRet(env.llvm_builder, env.compiler_stack.back()->working_state()->return_ex_back(0));
			return;
		} else if(rsummary.num_rstack_values == 0) {
			LLVMBuildRet(env.llvm_builder, env.compiler_stack.back()->working_state()->main_ex_back(0));
			return;
		} else {
			assert(false);
		}
	}

	auto rstruct = LLVMGetUndef(rsummary.composite_type);
	uint32_t insert_index = 0;

	for(int32_t i = rsummary.num_stack_values - 1; i >= 0; --i) {
		rstruct = LLVMBuildInsertValue(env.llvm_builder, rstruct, env.compiler_stack.back()->working_state()->main_ex_back(i), insert_index, "");
		++insert_index;
	}
	for(int32_t i = rsummary.num_rstack_values - 1; i >= 0;  --i) {
		rstruct = LLVMBuildInsertValue(env.llvm_builder, rstruct, env.compiler_stack.back()->working_state()->return_ex_back(i), insert_index, "");
		++insert_index;
	}
	LLVMBuildRet(env.llvm_builder, rstruct);
	// LLVMBuildAggregateRet(env.llvm_builder, LLVMValueRef * RetVals, unsigned N);
}

inline void llvm_make_function_call(environment& env, LLVMValueRef fn, std::span<int32_t const> desc) {
	std::vector<LLVMValueRef> params;
	
	{
		int32_t match_position = 0;
		// stack matching

		//int32_t consumed_stack_cells = 0;
		while(match_position < int32_t(desc.size()) && desc[match_position] != -1) {
			params.push_back(env.compiler_stack.back()->working_state()->main_ex_back(0));
			env.compiler_stack.back()->working_state()->pop_main();
			++match_position;
			//++consumed_stack_cells;
		}

		++match_position; // skip -1

		// output stack
		int32_t first_output_stack = match_position;
		//int32_t output_stack_types = 0;
		while(match_position < int32_t(desc.size()) && desc[match_position] != -1) {
			//returns_group.push_back(env.dict.type_array[desc[match_position]].llvm_type.llvm_type);
			++match_position;
			//++output_stack_types;
		}
		++match_position; // skip -1

		// return stack matching
		//int32_t consumed_rstack_cells = 0;
		while(match_position < int32_t(desc.size()) && desc[match_position] != -1) {
			params.push_back(env.compiler_stack.back()->working_state()->return_ex_back(0));
			env.compiler_stack.back()->working_state()->pop_return();
			++match_position;
			//++consumed_rstack_cells;
		}
	}

	assert(fn);
	auto retvalue = LLVMBuildCall2(env.llvm_builder, llvm_function_type_from_desc(env, desc), fn, params.data(), uint32_t(params.size()), "");
	LLVMSetInstructionCallConv(retvalue, LLVMCallConv::LLVMFastCallConv);
	auto rsummary = llvm_function_return_type_from_desc(env, desc);

	if(rsummary.composite_type == nullptr) {
		return;
	}

	{
		uint32_t extract_index = 0;
		int32_t match_position = 0;
		// stack matching

		//int32_t consumed_stack_cells = 0;
		while(match_position < int32_t(desc.size()) && desc[match_position] != -1) {
			//parameter_group.push_back(env.dict.type_array[desc[match_position]].llvm_type);
			++match_position;
			//++consumed_stack_cells;
		}

		++match_position; // skip -1

		// output stack
		int32_t first_output_stack = match_position;
		//int32_t output_stack_types = 0;
		while(match_position < int32_t(desc.size()) && desc[match_position] != -1) {
			if(rsummary.is_struct_type == false) { // single return value
				env.compiler_stack.back()->working_state()->push_back_main(desc[match_position], 0, retvalue);
			} else {
				env.compiler_stack.back()->working_state()->push_back_main(desc[match_position], 0, LLVMBuildExtractValue(env.llvm_builder, retvalue, extract_index, ""));
			}
			++extract_index;
			++match_position;
			//++output_stack_types;
		}
		++match_position; // skip -1

		// return stack matching
		//int32_t consumed_rstack_cells = 0;
		while(match_position < int32_t(desc.size()) && desc[match_position] != -1) {
			//parameter_group.push_back(env.dict.type_array[desc[match_position]].llvm_type);
			++match_position;
			//++consumed_rstack_cells;
		}

		++match_position; // skip -1

		// output ret stack
		//int32_t ret_added = 0;
		while(match_position < int32_t(desc.size()) && desc[match_position] != -1) {
			if(rsummary.is_struct_type == false) { // single return value
				env.compiler_stack.back()->working_state()->push_back_return(desc[match_position], 0, retvalue);
			} else {
				env.compiler_stack.back()->working_state()->push_back_return(desc[match_position], 0, LLVMBuildExtractValue(env.llvm_builder, retvalue, extract_index, ""));
			}
			++extract_index;
			++match_position;
			//++ret_added;
		}
	}
}
#endif

inline std::vector<int32_t> expand_stack_description(state_stack& initial_stack_state, std::span<const int32_t> desc, int32_t stack_consumed, int32_t rstack_consumed);
inline bool compare_stack_description(std::span<const int32_t> a, std::span<const int32_t> b);

class locals_holder : public opaque_compiler_data {
public:
	ankerl::unordered_dense::map<std::string, std::unique_ptr<var_data>> vars;
	ankerl::unordered_dense::map<std::string, std::unique_ptr<let_data>> lets;
	environment& env;
	const bool llvm_mode;

	locals_holder(opaque_compiler_data* p, environment& env) : opaque_compiler_data(p), env(env), llvm_mode(env.mode == fif_mode::compiling_llvm) {
	}

	virtual var_data* get_var(std::string const& name)override {
		if(auto it = vars.find(name); it != vars.end()) {
			return it->second.get();
		}
		return parent->get_var(name);
	}
	virtual var_data* create_var(std::string const& name, int32_t type)override {
		if(auto it = lets.find(name); it != lets.end()) {
			return nullptr;
		}
		if(auto it = vars.find(name); it != vars.end()) {
			return nullptr;
		}

		auto added = vars.insert_or_assign(name, std::make_unique<var_data>());
		added.first->second->type = type;
		added.first->second->data = 0;
#ifdef USE_LLVM
		added.first->second->alloc = llvm_mode ? LLVMBuildAlloca(env.llvm_builder, env.dict.type_array[type].llvm_type, name.c_str()) : nullptr;
#endif
		return added.first->second.get();
	}
	virtual let_data* get_let(std::string const& name) override {
		if(auto it = lets.find(name); it != lets.end()) {
			return it->second.get();
		}
		return parent->get_let(name);
	}
	virtual let_data* create_let(std::string const& name, int32_t type, int64_t data, LLVMValueRef expression)override {
		if(auto it = lets.find(name); it != lets.end()) {
			return nullptr;
		}
		if(auto it = vars.find(name); it != vars.end()) {
			return nullptr;
		}
		auto added = lets.insert_or_assign(name, std::make_unique<let_data>());
		added.first->second->type = type;
		added.first->second->data = data;
		added.first->second->expression = expression;
		if(auto it = lets.find(name); it != lets.end()) {
			return  it->second.get();
		}
		return nullptr;
	}

	void release_locals() {
		auto* ws = env.compiler_stack.back()->working_state();
		for(auto& l : vars) {
			if(env.dict.type_array[l.second->type].flags != 0) {
#ifdef USE_LLVM
				auto iresult = LLVMBuildLoad2(env.llvm_builder, env.dict.type_array[l.second->type].llvm_type, l.second->alloc, "");
#else
				void* iresult = nullptr;
#endif
				ws->push_back_main(l.second->type, l.second->data, iresult);
				execute_fif_word(fif::parse_result{ "drop", false }, env, false);
			}
		}
		for(auto& l : lets) {
			if(env.dict.type_array[l.second->type].flags != 0) {
				ws->push_back_main(l.second->type, l.second->data, l.second->expression);
				execute_fif_word(fif::parse_result{ "drop", false }, env, false);
			}
		}
		vars.clear();
		lets.clear();
	}
};

class function_scope : public locals_holder {
public:
	std::unique_ptr<state_stack> initial_state;
	std::unique_ptr<state_stack> iworking_state;
	std::vector<int32_t> compiled_bytes;
	std::vector<int32_t> type_subs;
	LLVMValueRef llvm_fn = nullptr;
	LLVMBasicBlockRef current_block = nullptr;
	int32_t for_word = -1;
	int32_t for_instance = -1;


	function_scope(opaque_compiler_data* p, environment& e, state_stack& entry_state, int32_t for_word, int32_t for_instance) : locals_holder(p, e), for_word(for_word), for_instance(for_instance) {
		
		initial_state = entry_state.copy();
		iworking_state = entry_state.copy();

		if(for_word == -1) {
			env.report_error("attempted to compile a function for an anonymous word");
			env.mode = fif_mode::error;
			return;
		}

		
			if(typechecking_mode(env.mode))
				env.dict.word_array[for_word].being_typechecked = true;
			else if(env.mode == fif_mode::compiling_bytecode || env.mode == fif_mode::compiling_llvm) {
				assert(for_instance != -1);
				std::get<interpreted_word_instance>(env.dict.all_instances[for_instance]).being_compiled = true;
			}

			if(env.mode == fif_mode::compiling_llvm) {
				assert(for_instance != -1);
				auto fn_desc = std::span<int32_t const>(env.dict.all_stack_types.data() + std::get<interpreted_word_instance>(env.dict.all_instances[for_instance]).stack_types_start, std::get<interpreted_word_instance>(env.dict.all_instances[for_instance]).stack_types_count);

#ifdef USE_LLVM
				if(!std::get<interpreted_word_instance>(env.dict.all_instances[for_instance]).llvm_function) {
					auto fn_string_name = word_name_from_id(for_word, env) + "#" + std::to_string(for_instance);
					auto fn_type = llvm_function_type_from_desc(env, fn_desc);
					std::get<interpreted_word_instance>(env.dict.all_instances[for_instance]).llvm_function = LLVMAddFunction(env.llvm_module, fn_string_name.c_str(), fn_type);
				}
#endif
				auto compiled_fn = std::get<interpreted_word_instance>(env.dict.all_instances[for_instance]).llvm_function;
				llvm_fn = compiled_fn;

#ifdef USE_LLVM
				if(std::get<interpreted_word_instance>(env.dict.all_instances[for_instance]).is_imported_function)
					LLVMSetFunctionCallConv(compiled_fn, NATIVE_CC);
				else
					LLVMSetFunctionCallConv(compiled_fn, LLVMCallConv::LLVMFastCallConv);

				LLVMSetLinkage(compiled_fn, LLVMLinkage::LLVMPrivateLinkage);
				auto entry_block = LLVMAppendBasicBlockInContext(env.llvm_context, compiled_fn, "fn_entry_point");
				LLVMPositionBuilderAtEnd(env.llvm_builder, entry_block);
				llvm_make_function_parameters(env, compiled_fn, *iworking_state, fn_desc);

				current_block = entry_block;
#endif
			}
		
	}
	virtual std::vector<int32_t>* type_substitutions()override {
		return &type_subs;
	}
	virtual control_structure get_type()override {
		return control_structure::function;
	}
	virtual LLVMValueRef llvm_function()override {
		return llvm_fn;
	}
	virtual LLVMBasicBlockRef* llvm_block() override {
		return &current_block;
	}
	virtual int32_t word_id()override {
		return for_word;
	}
	virtual int32_t instance_id()override {
		return for_instance;
	}
	virtual std::vector<int32_t>* bytecode_compilation_progress()override {
		return &compiled_bytes;
	}
	virtual ankerl::unordered_dense::map<uint64_t, typecheck_3_record>* typecheck_record()override {
		return parent ? parent->typecheck_record() : nullptr;
	}
	virtual state_stack* working_state()override {
		return iworking_state.get();
	}
	virtual void set_working_state(std::unique_ptr<state_stack> p) override {
		iworking_state = std::move(p);
	}
	virtual bool finish(environment&)override {
		int32_t stack_consumed = int32_t(initial_state->main_size()) - int32_t(iworking_state->min_main_depth);
		int32_t rstack_consumed = int32_t(initial_state->return_size()) - int32_t(iworking_state->min_return_depth);
		int32_t stack_added = int32_t(iworking_state->main_size()) - int32_t(iworking_state->min_main_depth);
		int32_t rstack_added = int32_t(iworking_state->return_size()) - int32_t(iworking_state->min_return_depth);
		assert(stack_added >= 0);
		assert(rstack_added >= 0);
		assert(stack_consumed >= 0);
		assert(rstack_consumed >= 0);

		if(env.mode == fif_mode::typechecking_lvl_1) {
			word& w = env.dict.word_array[for_word];

			interpreted_word_instance temp;
			auto& current_stack = *iworking_state;

			temp.stack_types_start = int32_t(env.dict.all_stack_types.size());
			{
				for(int32_t i = 0; i < stack_consumed; ++i) {
					env.dict.all_stack_types.push_back(initial_state->main_type_back(i));
				}
			}
			int32_t skipped = 0;
			if(stack_added > 0) {
				env.dict.all_stack_types.push_back(-1);
				for(int32_t i = 1; i <= stack_added; ++i) {
					env.dict.all_stack_types.push_back(current_stack.main_type_back(stack_added - i));
				}
			} else {
				++skipped;
			}
			if(rstack_consumed > 0) {
				for(; skipped > 0; --skipped)
					env.dict.all_stack_types.push_back(-1);
				env.dict.all_stack_types.push_back(-1);
				for(int32_t i = 0; i < rstack_consumed; ++i) {
					env.dict.all_stack_types.push_back(initial_state->return_type_back(i));
				}
			} else {
				++skipped;
			}
			if(rstack_added > 0) {
				for(; skipped > 0; --skipped)
					env.dict.all_stack_types.push_back(-1);
				env.dict.all_stack_types.push_back(-1);
				for(int32_t i = 1; i <= rstack_added; ++i) {
					env.dict.all_stack_types.push_back(current_stack.return_type_back(rstack_added - i));
				}
			}
			temp.stack_types_count = int32_t(env.dict.all_stack_types.size()) - temp.stack_types_start;
			temp.typechecking_level = 1;

			if(for_instance == -1) {
				w.instances.push_back(int32_t(env.dict.all_instances.size()));
				env.dict.all_instances.push_back(std::move(temp));
			} else if(std::get<interpreted_word_instance>(env.dict.all_instances[for_instance]).typechecking_level == 0) {
				env.dict.all_instances[for_instance] = std::move(temp);
			}

			env.dict.word_array[for_word].being_typechecked = false;
		} else if(env.mode == fif_mode::typechecking_lvl_2) {
			if(for_instance == -1) {
				env.report_error("tried to level 2 typecheck a word without an instance");
				env.mode = fif_mode::error;
				return true;
			}
			interpreted_word_instance& wi = std::get<interpreted_word_instance>(env.dict.all_instances[for_instance]);
			std::span<const int32_t> existing_description = std::span<const int32_t>(env.dict.all_stack_types.data() + wi.stack_types_start, size_t(wi.stack_types_count));
			auto revised_description = expand_stack_description(*initial_state, existing_description, stack_consumed, rstack_consumed);

			if(!compare_stack_description(existing_description, std::span<const int32_t>(revised_description.data(), revised_description.size()))) {
				wi.stack_types_start = int32_t(env.dict.all_stack_types.size());
				wi.stack_types_count = int32_t(revised_description.size());
				env.dict.all_stack_types.insert(env.dict.all_stack_types.end(), revised_description.begin(), revised_description.end());
			}

			wi.typechecking_level = std::max(wi.typechecking_level, 2);
			env.dict.word_array[for_word].being_typechecked = false;
		} else if(env.mode == fif_mode::typechecking_lvl_3) {
			// no alterations -- handled explicitly by invoking lvl 3
			env.dict.word_array[for_word].being_typechecked = false;
		} else if(env.mode == fif_mode::compiling_bytecode) {
			if(for_instance == -1) {
				env.report_error("tried to compile a word without an instance");
				env.mode = fif_mode::error;
				return true;
			}

			fif_call imm = function_return;
			uint64_t imm_bytes = 0;
			memcpy(&imm_bytes, &imm, 8);
			compiled_bytes.push_back(int32_t(imm_bytes & 0xFFFFFFFF));
			compiled_bytes.push_back(int32_t((imm_bytes >> 32) & 0xFFFFFFFF));

			interpreted_word_instance& wi = std::get<interpreted_word_instance>(env.dict.all_instances[for_instance]);
			wi.compiled_bytecode = std::move(compiled_bytes);

			if(for_instance != -1)
				std::get<interpreted_word_instance>(env.dict.all_instances[for_instance]).being_compiled = false;
		} else if(env.mode == fif_mode::compiling_llvm) {
#ifdef USE_LLVM
			if(for_instance == -1) {
				env.report_error("tried to compile a word without an instance");
				env.mode = fif_mode::error;
				return true;
			}

			release_locals(); 

			interpreted_word_instance& wi = std::get<interpreted_word_instance>(env.dict.all_instances[for_instance]);
			std::span<const int32_t> existing_description = std::span<const int32_t>(env.dict.all_stack_types.data() + wi.stack_types_start, size_t(wi.stack_types_count));
			llvm_make_function_return(env, existing_description);
			wi.llvm_compilation_finished = true;

			if(LLVMVerifyFunction(wi.llvm_function, LLVMVerifierFailureAction::LLVMPrintMessageAction)) {

				std::string mod_contents = LLVMPrintModuleToString(env.llvm_module);

				char* message = nullptr;
				LLVMVerifyModule(env.llvm_module, LLVMReturnStatusAction, &message);

				env.report_error("LLVM verification of function failed");
				env.mode = fif_mode::error;
				return true;
			}

			if(for_instance != -1)
				std::get<interpreted_word_instance>(env.dict.all_instances[for_instance]).being_compiled = false;
#endif
		} else if(typechecking_failed(env.mode)) {
			env.dict.word_array[for_word].being_typechecked = false;
			return true;
		} else {
			env.report_error("reached end of compilation in unexpected mode");
			env.mode = fif_mode::error;
			return true;
		}
		return true;
	}
};

class runtime_function_scope : public locals_holder {
public:
	runtime_function_scope(opaque_compiler_data* p, environment& e) : locals_holder(p, e) {
	}
	virtual bool finish(environment&) override {
		release_locals();
		return true;
	}
	virtual control_structure get_type() override {
		return control_structure::function;
	}
};
inline int32_t* call_function(state_stack& s, int32_t* p, environment* env) {
	int32_t* jump_target = nullptr;
	memcpy(&jump_target, p + 2, 8);
	env->compiler_stack.push_back(std::make_unique<runtime_function_scope>(env->compiler_stack.back().get(), *env));
	execute_fif_word(s, jump_target, *env);
	env->compiler_stack.back()->finish(*env);
	env->compiler_stack.pop_back();
	return p + 4;
}
inline int32_t* call_function_indirect(state_stack& s, int32_t* p, environment* env) {
	auto instance = *(p + 2);
	env->compiler_stack.push_back(std::make_unique<runtime_function_scope>(env->compiler_stack.back().get(), *env));
	execute_fif_word(std::get<interpreted_word_instance>(env->dict.all_instances[instance]), s, *env);
	env->compiler_stack.back()->finish(*env);
	env->compiler_stack.pop_back();
	return p + 3;
}
inline int32_t* enter_scope(state_stack& s, int32_t* p, environment* env) {
	env->compiler_stack.push_back(std::make_unique<runtime_function_scope>(env->compiler_stack.back().get(), *env));
	return p + 2;
}
inline int32_t* leave_scope(state_stack& s, int32_t* p, environment* env) {
	env->compiler_stack.back()->finish(*env);
	env->compiler_stack.pop_back();
	return p + 2;
}

class mode_switch_scope : public opaque_compiler_data {
public:
	opaque_compiler_data* interpreted_link = nullptr;
	fif_mode entry_mode;
	fif_mode running_mode;

	mode_switch_scope(opaque_compiler_data* p, environment& env, fif_mode running_mode) : opaque_compiler_data(p), running_mode(running_mode) {
		[&]() {
			for(auto i = env.compiler_stack.size(); i-- > 0; ) {
				if(env.compiler_stack[i]->get_type() == control_structure::mode_switch) {
					mode_switch_scope* p = static_cast<mode_switch_scope*>(env.compiler_stack[i].get());
					if(p->running_mode == running_mode) {
						++i;
						for(; i < env.compiler_stack.size(); ++i) {
							if(env.compiler_stack[i]->get_type() == control_structure::mode_switch) {
								interpreted_link = env.compiler_stack[i - 1].get();
								return;
							}
						}
						interpreted_link = env.compiler_stack[env.compiler_stack.size() - 1].get();
						return;
					}
				}
			}
		}();
		entry_mode = env.mode;
		env.mode = running_mode;
	}

	virtual control_structure get_type()override {
		return control_structure::mode_switch;
	}
	virtual ankerl::unordered_dense::map<uint64_t, typecheck_3_record>* typecheck_record() override {
		return parent ? parent->typecheck_record() : nullptr;
	}
	virtual state_stack* working_state() override {
		return interpreted_link ? interpreted_link->working_state() : nullptr;
	}
	virtual var_data* get_var(std::string const& name) override {
		return interpreted_link ? interpreted_link->get_var(name) : nullptr;
	}
	virtual var_data* create_var(std::string const& name, int32_t type) override {
		return interpreted_link ? interpreted_link->create_var(name, type) : nullptr;
	}
	virtual let_data* get_let(std::string const& name) override {
		return interpreted_link ? interpreted_link->get_let(name) : nullptr;
	}
	virtual let_data* create_let(std::string const& name, int32_t type, int64_t data, LLVMValueRef expression)override {
		return interpreted_link ? interpreted_link->create_let(name, type, data, expression) : nullptr;
	}
	virtual void set_working_state(std::unique_ptr<state_stack> p)override {
		if(interpreted_link)
			interpreted_link->set_working_state(std::move(p));
	}
	virtual bool finish(environment& env)override {
		if(env.mode != fif_mode::error) {
			env.mode = entry_mode;
		}
		return true;
	}
};
inline void switch_compiler_stack_mode(environment& env, fif_mode new_mode) {
	auto m = std::make_unique<mode_switch_scope>(env.compiler_stack.back().get(), env, new_mode);
	env.compiler_stack.emplace_back(std::move(m));
}
inline void restore_compiler_stack_mode(environment& env) {
	if(env.compiler_stack.empty() || env.compiler_stack.back()->get_type() != control_structure::mode_switch) {
		env.report_error("attempt to switch mode back revealed an unbalanced compiler stack");
		env.mode = fif_mode::error;
		return;
	}
	env.compiler_stack.back()->finish(env);
	env.compiler_stack.pop_back();
}
class outer_interpreter : public opaque_compiler_data {
public:
	std::unique_ptr<state_stack> interpreter_state;

	ankerl::unordered_dense::map<std::string, std::unique_ptr<var_data>> global_vars;
	ankerl::unordered_dense::map<std::string, std::unique_ptr<let_data>> global_lets;

	virtual var_data* get_var(std::string const& name) override {
		if(auto it = global_vars.find(name); it != global_vars.end()) {
			return it->second.get();
		}
		return nullptr;
	}
	virtual var_data* create_var(std::string const& name, int32_t type) override {
		if(auto it = global_lets.find(name); it != global_lets.end()) {
			return nullptr;
		}
		if(auto it = global_vars.find(name); it != global_vars.end()) {
			return nullptr;
		}
		auto added = global_vars.insert_or_assign(name, std::make_unique<var_data>());
		added.first->second->type = type;
		added.first->second->data = 0;
		added.first->second->alloc = nullptr;
		return added.first->second.get();
	}
	virtual let_data* get_let(std::string const& name) override {
		if(auto it = global_lets.find(name); it != global_lets.end()) {
			return it->second.get();
		}
		return nullptr;
	}
	virtual let_data* create_let(std::string const& name, int32_t type, int64_t data, LLVMValueRef expression) override {
		if(auto it = global_lets.find(name); it != global_lets.end()) {
			return nullptr;
		}
		if(auto it = global_vars.find(name); it != global_vars.end()) {
			return nullptr;
		}
		auto added = global_lets.insert_or_assign(name, std::make_unique<let_data>());
		added.first->second->type = type;
		added.first->second->data = data;
		added.first->second->expression = expression;
		if(auto it = global_lets.find(name); it != global_lets.end()) {
			return it->second.get();
		}
		return nullptr;
	}

	outer_interpreter(environment& env) : opaque_compiler_data(nullptr), interpreter_state(std::make_unique<interpreter_stack>()) {
	}
	virtual control_structure get_type() override {
		return control_structure::none;
	}
	virtual state_stack* working_state()override {
		return interpreter_state.get();
	}
	virtual void set_working_state(std::unique_ptr<state_stack> p) override {
		interpreter_state = std::move(p);
	}
	virtual bool finish(environment& env)override {
		return true;
	}
};
class typecheck3_record_holder : public opaque_compiler_data {
public:
	ankerl::unordered_dense::map<uint64_t, typecheck_3_record> tr;

	typecheck3_record_holder(opaque_compiler_data* p, environment& env) : opaque_compiler_data(p) {
	}

	virtual control_structure get_type() override {
		return control_structure::none;
	}
	virtual ankerl::unordered_dense::map<uint64_t, typecheck_3_record>* typecheck_record()override {
		return &tr;
	}
	virtual bool finish(environment& env)override {
		return true;
	}
};


inline std::vector<int32_t> expand_stack_description(state_stack& initial_stack_state, std::span<const int32_t> desc, int32_t stack_consumed, int32_t rstack_consumed) {
	int32_t match_position = 0;
	// stack matching

	std::vector<int32_t> result;

	int32_t consumed_stack_cells = 0;
	while(match_position < int32_t(desc.size()) && desc[match_position] != -1) {
		auto match_size = next_encoded_stack_type(desc.subspan(match_position));
		result.insert(result.end(), desc.data() + match_position, desc.data() + match_position + match_size);
		match_position += match_size;
		++consumed_stack_cells;
	}
	if(consumed_stack_cells < stack_consumed) {
		for(int32_t i = consumed_stack_cells; i < stack_consumed; ++i) {
			result.push_back(initial_stack_state.main_type_back(i));
		}
	}

	if(consumed_stack_cells < stack_consumed || (match_position < int32_t(desc.size()) && desc[match_position] == -1)) {
		result.push_back(-1);
	}
	++match_position; // skip -1

	if(consumed_stack_cells < stack_consumed) { // add additional touched inputs to the end
		for(int32_t i = stack_consumed - 1; i >= consumed_stack_cells; --i) {
			result.push_back(initial_stack_state.main_type_back(i));
		}
	}

	int32_t first_output_stack = match_position;
	//int32_t output_stack_types = 0;
	while(match_position < int32_t(desc.size()) && desc[match_position] != -1) {
		auto match_size = next_encoded_stack_type(desc.subspan(match_position));
		result.insert(result.end(), desc.data() + match_position, desc.data() + match_position + match_size);
		match_position += match_size;
		//++output_stack_types;
	}

	if(rstack_consumed > 0 || (match_position < int32_t(desc.size()) && desc[match_position] == -1)) {
		result.push_back(-1);
	}
	++match_position; // skip -1

	// return stack matching
	int32_t consumed_rstack_cells = 0;
	while(match_position < int32_t(desc.size()) && desc[match_position] != -1) {
		auto match_size = next_encoded_stack_type(desc.subspan(match_position));
		result.insert(result.end(), desc.data() + match_position, desc.data() + match_position + match_size);
		match_position += match_size;
		++consumed_rstack_cells;
	}
	if(consumed_rstack_cells < rstack_consumed) {
		for(int32_t i = consumed_rstack_cells; i < rstack_consumed; ++i) {
			result.push_back(initial_stack_state.return_type_back(i));
		}
	}

	if(consumed_rstack_cells < rstack_consumed || (match_position < int32_t(desc.size()) && desc[match_position] == -1)) {
		result.push_back(-1);
	}
	++match_position; // skip -1

	if(consumed_rstack_cells < rstack_consumed) { // add additional touched inputs to the end
		for(int32_t i = rstack_consumed - 1; i >= consumed_rstack_cells; --i) {
			result.push_back(initial_stack_state.return_type_back(i));
		}
	}

	// add new types
	int32_t ret_added = 0;
	while(match_position < int32_t(desc.size()) && desc[match_position] != -1) {
		auto match_size = next_encoded_stack_type(desc.subspan(match_position));
		result.insert(result.end(), desc.data() + match_position, desc.data() + match_position + match_size);
		match_position += match_size;
	}

	return result;
}

inline bool compare_stack_description(std::span<const int32_t> a, std::span<const int32_t> b) {
	if(a.size() != b.size())
		return false;
	for(auto i = a.size(); i-- > 0; ) {
		if(a[i] != b[i])
			return false;
	}
	return true;
}

inline bool stack_types_match(state_stack& a, state_stack& b) {
	if(a.main_size() != b.main_size() || a.return_size() != b.return_size()) {
		return false;
	}
	for(size_t i = a.main_size();  i-- > 0; ) {
		if(a.main_type(i) != b.main_type(i))
			return false;
	}
	for(size_t i = a.return_size();  i-- > 0; ) {
		if(a.return_type(i) != b.return_type(i))
			return false;
	}
	return true;
}

inline int32_t* conditional_jump(state_stack& s, int32_t* p, environment* env) {
	auto value = s.main_data_back(0);
	s.pop_main();
	if(value == 0)
		return p + *(p + 2);
	else
		return p + 3;
}
inline int32_t* reverse_conditional_jump(state_stack& s, int32_t* p, environment* env) {
	auto value = s.main_data_back(0);
	s.pop_main();
	if(value != 0)
		return p + *(p + 2);
	else
		return p + 3;
}
inline int32_t* unconditional_jump(state_stack& s, int32_t* p, environment* env) {
	return p + *(p + 2);
}

class conditional_scope : public locals_holder {
public:
	std::unique_ptr<state_stack> initial_state;
	std::unique_ptr<state_stack> iworking_state;
	std::unique_ptr<state_stack> first_branch_state;
	LLVMValueRef branch_condition = nullptr;
	LLVMBasicBlockRef parent_block = nullptr;
	LLVMBasicBlockRef true_block = nullptr;
	LLVMBasicBlockRef false_block = nullptr;
	bool interpreter_skipped_first_branch = false;
	bool interpreter_skipped_second_branch = false;
	bool typechecking_failed_on_first_branch = false;
	bool initial_typechecking_failed = false;
	size_t bytecode_first_branch_point = 0;
	size_t bytecode_second_branch_point = 0;

	conditional_scope(opaque_compiler_data* p, environment& e, state_stack& entry_state) : locals_holder(p, e) {	
		if(entry_state.main_size() == 0 || entry_state.main_type_back(0) != fif_bool) {
			env.report_error("attempted to start an if without a boolean value on the stack");
			env.mode = fif_mode::error;
		}
		if(env.mode == fif_mode::interpreting) {
			if(entry_state.main_data_back(0) != 0) {
				interpreter_skipped_second_branch = true;
			} else {
				interpreter_skipped_first_branch = true;
				env.mode = fif_mode::typechecking_lvl1_failed;
				entry_state.pop_main();
			}
		}
		if(env.mode == fif_mode::compiling_llvm) {
#ifdef USE_LLVM
			branch_condition = entry_state.main_ex_back(0);
			if(auto pb = env.compiler_stack.back()->llvm_block(); pb) {
				parent_block = *pb;
				*pb = LLVMCreateBasicBlockInContext(env.llvm_context, "if-first-branch");
				LLVMAppendExistingBasicBlock(env.compiler_stack.back()->llvm_function(), *pb);
				LLVMPositionBuilderAtEnd(env.llvm_builder, *pb);
			}
#endif
		}
		if(env.mode == fif_mode::compiling_bytecode) {
			auto bcode = parent->bytecode_compilation_progress();

			fif_call imm = conditional_jump;
			uint64_t imm_bytes = 0;
			memcpy(&imm_bytes, &imm, 8);
			bcode->push_back(int32_t(imm_bytes & 0xFFFFFFFF));
			bcode->push_back(int32_t((imm_bytes >> 32) & 0xFFFFFFFF));
			bytecode_first_branch_point = bcode->size();
			bcode->push_back(0);

			fif_call imm2 = enter_scope;
			uint64_t imm2_bytes = 0;
			memcpy(&imm2_bytes, &imm2, 8);
			bcode->push_back(int32_t(imm2_bytes & 0xFFFFFFFF));
			bcode->push_back(int32_t((imm2_bytes >> 32) & 0xFFFFFFFF));
		}
		initial_typechecking_failed = typechecking_failed(env.mode);
		if(!typechecking_failed(env.mode))
			entry_state.pop_main();

		initial_state = entry_state.copy();
		initial_state->min_main_depth = entry_state.min_main_depth;
		initial_state->min_return_depth = entry_state.min_return_depth;

		iworking_state = entry_state.copy();
	}
	void commit_first_branch(environment&) {
		if(first_branch_state) {
			env.report_error("attempted to compile multiple else conditions");
			env.mode = fif_mode::error;
			return;
		}

		if(interpreter_skipped_first_branch) {
			env.mode = fif_mode::interpreting;
		} else if(interpreter_skipped_second_branch) {
			env.mode = fif_mode::typechecking_lvl1_failed;
		} else { // not interpreted mode
			first_branch_state = std::move(iworking_state);
			iworking_state = initial_state->copy();
			release_locals();

			if(env.mode == fif_mode::compiling_llvm) {
#ifdef USE_LLVM
				if(auto pb = env.compiler_stack.back()->llvm_block(); pb) {
					true_block = *pb;
					*pb = LLVMCreateBasicBlockInContext(env.llvm_context, "if-else-branch");
					false_block = *pb;
					LLVMAppendExistingBasicBlock(parent->llvm_function(), *pb);
					LLVMPositionBuilderAtEnd(env.llvm_builder, *pb);
				}
#endif
			}
			if(env.mode == fif_mode::compiling_bytecode) {
				auto bcode = parent->bytecode_compilation_progress();
				{
					fif_call imm2 = leave_scope;
					uint64_t imm2_bytes = 0;
					memcpy(&imm2_bytes, &imm2, 8);
					bcode->push_back(int32_t(imm2_bytes & 0xFFFFFFFF));
					bcode->push_back(int32_t((imm2_bytes >> 32) & 0xFFFFFFFF));
				}
				fif_call imm = unconditional_jump;
				uint64_t imm_bytes = 0;
				memcpy(&imm_bytes, &imm, 8);
				bcode->push_back(int32_t(imm_bytes & 0xFFFFFFFF));
				bcode->push_back(int32_t((imm_bytes >> 32) & 0xFFFFFFFF));
				bytecode_second_branch_point = bcode->size();
				bcode->push_back(0);
				(*bcode)[bytecode_first_branch_point] = int32_t(bcode->size() - (bytecode_first_branch_point - 2));
				{
					fif_call imm2 = enter_scope;
					uint64_t imm2_bytes = 0;
					memcpy(&imm2_bytes, &imm2, 8);
					bcode->push_back(int32_t(imm2_bytes & 0xFFFFFFFF));
					bcode->push_back(int32_t((imm2_bytes >> 32) & 0xFFFFFFFF));
				}
			}
			if(typechecking_failed(env.mode)) {
				typechecking_failed_on_first_branch = true;
				env.mode = reset_typechecking(env.mode);
			}
		}
	}
	virtual control_structure get_type()override {
		return control_structure::str_if;
	}
	virtual state_stack* working_state() override {
		return iworking_state.get();
	}
	virtual void set_working_state(std::unique_ptr<state_stack> p)override {
		iworking_state = std::move(p);
	}
	virtual bool finish(environment&)override {
		if(interpreter_skipped_second_branch) {
			env.mode = fif_mode::interpreting;
		}
		if(env.mode == fif_mode::interpreting) {
			release_locals();
			parent->set_working_state(std::move(iworking_state));
			return true;
		}

		bool final_types_match = true;
		if(first_branch_state) {
			if(!initial_typechecking_failed && !typechecking_failed_on_first_branch && !typechecking_failed(env.mode)) {
				final_types_match = stack_types_match(*first_branch_state, *iworking_state);
			}
		} else {
			if(!typechecking_failed(env.mode))
				final_types_match = stack_types_match(*initial_state , *iworking_state);
		}

		if(!final_types_match) {
			if(typechecking_mode(env.mode)) {
				env.mode = fail_typechecking(env.mode);
				return true;
			} else {
				env.report_error("inconsistent stack types over a conditional branch");
				env.mode = fif_mode::error;
				return true;
			}
		}

		if(typechecking_mode(env.mode)) {
			if(typechecking_failed_on_first_branch && typechecking_failed(env.mode))
				return true; // failed to typecheck on both branches
			if(initial_typechecking_failed) {
				env.mode = fail_typechecking(env.mode);
				return true;
			}
		}

		release_locals();

		if(env.mode == fif_mode::compiling_bytecode) {
			auto bcode = parent->bytecode_compilation_progress();

			{
				fif_call imm2 = leave_scope;
				uint64_t imm2_bytes = 0;
				memcpy(&imm2_bytes, &imm2, 8);
				bcode->push_back(int32_t(imm2_bytes & 0xFFFFFFFF));
				bcode->push_back(int32_t((imm2_bytes >> 32) & 0xFFFFFFFF));
			}

			if(!first_branch_state)
				(*bcode)[bytecode_first_branch_point] = int32_t(bcode->size() - (bytecode_first_branch_point - 2));
			else
				(*bcode)[bytecode_second_branch_point] = int32_t(bcode->size() - (bytecode_second_branch_point - 2));
		}

		if(env.mode == fif_mode::compiling_llvm) {
#ifdef USE_LLVM
			auto pb = env.compiler_stack.back()->llvm_block();
			auto current_block = *pb;

			if(first_branch_state) {

				LLVMPositionBuilderAtEnd(env.llvm_builder, parent_block);
				LLVMBuildCondBr(env.llvm_builder, branch_condition, true_block, false_block);
				auto in_fn = env.compiler_stack.back()->llvm_function();

				auto post_if = LLVMCreateBasicBlockInContext(env.llvm_context, "then-branch");
				*pb = post_if;

				LLVMAppendExistingBasicBlock(in_fn, post_if);

				LLVMPositionBuilderAtEnd(env.llvm_builder, current_block);
				LLVMBuildBr(env.llvm_builder, post_if);
				LLVMPositionBuilderAtEnd(env.llvm_builder, true_block);
				LLVMBuildBr(env.llvm_builder, post_if);

				/*
				* build phi nodes
				*/

				LLVMPositionBuilderAtEnd(env.llvm_builder, post_if);

				for(auto i = iworking_state->main_size(); i-- > 0; ) {
					if(iworking_state->main_ex(i) != first_branch_state->main_ex(i)) {
						auto phi_ref = LLVMBuildPhi(env.llvm_builder, env.dict.type_array[iworking_state->main_type(i)].llvm_type, "if-phi");
						LLVMValueRef inc_vals[2] = { iworking_state->main_ex(i), first_branch_state->main_ex(i) };
						LLVMBasicBlockRef inc_blocks[2] = { current_block, true_block };
						LLVMAddIncoming(phi_ref, inc_vals, inc_blocks, 2);
						iworking_state->set_main_ex(i, phi_ref);
					} else {
						// leave working state as is
					}
				}
				for(auto i = iworking_state->return_size(); i-- > 0; ) {
					if(iworking_state->return_ex(i) != first_branch_state->return_ex(i)) {
						auto phi_ref = LLVMBuildPhi(env.llvm_builder, env.dict.type_array[iworking_state->return_type(i)].llvm_type, "if-phi");
						LLVMValueRef inc_vals[2] = { iworking_state->return_ex(i), first_branch_state->return_ex(i) };
						LLVMBasicBlockRef inc_blocks[2] = { current_block, true_block };
						LLVMAddIncoming(phi_ref, inc_vals, inc_blocks, 2);
						iworking_state->set_return_ex(i, phi_ref);
					} else {
						// leave working state as is
					}
				}
			} else {
				auto in_fn = env.compiler_stack.back()->llvm_function();
				auto post_if = LLVMCreateBasicBlockInContext(env.llvm_context, "then-branch");
				*pb = post_if;

				LLVMAppendExistingBasicBlock(in_fn, post_if);

				LLVMPositionBuilderAtEnd(env.llvm_builder, parent_block);
				LLVMBuildCondBr(env.llvm_builder, branch_condition, current_block, post_if);

				LLVMPositionBuilderAtEnd(env.llvm_builder, current_block);
				LLVMBuildBr(env.llvm_builder, post_if);

				/*
				* build phi nodes
				*/

				LLVMPositionBuilderAtEnd(env.llvm_builder, post_if);

				for(auto i = iworking_state->main_size(); i-- > 0; ) {
					if(iworking_state->main_ex(i) != initial_state->main_ex(i)) {
						auto phi_ref = LLVMBuildPhi(env.llvm_builder, env.dict.type_array[iworking_state->main_type(i)].llvm_type, "if-phi");
						LLVMValueRef inc_vals[2] = { iworking_state->main_ex(i), initial_state->main_ex(i) };
						LLVMBasicBlockRef inc_blocks[2] = { current_block, parent_block };
						LLVMAddIncoming(phi_ref, inc_vals, inc_blocks, 2);
						iworking_state->set_main_ex(i, phi_ref);
					} else {
						// leave working state as is
					}
				}
				for(auto i = iworking_state->return_size(); i-- > 0; ) {
					if(iworking_state->return_ex(i) != initial_state->return_ex(i)) {
						auto phi_ref = LLVMBuildPhi(env.llvm_builder, env.dict.type_array[iworking_state->return_type(i)].llvm_type, "if-phi");
						LLVMValueRef inc_vals[2] = { iworking_state->return_ex(i), initial_state->return_ex(i) };
						LLVMBasicBlockRef inc_blocks[2] = { current_block, parent_block };
						LLVMAddIncoming(phi_ref, inc_vals, inc_blocks, 2);
						iworking_state->set_return_ex(i, phi_ref);
					} else {
						// leave working state as is
					}
				}
			}
#endif
		}

		// branch reconciliation
		if(first_branch_state && !initial_typechecking_failed && !typechecking_failed_on_first_branch && typechecking_failed(env.mode)) {
			// case: second branch failed to typecheck, but first branch passed
			iworking_state = std::move(first_branch_state);
			iworking_state->min_main_depth = std::min(iworking_state->min_main_depth, initial_state->min_main_depth);
			iworking_state->min_return_depth = std::min(iworking_state->min_return_depth, initial_state->min_return_depth);

		} else if(first_branch_state && !initial_typechecking_failed && typechecking_failed_on_first_branch &&!typechecking_failed(env.mode)) {
			// case: first branch failed to typecheck, but second branch passed
			iworking_state->min_main_depth = std::min(iworking_state->min_main_depth, initial_state->min_main_depth);
			iworking_state->min_return_depth = std::min(iworking_state->min_return_depth, initial_state->min_return_depth);

		} else if(first_branch_state && !initial_typechecking_failed && !typechecking_failed_on_first_branch && !typechecking_failed(env.mode)) {
			// case both branches typechecked
			iworking_state->min_main_depth = std::min(iworking_state->min_main_depth, first_branch_state->min_main_depth);
			iworking_state->min_return_depth = std::min(iworking_state->min_return_depth, first_branch_state->min_return_depth);
			iworking_state->min_main_depth = std::min(iworking_state->min_main_depth, initial_state->min_main_depth);
			iworking_state->min_return_depth = std::min(iworking_state->min_return_depth, initial_state->min_return_depth);
		} else if(first_branch_state && !initial_typechecking_failed && typechecking_failed_on_first_branch && typechecking_failed(env.mode)) {
			// case both branches failed to typechecked
			// don't set working state
			return true;

		} else if(!first_branch_state && typechecking_failed(env.mode) && !initial_typechecking_failed) {
			// case: single branch failed to typecheck
			iworking_state = std::move(initial_state);

		} else if(!first_branch_state && !initial_typechecking_failed && !typechecking_failed(env.mode)) {
			// case: single branch typechecked
			iworking_state->min_main_depth = std::min(iworking_state->min_main_depth, initial_state->min_main_depth);
			iworking_state->min_return_depth = std::min(iworking_state->min_return_depth, initial_state->min_return_depth);

		} else if(initial_typechecking_failed) {
			// case: typechecking failed going into the conditional
			// dont set working state
			env.mode = fail_typechecking(env.mode);
			return true;

		}

		parent->set_working_state(std::move(iworking_state));
		env.mode = reset_typechecking(env.mode);
		return true;
	}
};

class while_loop_scope : public locals_holder {
public:
	std::unique_ptr<state_stack> initial_state;
	std::unique_ptr<state_stack> iworking_state;
	std::unique_ptr<state_stack> loop_entry_copy;

	std::string_view entry_source;
	size_t loop_entry_point = 0;
	size_t end_of_loop_branch = 0;
	bool phi_pass = false;
	bool intepreter_skip_body = false;
	bool saw_conditional = false;
	bool initial_typechecking_failed = false;
	LLVMValueRef conditional_expr = nullptr;
	LLVMBasicBlockRef pre_block = nullptr;
	LLVMBasicBlockRef entry_block = nullptr;
	LLVMBasicBlockRef body_block = nullptr;
	std::vector<LLVMValueRef> phinodes;

	while_loop_scope(opaque_compiler_data* p, environment& e, state_stack& entry_state) : locals_holder(p, e) {
		initial_state = entry_state.copy();
		iworking_state = entry_state.copy();
		initial_state->min_main_depth = entry_state.min_main_depth;
		initial_state->min_return_depth = entry_state.min_return_depth;
		initial_typechecking_failed = typechecking_failed(env.mode);

		if(!env.source_stack.empty()) {
			entry_source = env.source_stack.back();
		}
		if(env.mode == fif_mode::compiling_bytecode) {
			auto bcode = parent->bytecode_compilation_progress();
			loop_entry_point = bcode->size();

			{
				fif_call imm2 = enter_scope;
				uint64_t imm2_bytes = 0;
				memcpy(&imm2_bytes, &imm2, 8);
				bcode->push_back(int32_t(imm2_bytes & 0xFFFFFFFF));
				bcode->push_back(int32_t((imm2_bytes >> 32) & 0xFFFFFFFF));
			}
		}
		if(env.mode == fif_mode::compiling_llvm) {
			phi_pass = true;
			env.mode = fif_mode::typechecking_lvl_2;
			if(auto pb = env.compiler_stack.back()->llvm_block(); pb) {
				pre_block = *pb;
			}
		}
	}

	virtual control_structure get_type()override {
		return control_structure::str_while_loop;
	}
	virtual state_stack* working_state() override {
		return iworking_state.get();
	}
	virtual void set_working_state(std::unique_ptr<state_stack> p) override {
		iworking_state = std::move(p);
	}
	void end_condition(environment&) {
		if(saw_conditional) {
			env.report_error("multiple conditions in while loop");
			env.mode = fif_mode::error;
			return;
		}
		saw_conditional = true;

		if(!typechecking_failed(env.mode)) {
			if(iworking_state->main_type_back(0) != fif_bool) {
				if(!typechecking_mode(env.mode)) {
					env.report_error("while loop conditional expression did not produce a boolean");
					env.mode = fif_mode::error;
					return;
				} else {
					env.mode = fail_typechecking(env.mode);
					return;
				}
			}

			release_locals();

			if(env.mode == fif_mode::interpreting) {
				if(iworking_state->main_data_back(0) == 0) {
					intepreter_skip_body = true;
					env.mode = fif_mode::typechecking_lvl1_failed;
				}
				iworking_state->pop_main();
			} else if(env.mode == fif_mode::compiling_bytecode) {
				auto bcode = parent->bytecode_compilation_progress();

				{
					fif_call imm2 = leave_scope;
					uint64_t imm2_bytes = 0;
					memcpy(&imm2_bytes, &imm2, 8);
					bcode->push_back(int32_t(imm2_bytes & 0xFFFFFFFF));
					bcode->push_back(int32_t((imm2_bytes >> 32) & 0xFFFFFFFF));
				}

				fif_call imm = conditional_jump;
				uint64_t imm_bytes = 0;
				memcpy(&imm_bytes, &imm, 8);
				bcode->push_back(int32_t(imm_bytes & 0xFFFFFFFF));
				bcode->push_back(int32_t((imm_bytes >> 32) & 0xFFFFFFFF));
				end_of_loop_branch = bcode->size();
				bcode->push_back(0);
				iworking_state->pop_main();

				{
					fif_call imm2 = enter_scope;
					uint64_t imm2_bytes = 0;
					memcpy(&imm2_bytes, &imm2, 8);
					bcode->push_back(int32_t(imm2_bytes & 0xFFFFFFFF));
					bcode->push_back(int32_t((imm2_bytes >> 32) & 0xFFFFFFFF));
				}
			} else if(env.mode == fif_mode::compiling_llvm) {
#ifdef USE_LLVM
				if(auto pb = env.compiler_stack.back()->llvm_block(); pb) {
					conditional_expr = iworking_state->main_ex_back(0);
					iworking_state->pop_main();

					*pb = LLVMCreateBasicBlockInContext(env.llvm_context, "loop_body");
					body_block = *pb;
					LLVMAppendExistingBasicBlock(parent->llvm_function(), *pb);
					LLVMPositionBuilderAtEnd(env.llvm_builder, *pb);
				}
#endif
			} else if(typechecking_mode(env.mode)) {
				iworking_state->pop_main();
				if(!stack_types_match(*initial_state, *iworking_state)) {
					env.mode = fail_typechecking(env.mode);
				}
			}
		}
	}
	virtual bool finish(environment&) override {
		if(env.mode == fif_mode::typechecking_lvl1_failed && intepreter_skip_body) {
			env.mode = fif_mode::interpreting;
			
			release_locals();

			parent->set_working_state(std::move(iworking_state));
			return true;
		}

		release_locals();

		if(env.mode == fif_mode::interpreting) {
			if(!saw_conditional && iworking_state->main_type_back(0) == fif_bool) {
				if(iworking_state->main_data_back(0) == 0) {
					iworking_state->pop_main();
					parent->set_working_state(std::move(iworking_state));
					return true;
				}
				iworking_state->pop_main();
			}
			saw_conditional = false;
			if(!env.source_stack.empty())
				env.source_stack.back() = entry_source;
			return false;
		}

		if(env.mode == fif_mode::compiling_bytecode) {
			if(!saw_conditional) {
				if(iworking_state->main_type_back(0) == fif_bool) {
					iworking_state->pop_main();
				} else {
					env.report_error("while loop terminated with an appropriate conditional");
					env.mode = fif_mode::error;
					return true;
				}

				auto bcode = parent->bytecode_compilation_progress();

				{
					fif_call imm2 = leave_scope;
					uint64_t imm2_bytes = 0;
					memcpy(&imm2_bytes, &imm2, 8);
					bcode->push_back(int32_t(imm2_bytes & 0xFFFFFFFF));
					bcode->push_back(int32_t((imm2_bytes >> 32) & 0xFFFFFFFF));
				}

				fif_call imm = reverse_conditional_jump;
				uint64_t imm_bytes = 0;
				memcpy(&imm_bytes, &imm, 8);
				bcode->push_back(int32_t(imm_bytes & 0xFFFFFFFF));
				bcode->push_back(int32_t((imm_bytes >> 32) & 0xFFFFFFFF));
				end_of_loop_branch = bcode->size();
				bcode->push_back(int32_t(int64_t(loop_entry_point) - int64_t(bcode->size() - 2)));
			}

			bool final_types_match = stack_types_match(*initial_state, *iworking_state);
			if(!final_types_match) {
				env.report_error("while loop had a net stack effect");
				env.mode = fif_mode::error;
				return true;
			}

			if(saw_conditional) {
				auto bcode = parent->bytecode_compilation_progress();

				{
					fif_call imm2 = leave_scope;
					uint64_t imm2_bytes = 0;
					memcpy(&imm2_bytes, &imm2, 8);
					bcode->push_back(int32_t(imm2_bytes & 0xFFFFFFFF));
					bcode->push_back(int32_t((imm2_bytes >> 32) & 0xFFFFFFFF));
				}

				fif_call imm = unconditional_jump;
				uint64_t imm_bytes = 0;
				memcpy(&imm_bytes, &imm, 8);
				bcode->push_back(int32_t(imm_bytes & 0xFFFFFFFF));
				bcode->push_back(int32_t((imm_bytes >> 32) & 0xFFFFFFFF));
				bcode->push_back(int32_t(int64_t(loop_entry_point) - int64_t(bcode->size() - 2)));
				(*bcode)[end_of_loop_branch] = int32_t(bcode->size() - (end_of_loop_branch - 2));;
			}

			iworking_state->min_main_depth = std::min(iworking_state->min_main_depth, initial_state->min_main_depth);
			iworking_state->min_return_depth = std::min(iworking_state->min_return_depth, initial_state->min_return_depth);
			parent->set_working_state(std::move(iworking_state));

			return true;
		} else if(env.mode == fif_mode::compiling_llvm) {
#ifdef USE_LLVM
			if(!saw_conditional) {
				if(auto pb = env.compiler_stack.back()->llvm_block(); pb) {
					conditional_expr = iworking_state->main_ex_back(0);
					iworking_state->pop_main();

					*pb = LLVMCreateBasicBlockInContext(env.llvm_context, "loop_body");
					body_block = *pb;
					LLVMAppendExistingBasicBlock(parent->llvm_function(), *pb);
					LLVMPositionBuilderAtEnd(env.llvm_builder, *pb);
				}
			}

			bool final_types_match = stack_types_match(*initial_state, *iworking_state);
			if(!final_types_match) {
				env.report_error("while loop had a net stack effect");
				env.mode = fif_mode::error;
				return true;
			}

			if(auto pb = env.compiler_stack.back()->llvm_block(); pb) {
				auto in_block = *pb;
				LLVMBuildBr(env.llvm_builder, entry_block);

				*pb = LLVMCreateBasicBlockInContext(env.llvm_context, "post_loop");
				LLVMAppendExistingBasicBlock(parent->llvm_function(), *pb);

				LLVMPositionBuilderAtEnd(env.llvm_builder, entry_block);
				LLVMBuildCondBr(env.llvm_builder, conditional_expr, body_block, *pb);

				LLVMPositionBuilderAtEnd(env.llvm_builder, *pb);

				/*
				set phi inputs in entry block
				*/
				uint32_t node_index = 0;
				for(auto i = iworking_state->main_size(); i-- > iworking_state->min_main_depth; ) {
					if(phinodes[node_index] == iworking_state->main_ex(i)) { // phi node unchanged
						LLVMValueRef inc_vals[1] = { initial_state->main_ex(i) };
						LLVMBasicBlockRef inc_blocks[1] = { pre_block };
						LLVMAddIncoming(phinodes[node_index], inc_vals, inc_blocks, 1);
					} else { 
						LLVMValueRef inc_vals[2] = { iworking_state->main_ex(i), initial_state->main_ex(i) };
						LLVMBasicBlockRef inc_blocks[2] = { in_block, pre_block };
						LLVMAddIncoming(phinodes[node_index], inc_vals, inc_blocks, 2);
					}
					++node_index;
				}
				for(auto i = iworking_state->return_size(); i-- > iworking_state->min_return_depth; ) {
					if(phinodes[node_index] == iworking_state->return_ex(i)) { // phi node unchanged
						LLVMValueRef inc_vals[1] = { initial_state->return_ex(i) };
						LLVMBasicBlockRef inc_blocks[1] = { pre_block };
						LLVMAddIncoming(phinodes[node_index], inc_vals, inc_blocks, 1);
					} else {
						LLVMValueRef inc_vals[2] = { iworking_state->return_ex(i), initial_state->return_ex(i) };
						LLVMBasicBlockRef inc_blocks[2] = { in_block, pre_block };
						LLVMAddIncoming(phinodes[node_index], inc_vals, inc_blocks, 2);
					}
					++node_index;
				}
			}

			loop_entry_copy->min_main_depth = std::min(iworking_state->min_main_depth, initial_state->min_main_depth);
			loop_entry_copy->min_return_depth = std::min(iworking_state->min_return_depth, initial_state->min_return_depth);
			parent->set_working_state(std::move(loop_entry_copy));

			return true;
#endif
		} else if(env.mode == fif_mode::typechecking_lvl_2 && phi_pass == true) {
#ifdef USE_LLVM
			phi_pass = false;
			if(!saw_conditional) {
				iworking_state->pop_main();
			}


			if(auto pb = env.compiler_stack.back()->llvm_block(); pb) {
				*pb = LLVMCreateBasicBlockInContext(env.llvm_context, "while_entry");
				entry_block = *pb;
				LLVMAppendExistingBasicBlock(parent->llvm_function(), *pb);

				LLVMBuildBr(env.llvm_builder, entry_block);
				LLVMPositionBuilderAtEnd(env.llvm_builder, *pb);

				/*
				build entry phi_nodes
				*/
				for(auto i = iworking_state->main_size(); i-- > iworking_state->min_main_depth; ) {
					phinodes.push_back(LLVMBuildPhi(env.llvm_builder, env.dict.type_array[iworking_state->main_type(i)].llvm_type, ""));
					iworking_state->set_main_ex(i, phinodes.back());
				}
				for(auto i = iworking_state->return_size(); i-- > iworking_state->min_return_depth; ) {
					phinodes.push_back(LLVMBuildPhi(env.llvm_builder, env.dict.type_array[iworking_state->return_type(i)].llvm_type, ""));
					iworking_state->set_return_ex(i, phinodes.back());
				}
			}

			loop_entry_copy = iworking_state->copy();
			saw_conditional = false;
			env.mode = fif_mode::compiling_llvm;
			if(!env.source_stack.empty())	
				env.source_stack.back() = entry_source;
#endif
			return false;
		} else if(typechecking_mode(env.mode)) {
			if(!saw_conditional) {
				if(iworking_state->main_type_back(0) != fif_bool) {
					env.mode = reset_typechecking(env.mode);
					if(initial_typechecking_failed || env.mode != fif_mode::typechecking_lvl_1)
						env.mode = fail_typechecking(env.mode);

					return true;
				}
				iworking_state->pop_main();
			}
			bool final_types_match = stack_types_match(*initial_state, *iworking_state);
			if(!final_types_match) {
				env.mode = reset_typechecking(env.mode);
				if(initial_typechecking_failed || env.mode != fif_mode::typechecking_lvl_1)
					env.mode = fail_typechecking(env.mode);

				return true;
			}
			if(!typechecking_failed(env.mode)) {
				iworking_state->min_main_depth = std::min(iworking_state->min_main_depth, initial_state->min_main_depth);
				iworking_state->min_return_depth = std::min(iworking_state->min_return_depth, initial_state->min_return_depth);
				parent->set_working_state(std::move(iworking_state));
			} else if(env.mode == fif_mode::typechecking_lvl1_failed) {
				env.mode = reset_typechecking(env.mode);
			}

			return true;
		}
		return true;
	}
};

class do_loop_scope : public locals_holder {
public:
	std::unique_ptr<state_stack> initial_state;
	std::unique_ptr<state_stack> iworking_state;

	std::string_view entry_source;
	size_t loop_entry_point = 0;
	size_t end_of_loop_branch = 0;
	bool phi_pass = false;
	bool initial_typechecking_failed = false;
	
	LLVMBasicBlockRef pre_block = nullptr;
	LLVMBasicBlockRef body_block = nullptr;
	std::vector<LLVMValueRef> phinodes;

	do_loop_scope(opaque_compiler_data* p, environment& e, state_stack& entry_state) : locals_holder(p, e) {
		initial_state = entry_state.copy();
		iworking_state = entry_state.copy();
		initial_state->min_main_depth = entry_state.min_main_depth;
		initial_state->min_return_depth = entry_state.min_return_depth;
		initial_typechecking_failed = typechecking_failed(env.mode);

		if(!env.source_stack.empty()) {
			entry_source = env.source_stack.back();
		}
		if(env.mode == fif_mode::compiling_bytecode) {
			auto bcode = parent->bytecode_compilation_progress();
			loop_entry_point = bcode->size();

			{
				fif_call imm2 = enter_scope;
				uint64_t imm2_bytes = 0;
				memcpy(&imm2_bytes, &imm2, 8);
				bcode->push_back(int32_t(imm2_bytes & 0xFFFFFFFF));
				bcode->push_back(int32_t((imm2_bytes >> 32) & 0xFFFFFFFF));
			}
		}
		if(env.mode == fif_mode::compiling_llvm) {
			phi_pass = true;
			env.mode = fif_mode::typechecking_lvl_2;
			if(auto pb = env.compiler_stack.back()->llvm_block(); pb) {
				pre_block = *pb;
			}
		}
	}

	virtual control_structure get_type() override {
		return control_structure::str_do_loop;
	}
	virtual state_stack* working_state() override {
		return iworking_state.get();
	}
	virtual void set_working_state(std::unique_ptr<state_stack> p) override {
		iworking_state = std::move(p);
	}
	void at_until(environment&) {
		// don't actually need to do anything here ...
	}
	virtual bool finish(environment&)override {
		release_locals();

		if(env.mode == fif_mode::interpreting) {
			if(iworking_state->main_type_back(0) == fif_bool) {
				if(iworking_state->main_data_back(0) != 0) {
					iworking_state->pop_main();

					parent->set_working_state(std::move(iworking_state));
					return true;
				}
				iworking_state->pop_main();
			}
			if(!env.source_stack.empty())
				env.source_stack.back() = entry_source;
			return false;
		}

		if(env.mode == fif_mode::compiling_bytecode) {
			
			if(iworking_state->main_type_back(0) == fif_bool) {
				iworking_state->pop_main();
			} else {
				env.report_error("do loop not terminated with an appropriate conditional");
				env.mode = fif_mode::error;
				return true;
			}

			auto bcode = parent->bytecode_compilation_progress();
			{
				fif_call imm2 = leave_scope;
				uint64_t imm2_bytes = 0;
				memcpy(&imm2_bytes, &imm2, 8);
				bcode->push_back(int32_t(imm2_bytes & 0xFFFFFFFF));
				bcode->push_back(int32_t((imm2_bytes >> 32) & 0xFFFFFFFF));
			}

			fif_call imm = conditional_jump;
			uint64_t imm_bytes = 0;
			memcpy(&imm_bytes, &imm, 8);
			bcode->push_back(int32_t(imm_bytes & 0xFFFFFFFF));
			bcode->push_back(int32_t((imm_bytes >> 32) & 0xFFFFFFFF));
			end_of_loop_branch = bcode->size();
			bcode->push_back(int32_t(int64_t(loop_entry_point) - int64_t(bcode->size() - 2)));
			
			bool final_types_match = stack_types_match(*initial_state, *iworking_state);
			if(!final_types_match) {
				env.report_error("do loop had a net stack effect");
				env.mode = fif_mode::error;
				return true;
			}

			iworking_state->min_main_depth = std::min(iworking_state->min_main_depth, initial_state->min_main_depth);
			iworking_state->min_return_depth = std::min(iworking_state->min_return_depth, initial_state->min_return_depth);
			parent->set_working_state(std::move(iworking_state));

			return true;
		} else if(env.mode == fif_mode::compiling_llvm) {
#ifdef USE_LLVM
			auto conditional_expr = iworking_state->main_ex_back(0);
			iworking_state->pop_main();


			bool final_types_match = stack_types_match(*initial_state, *iworking_state);
			if(!final_types_match) {
				env.report_error("do loop had a net stack effect");
				env.mode = fif_mode::error;
				return true;
			}

			if(auto pb = env.compiler_stack.back()->llvm_block(); pb) {
				auto in_block = *pb;
				*pb = LLVMCreateBasicBlockInContext(env.llvm_context, "post_loop");
				LLVMAppendExistingBasicBlock(parent->llvm_function(), *pb);

				LLVMPositionBuilderAtEnd(env.llvm_builder, in_block);
				LLVMBuildCondBr(env.llvm_builder, conditional_expr, *pb, body_block);

				LLVMPositionBuilderAtEnd(env.llvm_builder, *pb);

				/*
				set phi inputs in entry block
				*/
				uint32_t node_index = 0;
				for(auto i = iworking_state->main_size(); i-- > iworking_state->min_main_depth; ) {
					if(phinodes[node_index] == iworking_state->main_ex(i)) { // phi node unchanged
						LLVMValueRef inc_vals[1] = { initial_state->main_ex(i) };
						LLVMBasicBlockRef inc_blocks[1] = { pre_block };
						LLVMAddIncoming(phinodes[node_index], inc_vals, inc_blocks, 1);
					} else {
						LLVMValueRef inc_vals[2] = { iworking_state->main_ex(i), initial_state->main_ex(i) };
						LLVMBasicBlockRef inc_blocks[2] = { in_block, pre_block };
						LLVMAddIncoming(phinodes[node_index], inc_vals, inc_blocks, 2);
					}
					++node_index;
				}
				for(auto i = iworking_state->return_size(); i-- > iworking_state->min_return_depth; ) {
					if(phinodes[node_index] == iworking_state->return_ex(i)) { // phi node unchanged
						LLVMValueRef inc_vals[1] = { initial_state->return_ex(i) };
						LLVMBasicBlockRef inc_blocks[1] = { pre_block };
						LLVMAddIncoming(phinodes[node_index], inc_vals, inc_blocks, 1);
					} else {
						LLVMValueRef inc_vals[2] = { iworking_state->return_ex(i), initial_state->return_ex(i) };
						LLVMBasicBlockRef inc_blocks[2] = { in_block, pre_block };
						LLVMAddIncoming(phinodes[node_index], inc_vals, inc_blocks, 2);
					}
					++node_index;
				}
			}

			iworking_state->min_main_depth = std::min(iworking_state->min_main_depth, initial_state->min_main_depth);
			iworking_state->min_return_depth = std::min(iworking_state->min_return_depth, initial_state->min_return_depth);
			parent->set_working_state(std::move(iworking_state));
#endif
			return true;
		} else if(env.mode == fif_mode::typechecking_lvl_2 && phi_pass == true) {
#ifdef USE_LLVM
			phi_pass = false;

			if(iworking_state->main_type_back(0) != fif_bool) {
				env.mode = fif_mode::error;
				env.report_error("do loop did not finish with a boolean value");
				return true;
			}
			iworking_state->pop_main();

			if(auto pb = env.compiler_stack.back()->llvm_block(); pb) {
				*pb = LLVMCreateBasicBlockInContext(env.llvm_context, "do_body");
				body_block = *pb;
				LLVMAppendExistingBasicBlock(parent->llvm_function(), *pb);

				LLVMBuildBr(env.llvm_builder, body_block);
				LLVMPositionBuilderAtEnd(env.llvm_builder, *pb);

				/*
				build entry phi_nodes
				*/
				for(auto i = iworking_state->main_size(); i-- > iworking_state->min_main_depth; ) {
					phinodes.push_back(LLVMBuildPhi(env.llvm_builder, env.dict.type_array[iworking_state->main_type(i)].llvm_type, ""));
					iworking_state->set_main_ex(i, phinodes.back());
				}
				for(auto i = iworking_state->return_size(); i-- > iworking_state->min_return_depth; ) {
					phinodes.push_back(LLVMBuildPhi(env.llvm_builder, env.dict.type_array[iworking_state->return_type(i)].llvm_type, ""));
					iworking_state->set_return_ex(i, phinodes.back());
				}
			}

			env.mode = fif_mode::compiling_llvm;
			if(!env.source_stack.empty())
				env.source_stack.back() = entry_source;
#endif
			return false;
		} else if(typechecking_mode(env.mode)) {
			if(iworking_state->main_type_back(0) != fif_bool) {
				env.mode = reset_typechecking(env.mode);
				if(initial_typechecking_failed || env.mode != fif_mode::typechecking_lvl_1)
					env.mode = fail_typechecking(env.mode);
				
				return true;
			}
			iworking_state->pop_main();

			bool final_types_match = stack_types_match(*initial_state, *iworking_state);
			if(!final_types_match) {
				env.mode = reset_typechecking(env.mode);
				if(initial_typechecking_failed || env.mode != fif_mode::typechecking_lvl_1)
					env.mode = fail_typechecking(env.mode);

				parent->set_working_state(std::move(initial_state));

				return true;
			}

			if(!typechecking_failed(env.mode)) {
				iworking_state->min_main_depth = std::min(iworking_state->min_main_depth, initial_state->min_main_depth);
				iworking_state->min_return_depth = std::min(iworking_state->min_return_depth, initial_state->min_return_depth);
				parent->set_working_state(std::move(iworking_state));
			} else if(!initial_typechecking_failed && env.mode == fif_mode::typechecking_lvl_1) {
				env.mode = reset_typechecking(env.mode);
			}

			return true;
		}

		return true;
	}
};

inline constexpr size_t inlining_cells_limit = 512;

inline uint32_t codepoint_from_utf8(char const* start, char const* end) {
	uint8_t byte1 = uint8_t(start + 0 < end ? start[0] : 0);
	uint8_t byte2 = uint8_t(start + 1 < end ? start[1] : 0);
	uint8_t byte3 = uint8_t(start + 2 < end ? start[2] : 0);
	uint8_t byte4 = uint8_t(start + 3 < end ? start[3] : 0);
	if((byte1 & 0x80) == 0) {
		return uint32_t(byte1);
	} else if((byte1 & 0xE0) == 0xC0) {
		return uint32_t(byte2 & 0x3F) | (uint32_t(byte1 & 0x1F) << 6);
	} else  if((byte1 & 0xF0) == 0xE0) {
		return uint32_t(byte3 & 0x3F) | (uint32_t(byte2 & 0x3F) << 6) | (uint32_t(byte1 & 0x0F) << 12);
	} else if((byte1 & 0xF8) == 0xF0) {
		return uint32_t(byte4 & 0x3F) | (uint32_t(byte3 & 0x3F) << 6) | (uint32_t(byte2 & 0x3F) << 12) | (uint32_t(byte1 & 0x07) << 18);
	}
	return 0;
}
inline size_t size_from_utf8(char const* start) {
	uint8_t b = uint8_t(start[0]);
	return ((b & 0x80) == 0) ? 1 : ((b & 0xE0) == 0xC0) ? 2
		: ((b & 0xF0) == 0xE0) ? 3 : ((b & 0xF8) == 0xF0) ? 4
		: 1;
}
inline bool codepoint_is_space(uint32_t c) noexcept {
	return (c == 0x3000 || c == 0x205F || c == 0x202F || c == 0x2029 || c == 0x2028 || c == 0x00A0
		|| c == 0x0085 || c <= 0x0020 || (0x2000 <= c && c <= 0x200A));
}
inline bool codepoint_is_line_break(uint32_t c) noexcept {
	return  c == 0x2029 || c == 0x2028 || c == uint32_t('\n') || c == uint32_t('\r');
}

struct string_start {
	int32_t eq_match = 0;
	bool starts_string = false;
};

inline string_start match_string_start(std::string_view source) {
	if(source.length() < 2)
		return string_start{ 0, false };
	if(source[0] != '<')
		return string_start{ 0, false };
	int32_t eq_count = 0;
	uint32_t pos = 1;
	while(pos < source.length()) {
		if(source[pos] == '<') {
			return string_start{ eq_count, true };
		} else if(source[pos] == '=') {
			++eq_count;
		} else {
			break;
		}
		++pos;
	}
	return string_start{ 0, false };
}
inline bool match_string_end(std::string_view source, int32_t eq_count_in) {
	if(source.length() < 2)
		return false ;
	if(source[0] != '>')
		return  false;
	int32_t eq_count = 0;
	uint32_t pos = 1;
	while(pos < source.length()) {
		if(source[pos] == '>') {
			return eq_count == eq_count_in;
		} else if(source[pos] == '=') {
			++eq_count;
		} else {
			break;
		}
		++pos;
	}
	return false;
}

// string format: <<xxxxx>> or <=<xxxxx>=> or <==<xxxxx>==> etc

inline parse_result read_token(std::string_view& source, environment& env) {
	size_t first_non_space = 0;
	while(first_non_space < source.length()) {
		auto codepoint = codepoint_from_utf8(source.data() + first_non_space, source.data() + source.length());
		if(codepoint_is_space(codepoint) || codepoint_is_line_break(codepoint)) 
			first_non_space += size_from_utf8(source.data() + first_non_space);
		 else
			break;
	}

	if(auto sm = match_string_start(source.substr(first_non_space)); sm.starts_string) {
		auto str_start = first_non_space + sm.eq_match + 2;
		auto str_pos = str_start;
		while(str_pos < source.length()) {
			if(match_string_end(source.substr(str_pos), sm.eq_match)) {
				auto result = source.substr(str_start, str_pos - str_start);
				source = source.substr(str_pos + sm.eq_match + 2);
				return parse_result{ result, true };
			}
			str_pos += size_from_utf8(source.data() + str_pos);
		}

		// invalid text, reached the end of source within a string without closing it
		env.report_error("unclosed string constant");
		env.mode = fif_mode::error;
		source = std::string_view{ };
		return parse_result{ std::string_view{ }, false };
	}

	auto word_end = first_non_space;
	while(word_end < source.length()) {
		auto codepoint = codepoint_from_utf8(source.data() + word_end, source.data() + source.length());
		if(codepoint_is_space(codepoint) || codepoint_is_line_break(codepoint))
			 break;
		else
			word_end += size_from_utf8(source.data() + word_end);
	}

	auto result = source.substr(first_non_space, word_end - first_non_space);
	source = source.substr(word_end);

	return parse_result{ result, false };

}

inline void execute_fif_word(parse_result word, environment& env, bool ignore_specialization);


inline void run_to_scope_end(environment& env) { // execute/compile source code until current function is completed
	parse_result word;
	auto scope_depth = env.compiler_stack.size();

	if(!env.compiler_stack.empty()) {
		do {
			if(!env.source_stack.empty())
				word = read_token(env.source_stack.back(), env);
			else
				word.content = std::string_view{ };

			if(word.content.length() > 0 && env.mode != fif_mode::error) {
				execute_fif_word(word, env, false);
			}
		} while(word.content.length() > 0 && !env.compiler_stack.empty() && env.mode != fif_mode::error);
	}
}

inline void run_to_function_end(environment& env) { // execute/compile source code until current function is completed
	run_to_scope_end(env);
	if(!env.compiler_stack.empty() && env.compiler_stack.back()->finish(env)) {
		env.compiler_stack.pop_back();
	}
}

inline word_match_result get_basic_type_match(int32_t word_index, state_stack& current_type_state, environment& env, std::vector<int32_t>& specialize_t_subs, bool ignore_specializations) {
	while(word_index != -1) {
		specialize_t_subs.clear();
		bool specialization_matches = [&]() { 
			if(env.dict.word_array[word_index].stack_types_count == 0)
				return true;
			return match_stack_description(std::span<int32_t const>{env.dict.all_stack_types.data() + env.dict.word_array[word_index].stack_types_start, size_t(env.dict.word_array[word_index].stack_types_count)}, current_type_state, env, specialize_t_subs).matched;
		}();
		if(specialization_matches && (ignore_specializations == false || env.dict.word_array[word_index].treat_as_base || env.dict.word_array[word_index].specialization_of == -1)) {
			word_match_result match = match_word(env.dict.word_array[word_index], current_type_state, env.dict.all_instances, env.dict.all_stack_types, env);
			int32_t w = word_index;
			match.substitution_version = word_index;

			if(!match.matched) {
				if(typechecking_failed(env.mode)) {
					// ignore match failure and pass on through
					return word_match_result{ false, 0, 0, 0, 0 };
				} else if(env.mode == fif_mode::typechecking_lvl_1 || env.mode == fif_mode::typechecking_lvl_2) {
					if(env.dict.word_array[w].being_typechecked) { // already being typechecked -- mark as un checkable recursive branch
						env.mode = fail_typechecking(env.mode);
					} else if(env.dict.word_array[w].source.length() > 0) { // try to typecheck word as level 1
						env.dict.word_array[w].being_typechecked = true;

						switch_compiler_stack_mode(env, fif_mode::typechecking_lvl_1);

						env.source_stack.push_back(std::string_view(env.dict.word_array[w].source));
						auto fnscope = std::make_unique<function_scope>(env.compiler_stack.back().get(), env, current_type_state, w, -1);
						fnscope->type_subs = specialize_t_subs;
						env.compiler_stack.emplace_back(std::move(fnscope));

						run_to_function_end(env);
						env.source_stack.pop_back();

						env.dict.word_array[w].being_typechecked = false;
						match = match_word(env.dict.word_array[w], current_type_state, env.dict.all_instances, env.dict.all_stack_types, env);
						match.substitution_version = word_index;

						restore_compiler_stack_mode(env);

						if(match.matched) {
							std::get<interpreted_word_instance>(env.dict.all_instances[match.word_index]).typechecking_level = 1;
							return match;
						} else {
							env.mode = fail_typechecking(env.mode);
							return word_match_result{ false, 0, 0, 0, 0 };
						}
					}
				} else if(env.dict.word_array[w].source.length() > 0) { // either compiling or interpreting or level 3 typecheck-- switch to typechecking to get a type definition
					switch_compiler_stack_mode(env, fif_mode::typechecking_lvl_1);
					env.dict.word_array[w].being_typechecked = true;

					env.source_stack.push_back(std::string_view(env.dict.word_array[w].source));
					auto fnscope = std::make_unique<function_scope>(env.compiler_stack.back().get(), env, current_type_state, w, -1);
					fnscope->type_subs = specialize_t_subs;
					env.compiler_stack.emplace_back(std::move(fnscope));

					run_to_function_end(env);
					env.source_stack.pop_back();

					env.dict.word_array[w].being_typechecked = false;

					restore_compiler_stack_mode(env);

					match = match_word(env.dict.word_array[w], current_type_state, env.dict.all_instances, env.dict.all_stack_types, env);
					match.substitution_version = word_index;

					if(!match.matched) {
						env.report_error("typechecking failure for " + word_name_from_id(w, env));
						env.mode = fif_mode::error;
						return word_match_result{ false, 0, 0, 0, 0 };
					}
					return match;
				}
			}

			return match;
		} else {
			word_index = env.dict.word_array[word_index].specialization_of;
		}
	}
	
	return word_match_result{ false, 0, 0, 0, 0 };
}

inline bool fully_typecheck_word(int32_t w, int32_t word_index, interpreted_word_instance& wi, state_stack& current_type_state, environment& env, std::vector<int32_t>& tsubs) {
	if(wi.typechecking_level == 1) {
		// perform level 2 typechecking

		switch_compiler_stack_mode(env, fif_mode::typechecking_lvl_2);

		env.source_stack.push_back(std::string_view(env.dict.word_array[w].source));
		auto fnscope = std::make_unique<function_scope>(env.compiler_stack.back().get(), env, current_type_state, w, word_index);
		fnscope->type_subs = tsubs;
		env.compiler_stack.emplace_back(std::move(fnscope));

		run_to_function_end(env);
		env.source_stack.pop_back();

		bool failed = typechecking_failed(env.mode);

		restore_compiler_stack_mode(env);

		if(failed) {
			env.report_error("level 2 typecheck failed");
			env.mode = fif_mode::error;
			return false;
		}

		wi.typechecking_level = 2;
	}

	if(wi.typechecking_level == 2) {
		// perform level 3 typechecking

		env.compiler_stack.emplace_back(std::make_unique< typecheck3_record_holder>(env.compiler_stack.back().get(), env));
		auto record_holder = static_cast<typecheck3_record_holder*>(env.compiler_stack.back().get());

		switch_compiler_stack_mode(env, fif_mode::typechecking_lvl_3);
		env.source_stack.push_back(std::string_view(env.dict.word_array[w].source));
		auto fnscope = std::make_unique<function_scope>(env.compiler_stack.back().get(), env, current_type_state, w, word_index);
		fnscope->type_subs = tsubs;
		env.compiler_stack.emplace_back(std::move(fnscope));

		run_to_function_end(env);
		env.source_stack.pop_back();

		bool failed = typechecking_failed(env.mode);

		restore_compiler_stack_mode(env);

		if(failed) {
			env.report_error("level 3 typecheck failed");
			env.mode = fif_mode::error;
			return false;
		}

		wi.typechecking_level = 3;

		if(auto erb = record_holder->tr.find((uint64_t(w) << 32) | uint64_t(word_index)); erb != record_holder->tr.end()) {
			typecheck_3_record r;
			r.stack_height_added_at = int32_t(current_type_state.main_size());
			r.rstack_height_added_at = int32_t(current_type_state.return_size());

			auto c = get_stack_consumption(w, word_index, env);
			r.stack_consumed = std::max(c.stack, erb->second.stack_consumed);
			r.rstack_consumed = std::max(c.rstack, erb->second.rstack_consumed);

			record_holder->tr.insert_or_assign((uint64_t(w) << 32) | uint64_t(word_index), r);
			} else {
				typecheck_3_record r;
				r.stack_height_added_at = int32_t(current_type_state.main_size());
				r.rstack_height_added_at = int32_t(current_type_state.return_size());

				auto c = get_stack_consumption(w, word_index, env);
				r.stack_consumed = c.stack;
				r.rstack_consumed = c.rstack;

				record_holder->tr.insert_or_assign((uint64_t(w) << 32) | uint64_t(word_index), r);
		}

		/*
		process results of typechecking
		*/
		auto min_stack_depth = int32_t(current_type_state.main_size());
		auto min_rstack_depth = int32_t(current_type_state.return_size());
		for(auto& s : record_holder->tr) {
			min_stack_depth = std::min(min_stack_depth, s.second.stack_height_added_at - s.second.stack_consumed);
			min_rstack_depth = std::min(min_rstack_depth, s.second.rstack_height_added_at - s.second.rstack_consumed);
		}

		auto existing_description = std::span<int32_t const>(env.dict.all_stack_types.data() + wi.stack_types_start, wi.stack_types_count);
		auto revised_description = expand_stack_description(current_type_state, existing_description, int32_t(current_type_state.main_size()) - min_stack_depth, int32_t(current_type_state.return_size()) - min_rstack_depth);

		if(!compare_stack_description(existing_description, std::span<int32_t const>(revised_description.data(), revised_description.size()))) {
			wi.stack_types_start = int32_t(env.dict.all_stack_types.size());
			wi.stack_types_count = int32_t(revised_description.size());
			env.dict.all_stack_types.insert(env.dict.all_stack_types.end(), revised_description.begin(), revised_description.end());
		}

		env.compiler_stack.pop_back(); // for typecheck3_record_holder
	}

	return true;
}

inline bool compile_word(int32_t w, int32_t word_index, state_stack& state, fif_mode compile_mode, environment& env, std::vector<int32_t>& tsubs) {
	if(!std::holds_alternative<interpreted_word_instance>(env.dict.all_instances[word_index]))
		return true;

	interpreted_word_instance& wi = std::get<interpreted_word_instance>(env.dict.all_instances[word_index]);
	if(!fully_typecheck_word(w, word_index, wi, state, env, tsubs)) {
		return false;
	}

	switch_compiler_stack_mode(env, compile_mode);

	if(env.mode != fif_mode::compiling_llvm && wi.compiled_bytecode.size() == 0) {
		// typed but uncompiled word
		if(!std::get<interpreted_word_instance>(env.dict.all_instances[word_index]).being_compiled) {
			env.source_stack.push_back(std::string_view(env.dict.word_array[w].source));
			auto fnscope = std::make_unique<function_scope>(env.compiler_stack.back().get(), env, state, w, word_index);
			fnscope->type_subs = tsubs;
			env.compiler_stack.emplace_back(std::move(fnscope));
			run_to_function_end(env);
			env.source_stack.pop_back();
		}
	}

	// case: reached an uncompiled llvm definition
	if(env.mode == fif_mode::compiling_llvm && !wi.llvm_compilation_finished) {
#ifdef USE_LLVM
		// typed but uncompiled word
		if(!std::get<interpreted_word_instance>(env.dict.all_instances[word_index]).being_compiled) {
			LLVMBasicBlockRef stored_block = nullptr;
			if(auto pb = env.compiler_stack.back()->llvm_block(); pb)
				stored_block = *pb;

			
			env.source_stack.push_back(std::string_view(env.dict.word_array[w].source));
			auto fnscope = std::make_unique<function_scope>(env.compiler_stack.back().get(), env, state, w, word_index);
			fnscope->type_subs = tsubs;
			env.compiler_stack.emplace_back(std::move(fnscope));
			run_to_function_end(env);
			env.source_stack.pop_back();

			if(auto pb = env.compiler_stack.back()->llvm_block(); pb) {
				*pb = stored_block;
				LLVMPositionBuilderAtEnd(env.llvm_builder, stored_block);
			}
			
		}
#endif
	}

	restore_compiler_stack_mode(env);
	return true;
}

inline let_data* get_global_let(environment& env, std::string const& name) {
	for(auto& p : env.compiler_stack) {
		if(p->get_type() == control_structure::globals)
			return static_cast<compiler_globals_layer*>(p.get())->get_global_let(name);
	}
	return nullptr;
}
inline var_data* get_global_var(environment& env, std::string const& name) {
	for(auto& p : env.compiler_stack) {
		if(p->get_type() == control_structure::globals)
			return static_cast<compiler_globals_layer*>(p.get())->get_global_var(name);
	}
	return nullptr;
}

inline int32_t* immediate_local(state_stack& s, int32_t* p, environment* e) {
	char* name = 0;
	memcpy(&name, p + 2, 8);

	var_data* l = e->compiler_stack.back()->get_var(std::string(name));
	if(!l) {
		e->report_error("unable to find local var");
		return nullptr;
	}
	int32_t type = 0;
	memcpy(&type, p + 4, 4);
	s.push_back_main(type, (int64_t)l, nullptr);
	return p + 5;
}

inline int32_t* immediate_let(state_stack& s, int32_t* p, environment* e) {
	char* name = 0;
	memcpy(&name, p + 2, 8);
	let_data* l = e->compiler_stack.back()->get_let(std::string(name));
	if(!l) {
		e->report_error("unable to find local let");
		return nullptr;
	}
	int32_t type = 0;
	memcpy(&type, p + 4, 4);
	s.push_back_main(type, l->data, nullptr);
	return p + 5;
}

inline int32_t* immediate_global(state_stack& s, int32_t* p, environment* e) {
	char* name = 0;
	memcpy(&name, p + 2, 8);
	var_data* v = get_global_var(*e, std::string(name));
	if(!v) {
		e->report_error("unable to find local let");
		return nullptr;
	}
	int32_t type = 0;
	memcpy(&type, p + 4, 4);
	s.push_back_main(type, (int64_t)v, nullptr);
	return p + 5;
}

inline void execute_fif_word(parse_result word, environment& env, bool ignore_specializations) {
	auto ws = env.compiler_stack.back()->working_state();
	if(!ws) {
		env.report_error("tried to execute in a scope with no working state");
		env.mode = fif_mode::error;
		return;
	}

	// TODO: string constant case
	// TODO: restore constructor word
	//if(word.content.length() > 0 && word.content[0] == '@') {
	//	do_construct_type(*ws, resolve_type(word.content.substr(1), env), &env);
	//} else 
	auto content_string = std::string{ word.content };
	if(is_integer(word.content.data(), word.content.data() + word.content.length())) {
		do_immediate_i32(*ws, parse_int(word.content), &env);
	} else if(is_fp(word.content.data(), word.content.data() + word.content.length())) {
		do_immediate_f32(*ws, parse_float(word.content), &env);
	} else if(word.content == "true" || word.content == "false") {
		do_immediate_bool(*ws, word.content == "true", &env);
	} else if(auto it = env.dict.words.find(std::string(word.content)); it != env.dict.words.end()) {
		auto w = it->second;
		// execute / compile word

		// IMMEDIATE words with source
		if(env.dict.word_array[w].immediate) {
			if(env.dict.word_array[w].source.length() > 0) {
				env.source_stack.push_back(std::string_view{ env.dict.word_array[w].source });
				switch_compiler_stack_mode(env, fif_mode::interpreting);

				run_to_scope_end(env);

				restore_compiler_stack_mode(env);
				env.source_stack.pop_back(); // remove source replacement

				return;
			}
		}

		std::vector<int32_t> called_tsub_types;
		auto match = get_basic_type_match(w, *ws, env, called_tsub_types, ignore_specializations);
		w = match.substitution_version;

		if(!match.matched) {
			if(typechecking_failed(env.mode)) {
				return;
			} else { // critical failure
				env.report_error("could not match word to stack types");
				env.mode = fif_mode::error;
				return;
			}
		}

		word_types* wi = &(env.dict.all_instances[match.word_index]);

		// IMMEDIATE words (source not available)
		if(env.dict.word_array[w].immediate) {
			if(std::holds_alternative<interpreted_word_instance>(*wi)) {
				switch_compiler_stack_mode(env, fif_mode::interpreting);
				execute_fif_word(std::get<interpreted_word_instance>(*wi), *ws, env);
				restore_compiler_stack_mode(env);
			} else if(std::holds_alternative<compiled_word_instance>(*wi)) {
				execute_fif_word(std::get<compiled_word_instance>(*wi), *ws, env);
			}
			return;
		}

		//
		// level 1 typechecking -- should be able to trace at least one path through each word using only known words
		//
		// level 2 typechecking -- should be able to trace through every branch to produce an accurate stack picture for all known words present in the definition
		//

		if(env.mode == fif_mode::typechecking_lvl_1 || env.mode == fif_mode::typechecking_lvl1_failed
			|| env.mode == fif_mode::typechecking_lvl_2 || env.mode == fif_mode::typechecking_lvl2_failed) {

			if(std::holds_alternative<interpreted_word_instance>(*wi)) {
				if(!typechecking_failed(env.mode)) {
					apply_stack_description(std::span<int32_t const>(env.dict.all_stack_types.data() + std::get<interpreted_word_instance>(*wi).stack_types_start, size_t(std::get<interpreted_word_instance>(*wi).stack_types_count)), *ws, env);
				}
			} else if(std::holds_alternative<compiled_word_instance>(*wi)) {
				// no special logic, compiled words assumed to always typecheck
				if(!typechecking_failed(env.mode)) {
					apply_stack_description(std::span<int32_t const>(env.dict.all_stack_types.data() + std::get<compiled_word_instance>(*wi).stack_types_start, size_t(std::get<compiled_word_instance>(*wi).stack_types_count)), *ws, env);
				}
			}
			return;
		}

		//
		// level 3 typechecking -- recursively determine the minimum stack position of all dependencies
		//

		if(env.mode == fif_mode::typechecking_lvl_3 || env.mode == fif_mode::typechecking_lvl3_failed) {
			if(std::holds_alternative<interpreted_word_instance>(*wi)) {
				if(!typechecking_failed(env.mode)) {
					// add typecheck info
					if(std::get<interpreted_word_instance>(*wi).typechecking_level < 3) {
						// this word also hasn't been compiled yet

						auto rword = env.compiler_stack.back()->word_id();
						auto rinst = env.compiler_stack.back()->instance_id();
						auto& dep = *(env.compiler_stack.back()->typecheck_record());
						auto existing_record = dep.find((uint64_t(w) << 32) | uint64_t(match.word_index));
						if(existing_record != dep.end()
							&& existing_record->second.stack_height_added_at <= int32_t(ws->main_size())
							&& existing_record->second.rstack_height_added_at <= int32_t(ws->return_size())) {

							// already added all dependencies of this word at this stack height or less
						} else { // word is occurring deeper in the stack or not yet seen
							// recurse and typecheck through it
							// first, make sure that it is typechecked to at least level 2

							if(env.dict.word_array[w].source.length() == 0) {
								env.report_error(std::string("Word ") + std::to_string(w) + " is undefined.");
								env.mode = fif_mode::error;
								return;
							}

							if(std::get<interpreted_word_instance>(*wi).typechecking_level < 2) {
								switch_compiler_stack_mode(env, fif_mode::typechecking_lvl_2);

								env.source_stack.push_back(std::string_view(env.dict.word_array[w].source));
								auto fnscope = std::make_unique<function_scope>(env.compiler_stack.back().get(), env, *ws, w, match.word_index);
								fnscope->type_subs = called_tsub_types;
								env.compiler_stack.emplace_back(std::move(fnscope));

								run_to_function_end(env);
								env.source_stack.pop_back();

								bool failed = typechecking_failed(env.mode);
								restore_compiler_stack_mode(env);

								if(failed) {
									env.report_error("level 2 typecheck failed");
									env.mode = fif_mode::error;
									return;
								}

								wi = &(env.dict.all_instances[match.word_index]);
								std::get<interpreted_word_instance>(*wi).typechecking_level = 2;
							}

							env.mode = fif_mode::typechecking_lvl_3;
							if(auto erb = dep.find((uint64_t(w) << 32) | uint64_t(match.word_index)); erb != dep.end()) {
								typecheck_3_record r;
								r.stack_height_added_at = int32_t(ws->main_size());
								r.rstack_height_added_at = int32_t(ws->return_size());

								auto c = get_stack_consumption(w, match.word_index, env);
								r.stack_consumed = std::max(c.stack, erb->second.stack_consumed);
								r.rstack_consumed = std::max(c.rstack, erb->second.rstack_consumed);

								dep.insert_or_assign((uint64_t(w) << 32) | uint64_t(match.word_index), r);
							} else {
								typecheck_3_record r;
								r.stack_height_added_at = int32_t(ws->main_size());
								r.rstack_height_added_at = int32_t(ws->return_size());

								auto c = get_stack_consumption(w, match.word_index, env);
								r.stack_consumed = c.stack;
								r.rstack_consumed = c.rstack;

								dep.insert_or_assign((uint64_t(w) << 32) | uint64_t(match.word_index), r);
							}
						}
					}

					apply_stack_description(std::span<int32_t const>(env.dict.all_stack_types.data() + std::get<interpreted_word_instance>(*wi).stack_types_start, size_t(std::get<interpreted_word_instance>(*wi).stack_types_count)), *ws, env);
				}
			} else if(std::holds_alternative<compiled_word_instance>(*wi)) {
				if(!typechecking_failed(env.mode)) {
					// no special logic, compiled words assumed to always typecheck
					apply_stack_description(std::span<int32_t const>(env.dict.all_stack_types.data() + std::get<compiled_word_instance>(*wi).stack_types_start, size_t(std::get<compiled_word_instance>(*wi).stack_types_count)), *ws, env);
				}
			}

			return;
		}

		if(env.mode == fif_mode::interpreting || env.mode == fif_mode::compiling_llvm || env.mode == fif_mode::compiling_bytecode) {
			if(!compile_word(w, match.word_index, *ws, env.mode != fif_mode::compiling_llvm ? fif_mode::compiling_bytecode : fif_mode::compiling_llvm, env, called_tsub_types)) {
				env.report_error("failed to compile word");
				env.mode = fif_mode::error;
				return;
			}
			wi = &(env.dict.all_instances[match.word_index]);

			if(std::holds_alternative<interpreted_word_instance>(*wi)) {
				if(env.mode == fif_mode::interpreting) {
					env.compiler_stack.push_back(std::make_unique<runtime_function_scope>(env.compiler_stack.back().get(), env));
					execute_fif_word(std::get<interpreted_word_instance>(*wi), *ws, env);
					env.compiler_stack.back()->finish(env);
					env.compiler_stack.pop_back();
				} else if(env.mode == fif_mode::compiling_llvm) {
#ifdef USE_LLVM
					std::span<int32_t const> desc{ env.dict.all_stack_types.data() + std::get<interpreted_word_instance>(*wi).stack_types_start, size_t(std::get<interpreted_word_instance>(*wi).stack_types_count) };
					llvm_make_function_call(env, std::get<interpreted_word_instance>(*wi).llvm_function, desc);
#endif
				} else if(env.mode == fif_mode::compiling_bytecode) {
					auto cbytes = env.compiler_stack.back()->bytecode_compilation_progress();
					if(cbytes) {
						if(std::get<interpreted_word_instance>(*wi).being_compiled) {
							fif_call imm = call_function_indirect;
							uint64_t imm_bytes = 0;
							memcpy(&imm_bytes, &imm, 8);
							cbytes->push_back(int32_t(imm_bytes & 0xFFFFFFFF));
							cbytes->push_back(int32_t((imm_bytes >> 32) & 0xFFFFFFFF));
							cbytes->push_back(match.word_index);
						} else {
							{
								fif_call imm = call_function;
								uint64_t imm_bytes = 0;
								memcpy(&imm_bytes, &imm, 8);
								cbytes->push_back(int32_t(imm_bytes & 0xFFFFFFFF));
								cbytes->push_back(int32_t((imm_bytes >> 32) & 0xFFFFFFFF));
							}
							{
								int32_t* bcode = std::get<interpreted_word_instance>(*wi).compiled_bytecode.data();
								uint64_t imm_bytes = 0;
								memcpy(&imm_bytes, &bcode, 8);
								cbytes->push_back(int32_t(imm_bytes & 0xFFFFFFFF));
								cbytes->push_back(int32_t((imm_bytes >> 32) & 0xFFFFFFFF));
							}
						}
						apply_stack_description(std::span<int32_t const>(env.dict.all_stack_types.data() + std::get<interpreted_word_instance>(*wi).stack_types_start, size_t(std::get<interpreted_word_instance>(*wi).stack_types_count)), *ws, env);
					}
				}
			} else if(std::holds_alternative<compiled_word_instance>(*wi)) {
				if(env.mode == fif_mode::compiling_bytecode) {
					auto cbytes = env.compiler_stack.back()->bytecode_compilation_progress();
					if(cbytes) {
						fif_call imm = std::get<compiled_word_instance>(*wi).implementation;
						uint64_t imm_bytes = 0;
						memcpy(&imm_bytes, &imm, 8);
						cbytes->push_back(int32_t(imm_bytes & 0xFFFFFFFF));
						cbytes->push_back(int32_t((imm_bytes >> 32) & 0xFFFFFFFF));

						apply_stack_description(std::span<int32_t const>(env.dict.all_stack_types.data() + std::get<compiled_word_instance>(*wi).stack_types_start, size_t(std::get<compiled_word_instance>(*wi).stack_types_count)), *ws, env);
					}
				} else {
					std::get<compiled_word_instance>(*wi).implementation(*ws, nullptr, &env);
				}
			}
		}
	} else if(auto let = env.compiler_stack.back()->get_let(content_string); word.is_string == false && let) {
		if(typechecking_mode(env.mode)) {
			ws->push_back_main(let->type, let->data, let->expression);
		} else if(env.mode == fif_mode::compiling_llvm) {
			ws->push_back_main(let->type, let->data, let->expression);
		} else if(env.mode == fif_mode::interpreting) {
			ws->push_back_main(let->type, let->data, let->expression);
		} else if(env.mode == fif_mode::compiling_bytecode) {
			// implement let
			auto cbytes = env.compiler_stack.back()->bytecode_compilation_progress();
			if(cbytes) {
				fif_call imm = immediate_let;
				uint64_t imm_bytes = 0;
				memcpy(&imm_bytes, &imm, 8);
				cbytes->push_back(int32_t(imm_bytes & 0xFFFFFFFF));
				cbytes->push_back(int32_t((imm_bytes >> 32) & 0xFFFFFFFF));

				auto string_constant = env.get_string_constant(word.content);
				char const* cptr = string_constant.data();

				uint64_t let_addr = 0;
				memcpy(&let_addr, &cptr, 8);
				cbytes->push_back(int32_t(let_addr & 0xFFFFFFFF));
				cbytes->push_back(int32_t((let_addr >> 32) & 0xFFFFFFFF));

				cbytes->push_back(let->type);
			}
			ws->push_back_main(let->type, 0, 0);
		}
	} else if(auto var = env.compiler_stack.back()->get_var(content_string); word.is_string == false && var) {
		int32_t ptr_type[] = { fif_ptr, std::numeric_limits<int32_t>::max(), var->type, -1 };
		std::vector<int32_t> subs;
		auto mem_type = resolve_span_type(std::span<int32_t const>(ptr_type, ptr_type + 4), subs, env);

		if(typechecking_mode(env.mode)) {
			ws->push_back_main(mem_type.type, 0, 0);
		} else if(env.mode == fif_mode::compiling_llvm) {
			ws->push_back_main(mem_type.type, 0, var->alloc);
		} else if(env.mode == fif_mode::interpreting) {
			ws->push_back_main(mem_type.type, (int64_t)(var), 0);
		} else if(env.mode == fif_mode::compiling_bytecode) {
			// implement let
			auto cbytes = env.compiler_stack.back()->bytecode_compilation_progress();
			if(cbytes) {
				fif_call imm = immediate_local;
				uint64_t imm_bytes = 0;
				memcpy(&imm_bytes, &imm, 8);
				cbytes->push_back(int32_t(imm_bytes & 0xFFFFFFFF));
				cbytes->push_back(int32_t((imm_bytes >> 32) & 0xFFFFFFFF));

				auto string_constant = env.get_string_constant(word.content);
				char const* cptr = string_constant.data();
				uint64_t let_addr = 0;
				memcpy(&let_addr, &cptr, 8);
				cbytes->push_back(int32_t(let_addr & 0xFFFFFFFF));
				cbytes->push_back(int32_t((let_addr >> 32) & 0xFFFFFFFF));

				cbytes->push_back(mem_type.type);
			}
			ws->push_back_main(mem_type.type, 0, 0);
		}
	} else if(auto letb = get_global_let(env, content_string); word.is_string == false && letb) {

	} else if(auto varb = get_global_var(env, content_string); word.is_string == false && varb) {
		int32_t ptr_type[] = { fif_ptr, std::numeric_limits<int32_t>::max(), varb->type, -1 };
		std::vector<int32_t> subs;
		auto mem_type = resolve_span_type(std::span<int32_t const>(ptr_type, ptr_type + 4), subs, env);

		if(typechecking_mode(env.mode)) {
			ws->push_back_main(mem_type.type, 0, 0);
		} else if(env.mode == fif_mode::compiling_llvm) {
			ws->push_back_main(mem_type.type, 0, varb->alloc);
		} else if(env.mode == fif_mode::interpreting) {
			ws->push_back_main(mem_type.type, (int64_t)(varb), 0);
		} else if(env.mode == fif_mode::compiling_bytecode) {
			// implement let
			auto cbytes = env.compiler_stack.back()->bytecode_compilation_progress();
			if(cbytes) {
				fif_call imm = immediate_global;
				uint64_t imm_bytes = 0;
				memcpy(&imm_bytes, &imm, 8);
				cbytes->push_back(int32_t(imm_bytes & 0xFFFFFFFF));
				cbytes->push_back(int32_t((imm_bytes >> 32) & 0xFFFFFFFF));

				auto string_constant = env.get_string_constant(word.content);
				char const* cptr = string_constant.data();
				uint64_t let_addr = 0;
				memcpy(&let_addr, &cptr, 8);
				cbytes->push_back(int32_t(let_addr & 0xFFFFFFFF));
				cbytes->push_back(int32_t((let_addr >> 32) & 0xFFFFFFFF));

				cbytes->push_back(mem_type.type);
			}
			ws->push_back_main(mem_type.type, 0, 0);
		}
	} else if(auto rtype = resolve_type(word.content, env, env.compiler_stack.back()->type_substitutions()); rtype != -1) {
		do_immediate_type(*ws, rtype, &env);
	} else {
		env.report_error(std::string("attempted to execute an unknown word: ") + std::string(word.content));
		env.mode = fif_mode::error;
	}
}

#ifdef USE_LLVM
inline void add_exportable_functions_to_globals(environment& env) {
	if(!env.exported_functions.empty()) {
		auto array_type = LLVMArrayType(LLVMPointerTypeInContext(env.llvm_context, 0), 1);
		auto used_array = LLVMAddGlobal(env.llvm_module, array_type, "llvm.used");
		LLVMSetLinkage(used_array, LLVMLinkage::LLVMAppendingLinkage);
		LLVMSetInitializer(used_array, LLVMConstArray(LLVMPointerTypeInContext(env.llvm_context, 0), env.exported_functions.data(), uint32_t(env.exported_functions.size())));
		LLVMSetSection(used_array, "llvm.metadata");
	}
}

inline LLVMValueRef make_exportable_function(std::string const& export_name, std::string const& word, std::vector<int32_t> param_stack, std::vector<int32_t> return_stack, environment& env) {

	env.compiler_stack.emplace_back(std::make_unique<outer_interpreter>(env));
	env.source_stack.push_back(std::string_view{ });
	outer_interpreter* o = static_cast<outer_interpreter*>(env.compiler_stack.back().get());
	switch_compiler_stack_mode(env, fif_mode::interpreting);
	static_cast<mode_switch_scope*>(env.compiler_stack.back().get())->interpreted_link = o;

	int32_t w = -1;
	if(auto it = env.dict.words.find(word); it != env.dict.words.end()) {
		w = it->second;
	} else {
		env.report_error("failed to export function (dictionary lookup failed)");
		return nullptr;
	}

	llvm_stack ts;
	ts.resize(param_stack.size(), return_stack.size());
	for(auto i = param_stack.size(); i-- > 0; ) {
		ts.set_main_type(i, param_stack[i]);
	}
	for(auto i = return_stack.size(); i-- > 0; ) {
		ts.set_return_type(i, return_stack[i]);
	}
	ts.min_main_depth = param_stack.size();
	ts.min_return_depth = param_stack.size();

	std::vector<int32_t> typevars;
	auto match = get_basic_type_match(w, ts, env, typevars, false);
	w = match.substitution_version;
	if(!match.matched) {
		env.report_error("failed to export function (typematch failed)");
		return nullptr;
	}

	if(!compile_word(w, match.word_index, ts, fif_mode::compiling_llvm, env, typevars)) {
		env.report_error("failed to export function (compilation failed)");
		return nullptr;
	}

	if(!std::holds_alternative<interpreted_word_instance>(env.dict.all_instances[match.word_index])) {
		env.report_error("failed to export function (can't export built-in)");
		return nullptr;
	}

	auto& wi = std::get<interpreted_word_instance>(env.dict.all_instances[match.word_index]);

	auto desc = std::span<int32_t const>(env.dict.all_stack_types.data() + wi.stack_types_start, wi.stack_types_count);
	auto fn_type = llvm_function_type_from_desc(env, desc);
	auto compiled_fn = LLVMAddFunction(env.llvm_module, export_name.c_str(), fn_type);

	LLVMSetFunctionCallConv(compiled_fn, NATIVE_CC);
	//LLVMSetLinkage(compiled_fn, LLVMLinkage::LLVMLinkOnceAnyLinkage);
	//LLVMSetVisibility(compiled_fn, LLVMVisibility::LLVMDefaultVisibility);

	auto entry_block = LLVMAppendBasicBlockInContext(env.llvm_context, compiled_fn, "fn_entry_point");
	LLVMPositionBuilderAtEnd(env.llvm_builder, entry_block);


	// add body
	std::vector<LLVMValueRef> params;

	int32_t match_position = 0;
	// stack matching

	int32_t consumed_stack_cells = 0;
	while(match_position < int32_t(desc.size()) && desc[match_position] != -1) {
		params.push_back(LLVMGetParam(compiled_fn, uint32_t(consumed_stack_cells)));
		++match_position;
		++consumed_stack_cells;
	}

	++match_position; // skip -1

	// output stack
	int32_t first_output_stack = match_position;
	//int32_t output_stack_types = 0;
	while(match_position < int32_t(desc.size()) && desc[match_position] != -1) {
		//returns_group.push_back(env.dict.type_array[desc[match_position]].llvm_type.llvm_type);
		++match_position;
		//++output_stack_types;
	}
	++match_position; // skip -1

	// return stack matching
	int32_t consumed_rstack_cells = 0;
	while(match_position < int32_t(desc.size()) && desc[match_position] != -1) {
		params.push_back(LLVMGetParam(compiled_fn, uint32_t(consumed_stack_cells + consumed_rstack_cells)));
		++match_position;
		++consumed_rstack_cells;
	}

	auto retvalue = LLVMBuildCall2(env.llvm_builder, llvm_function_type_from_desc(env, desc), wi.llvm_function, params.data(), uint32_t(params.size()), "");
	LLVMSetInstructionCallConv(retvalue, LLVMCallConv::LLVMFastCallConv);
	auto rsummary = llvm_function_return_type_from_desc(env, desc);

	// make return
	if(rsummary.composite_type == nullptr) {
		LLVMBuildRetVoid(env.llvm_builder);
	} else {
		LLVMBuildRet(env.llvm_builder, retvalue);
	}
	if(LLVMVerifyFunction(compiled_fn, LLVMVerifierFailureAction::LLVMPrintMessageAction))
		std::abort();

	env.exported_functions.push_back(compiled_fn);

	restore_compiler_stack_mode(env);
	env.compiler_stack.pop_back();
	env.source_stack.pop_back();

	return compiled_fn;
}
#endif

inline void run_fif_interpreter(environment& env, std::string_view on_text) {
	env.source_stack.push_back(std::string_view(on_text));
	env.compiler_stack.emplace_back(std::make_unique<outer_interpreter>(env));
	outer_interpreter* o = static_cast<outer_interpreter*>(env.compiler_stack.back().get());

	switch_compiler_stack_mode(env, fif_mode::interpreting);
	mode_switch_scope* m = static_cast<mode_switch_scope*>(env.compiler_stack.back().get());
	m->interpreted_link = o;

	run_to_scope_end(env);
	env.source_stack.pop_back();
	restore_compiler_stack_mode(env);
	env.compiler_stack.pop_back();
}

inline void run_fif_interpreter(environment& env, std::string_view on_text, interpreter_stack& s) {
	env.source_stack.push_back(std::string_view(on_text));
	env.compiler_stack.emplace_back(std::make_unique<outer_interpreter>(env));
	outer_interpreter* o = static_cast<outer_interpreter*>(env.compiler_stack.back().get());
	static_cast<interpreter_stack*>(o->interpreter_state.get())->move_into(std::move(s));
	
	switch_compiler_stack_mode(env, fif_mode::interpreting);
	mode_switch_scope* m = static_cast<mode_switch_scope*>(env.compiler_stack.back().get());
	m->interpreted_link = o;

	run_to_scope_end(env);
	env.source_stack.pop_back();
	restore_compiler_stack_mode(env);

	s.move_into(std::move(*(o->interpreter_state)));
	env.compiler_stack.pop_back();
}

#ifdef USE_LLVM
inline LLVMErrorRef module_transform(void* Ctx, LLVMModuleRef Mod) {
	LLVMPassBuilderOptionsRef pass_opts = LLVMCreatePassBuilderOptions();
	LLVMPassBuilderOptionsSetLoopInterleaving(pass_opts, true);
	LLVMPassBuilderOptionsSetLoopVectorization(pass_opts, true);
	LLVMPassBuilderOptionsSetSLPVectorization(pass_opts, true);
	LLVMPassBuilderOptionsSetLoopUnrolling(pass_opts, true);
	LLVMPassBuilderOptionsSetForgetAllSCEVInLoopUnroll(pass_opts, false);
	LLVMPassBuilderOptionsSetMergeFunctions(pass_opts, true);
	LLVMErrorRef E = LLVMRunPasses(Mod, "default<O3>", nullptr, pass_opts);
	//LLVMErrorRef E = LLVMRunPasses(Mod, "instcombine", nullptr, pass_opts);
	LLVMDisposePassBuilderOptions(pass_opts);
	if(E) {
		auto msg = LLVMGetErrorMessage(E);
		//std::cout << msg << std::endl;
		LLVMDisposeErrorMessage(msg);
		std::abort();
	}
	return E;
}

inline LLVMErrorRef perform_transform(void* Ctx, LLVMOrcThreadSafeModuleRef* the_module, LLVMOrcMaterializationResponsibilityRef MR) {
	return LLVMOrcThreadSafeModuleWithModuleDo(*the_module, module_transform, Ctx);
}
#endif
inline void add_import(std::string_view name, void* ptr, fif_call interpreter_implementation, std::vector<int32_t> const& params, std::vector<int32_t> const& returns, environment& env) {
	env.imported_functions.push_back(import_item{ std::string(name), ptr });

	std::vector<int32_t> itype_list;
	for(auto j = params.size(); j-->0;) {
		itype_list.push_back(params[j]);
	}
	auto pcount = itype_list.size();
	if(!returns.empty()) {
		itype_list.push_back(-1);
		for(auto r : returns) {
			itype_list.push_back(r);
		}
	}

	int32_t start_types = int32_t(env.dict.all_stack_types.size());
	env.dict.all_stack_types.insert(env.dict.all_stack_types.end(), itype_list.begin(), itype_list.end());
	int32_t count_types = int32_t(itype_list.size());

	auto nstr = std::string(name);
	int32_t old_word = -1;
	if(auto it = env.dict.words.find(nstr); it != env.dict.words.end()) {
		old_word = it->second;
	}

	env.dict.words.insert_or_assign(nstr, int32_t(env.dict.word_array.size()));
	env.dict.word_array.emplace_back();
	env.dict.word_array.back().specialization_of = old_word;
	env.dict.word_array.back().stack_types_start = start_types;
	env.dict.word_array.back().stack_types_count = int32_t(pcount);

	auto instance_num = int32_t(env.dict.all_instances.size());
	env.dict.word_array.back().instances.push_back(instance_num);

	interpreted_word_instance wi;
	{
		fif_call imm = interpreter_implementation;
		uint64_t imm_bytes = 0;
		memcpy(&imm_bytes, &imm, 8);
		wi.compiled_bytecode.push_back(int32_t(imm_bytes & 0xFFFFFFFF));
		wi.compiled_bytecode.push_back(int32_t((imm_bytes >> 32) & 0xFFFFFFFF));
	}
	{
		fif_call imm = function_return;
		uint64_t imm_bytes = 0;
		memcpy(&imm_bytes, &imm, 8);
		wi.compiled_bytecode.push_back(int32_t(imm_bytes & 0xFFFFFFFF));
		wi.compiled_bytecode.push_back(int32_t((imm_bytes >> 32) & 0xFFFFFFFF));
	}
	wi.llvm_compilation_finished = true;
	wi.stack_types_start = start_types;
	wi.stack_types_count = count_types;
	wi.typechecking_level = 3;
	wi.is_imported_function = true;

#ifdef USE_LLVM
	auto fn_desc = std::span<int32_t const>(itype_list.begin(), itype_list.end());
	auto fn_type = llvm_function_type_from_desc(env, fn_desc);
	wi.llvm_function = LLVMAddFunction(env.llvm_module, nstr.c_str(), fn_type);
	LLVMSetFunctionCallConv(wi.llvm_function, NATIVE_CC);
	LLVMSetLinkage(wi.llvm_function, LLVMLinkage::LLVMExternalLinkage);
#endif

	env.dict.all_instances.emplace_back(std::move(wi));
}

#ifdef USE_LLVM
inline void perform_jit(environment& e) {
	//add_exportable_functions_to_globals(e);

	char* out_message = nullptr;
	auto result = LLVMVerifyModule(e.llvm_module, LLVMVerifierFailureAction::LLVMPrintMessageAction, &out_message);
	if(result) {
		e.report_error(out_message);
		return;
	}
	if(out_message)
		LLVMDisposeMessage(out_message);
	
	LLVMDisposeBuilder(e.llvm_builder);
	e.llvm_builder = nullptr;

	// ORC JIT
	auto jit_builder = LLVMOrcCreateLLJITBuilder();
	assert(jit_builder);

	auto target_machine = LLVMOrcJITTargetMachineBuilderCreateFromTargetMachine(e.llvm_target_machine);
	e.llvm_target_machine = nullptr;
	LLVMOrcLLJITBuilderSetJITTargetMachineBuilder(jit_builder, target_machine);

	auto errora = LLVMOrcCreateLLJIT(&e.llvm_jit, jit_builder);
	if(errora) {
		auto msg = LLVMGetErrorMessage(errora);
		e.report_error(msg);
		LLVMDisposeErrorMessage(msg);
		return;
	}

	if(!e.llvm_jit) {
		e.report_error("failed to create jit");
		return;
	}


	LLVMOrcIRTransformLayerRef TL = LLVMOrcLLJITGetIRTransformLayer(e.llvm_jit);
	LLVMOrcIRTransformLayerSetTransform(TL, *perform_transform, nullptr);

	LLVMOrcThreadSafeModuleRef orc_mod = LLVMOrcCreateNewThreadSafeModule(e.llvm_module, e.llvm_ts_context);
	e.llvm_module = nullptr;

	LLVMOrcExecutionSessionRef execution_session = LLVMOrcLLJITGetExecutionSession(e.llvm_jit);
	LLVMOrcJITDylibRef main_dyn_lib = LLVMOrcLLJITGetMainJITDylib(e.llvm_jit);
	if(!main_dyn_lib) {
		e.report_error("failed to get main dylib");
		std::abort();
	}

	// add imports
	std::vector< LLVMOrcCSymbolMapPair> import_symbols;
	for(auto& i : e.imported_functions) {
		auto name = LLVMOrcLLJITMangleAndIntern(e.llvm_jit, i.name.c_str());
		LLVMJITEvaluatedSymbol sym;
		sym.Address = (LLVMOrcExecutorAddress)i.ptr;
		sym.Flags.GenericFlags = LLVMJITSymbolGenericFlags::LLVMJITSymbolGenericFlagsCallable;
		sym.Flags.TargetFlags = 0;
		import_symbols.push_back(LLVMOrcCSymbolMapPair{ name, sym });
	}

	if(import_symbols.size() > 0) {
		auto import_mr = LLVMOrcAbsoluteSymbols(import_symbols.data(), import_symbols.size());
		auto import_result = LLVMOrcJITDylibDefine(main_dyn_lib, import_mr);
		if(import_result) {
			auto msg = LLVMGetErrorMessage(import_result);
			e.report_error(msg);
			LLVMDisposeErrorMessage(msg);
			return;
		}
	}

	auto error = LLVMOrcLLJITAddLLVMIRModule(e.llvm_jit, main_dyn_lib, orc_mod);
	if(error) {
		auto msg = LLVMGetErrorMessage(error);
		e.report_error(msg);
		LLVMDisposeErrorMessage(msg);
		return;
	}
}
#endif

inline int32_t* colon_definition(fif::state_stack&, int32_t* p, fif::environment* e) {
	if(fif::typechecking_mode(e->mode))
		return p + 2;
	if(e->mode != fif::fif_mode::interpreting) {
		e->report_error("attempted to compile a definition inside a definition");
		e->mode = fif::fif_mode::error;
		return p + 2;
	}
	
	if(e->source_stack.empty()) {
		e->report_error("attempted to compile a definition without a source");
		e->mode = fif::fif_mode::error;
		return p + 2;
	}

	auto name_token = fif::read_token(e->source_stack.back(), *e);

	auto string_start = e->source_stack.back().data();
	while(e->source_stack.back().length() > 0) {
		auto t = fif::read_token(e->source_stack.back(), *e);
		if(t.is_string == false && t.content == ";") { // end of definition
			auto string_end = t.content.data();

			auto nstr = std::string(name_token.content);
			if(e->dict.words.find(nstr) != e->dict.words.end()) {
				e->report_error("illegal word redefinition");
				e->mode = fif_mode::error;
				return p + 2;
			}

			e->dict.words.insert_or_assign(nstr, int32_t(e->dict.word_array.size()));
			e->dict.word_array.emplace_back();
			e->dict.word_array.back().source = std::string(string_start, string_end);
			
			return p + 2;
		}
	}

	e->report_error("reached the end of a definition source without a ; terminator");
	e->mode = fif::fif_mode::error;
	return p + 2;
}

inline int32_t* colon_specialization(fif::state_stack&, int32_t* p, fif::environment* e) {
	if(fif::typechecking_mode(e->mode))
		return p + 2;
	if(e->mode != fif::fif_mode::interpreting) {
		e->report_error("attempted to compile a definition inside a definition");
		e->mode = fif::fif_mode::error;
		return p + 2;
	}

	if(e->source_stack.empty()) {
		e->report_error("attempted to compile a definition without a source");
		e->mode = fif::fif_mode::error;
		return p + 2;
	}

	auto name_token = fif::read_token(e->source_stack.back(), *e);

	std::vector<std::string_view> stack_types;
	while(true) {
		auto next_token = fif::read_token(e->source_stack.back(), *e);
		if(next_token.content.length() == 0 || next_token.content == "s:") {
			break;
		}
		stack_types.push_back(next_token.content);
	}
	
	std::vector<int32_t> acc_types;
	while(!stack_types.empty()) {
		auto result = internal_generate_type(stack_types.back(), *e);
		if(result.type_array.empty()) {
			e->mode = fif_mode::error;
			e->report_error("unable to resolve type from text");
			return nullptr;
		}
		acc_types.insert(acc_types.end(), result.type_array.begin(), result.type_array.end());
		stack_types.pop_back();
	}
	int32_t start_types = int32_t(e->dict.all_stack_types.size());
	e->dict.all_stack_types.insert(e->dict.all_stack_types.end(), acc_types.begin(), acc_types.end());
	int32_t count_types = int32_t(acc_types.size());

	auto string_start = e->source_stack.back().data();
	while(e->source_stack.back().length() > 0) {
		auto t = fif::read_token(e->source_stack.back(), *e);
		if(t.is_string == false && t.content == ";") { // end of definition
			auto string_end = t.content.data();

			auto nstr = std::string(name_token.content);
			int32_t old_word = -1;
			if(auto it = e->dict.words.find(nstr); it != e->dict.words.end()) {
				old_word = it->second;
			}

			e->dict.words.insert_or_assign(nstr, int32_t(e->dict.word_array.size()));
			e->dict.word_array.emplace_back();
			e->dict.word_array.back().source = std::string(string_start, string_end);
			e->dict.word_array.back().specialization_of = old_word;
			e->dict.word_array.back().stack_types_start = start_types;
			e->dict.word_array.back().stack_types_count = count_types;

			return p + 2;
		}
	}

	e->report_error("reached the end of a definition source without a ; terminator");
	e->mode = fif::fif_mode::error;
	return p + 2;
}

inline int32_t* iadd(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		s.mark_used_from_main(2);
		auto add_result = LLVMBuildAdd(e->llvm_builder, s.main_ex_back(1), s.main_ex_back(0), "");
		s.pop_main();
		s.set_main_ex_back(0, add_result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		s.mark_used_from_main(2);
		auto a = s.main_data_back(0);
		auto b = s.main_data_back(1);
		s.pop_main();
		s.set_main_data_back(0, b + a);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.mark_used_from_main(2);
		s.pop_main();
	}
	return p + 2;
}
inline int32_t* f32_add(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto add_result = LLVMBuildFAdd(e->llvm_builder, s.main_ex_back(1), s.main_ex_back(0), "");
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif_f32, 0, add_result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		auto a = s.main_data_back(0);
		auto b = s.main_data_back(1);
		s.pop_main();
		s.pop_main();
		float fa = 0;
		float fb = 0;
		memcpy(&fa, &a, 4);
		memcpy(&fb, &b, 4);
		fa = fa + fb;
		memcpy(&a, &fa, 4);
		s.push_back_main(fif::fif_f32, a, nullptr);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif::fif_f32, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* f64_add(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto add_result = LLVMBuildFAdd(e->llvm_builder, s.main_ex_back(1), s.main_ex_back(0), "");
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif_f64, 0, add_result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		auto a = s.main_data_back(0);
		auto b = s.main_data_back(1);
		s.pop_main();
		s.pop_main();
		double fa = 0;
		double fb = 0;
		memcpy(&fa, &a, 8);
		memcpy(&fb, &b, 8);
		fa = fa + fb;
		memcpy(&a, &fa, 8);
		s.push_back_main(fif::fif_f64, a, nullptr);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif::fif_f64, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* isub(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		s.mark_used_from_main(2);
		auto add_result = LLVMBuildSub(e->llvm_builder, s.main_ex_back(1), s.main_ex_back(0), "");
		s.pop_main();
		s.set_main_ex_back(0, add_result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		s.mark_used_from_main(2);
		auto a = s.main_data_back(0);
		auto b = s.main_data_back(1);
		s.pop_main();
		s.set_main_data_back(0, b - a);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.mark_used_from_main(2);
		s.pop_main();
	}
	return p + 2;
}
inline int32_t* f32_sub(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto add_result = LLVMBuildFSub(e->llvm_builder, s.main_ex_back(1), s.main_ex_back(0), "");
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif_f32, 0, add_result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		auto a = s.main_data_back(0);
		auto b = s.main_data_back(1);
		s.pop_main();
		s.pop_main();
		float fa = 0;
		float fb = 0;
		memcpy(&fa, &a, 4);
		memcpy(&fb, &b, 4);
		fa = fa - fb;
		memcpy(&a, &fa, 4);
		s.push_back_main(fif::fif_f32, a, nullptr);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif::fif_f32, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* f64_sub(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto add_result = LLVMBuildFSub(e->llvm_builder, s.main_ex_back(1), s.main_ex_back(0), "");
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif_f64, 0, add_result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		auto a = s.main_data_back(0);
		auto b = s.main_data_back(1);
		s.pop_main();
		s.pop_main();
		double fa = 0;
		double fb = 0;
		memcpy(&fa, &a, 8);
		memcpy(&fb, &b, 8);
		fa = fa - fb;
		memcpy(&a, &fa, 8);
		s.push_back_main(fif::fif_f64, a, nullptr);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif::fif_f64, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* imul(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		s.mark_used_from_main(2);
		auto add_result = LLVMBuildMul(e->llvm_builder, s.main_ex_back(1), s.main_ex_back(0), "");
		s.pop_main();
		s.set_main_ex_back(0, add_result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		s.mark_used_from_main(2);
		auto a = s.main_data_back(0);
		auto b = s.main_data_back(1);
		s.pop_main();
		s.set_main_data_back(0, b * a);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.mark_used_from_main(2);
		s.pop_main();
	}
	return p + 2;
}
inline int32_t* f32_mul(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto add_result = LLVMBuildFMul(e->llvm_builder, s.main_ex_back(1), s.main_ex_back(0), "");
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif_f32, 0, add_result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		auto a = s.main_data_back(0);
		auto b = s.main_data_back(1);
		s.pop_main();
		s.pop_main();
		float fa = 0;
		float fb = 0;
		memcpy(&fa, &a, 4);
		memcpy(&fb, &b, 4);
		fa =  fb * fa;
		memcpy(&a, &fa, 4);
		s.push_back_main(fif::fif_f32, a, nullptr);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif::fif_f32, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* f64_mul(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto add_result = LLVMBuildFMul(e->llvm_builder, s.main_ex_back(1), s.main_ex_back(0), "");
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif_f64, 0, add_result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		auto a = s.main_data_back(0);
		auto b = s.main_data_back(1);
		s.pop_main();
		s.pop_main();
		double fa = 0;
		double fb = 0;
		memcpy(&fa, &a, 8);
		memcpy(&fb, &b, 8);
		fa = fb * fa;
		memcpy(&a, &fa, 8);
		s.push_back_main(fif::fif_f64, a, nullptr);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif::fif_f64, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* sidiv(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		s.mark_used_from_main(2);
		auto add_result = LLVMBuildSDiv(e->llvm_builder, s.main_ex_back(1), s.main_ex_back(0), "");
		s.pop_main();
		s.set_main_ex_back(0, add_result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		s.mark_used_from_main(2);
		auto a = s.main_data_back(0);
		auto b = s.main_data_back(1);
		s.pop_main();
		s.set_main_data_back(0, b / a);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.mark_used_from_main(2);
		s.pop_main();
	}
	return p + 2;
}
inline int32_t* uidiv(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		s.mark_used_from_main(2);
		auto add_result = LLVMBuildUDiv(e->llvm_builder, s.main_ex_back(1), s.main_ex_back(0), "");
		s.pop_main();
		s.set_main_ex_back(0, add_result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		s.mark_used_from_main(2);
		auto a = uint64_t(s.main_data_back(0));
		auto b = uint64_t(s.main_data_back(1));
		s.pop_main();
		s.set_main_data_back(0, b / a);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.mark_used_from_main(2);
		s.pop_main();
	}
	return p + 2;
}
inline int32_t* f32_div(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto add_result = LLVMBuildFDiv(e->llvm_builder, s.main_ex_back(1), s.main_ex_back(0), "");
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif_f32, 0, add_result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		auto a = s.main_data_back(0);
		auto b = s.main_data_back(1);
		s.pop_main();
		s.pop_main();
		float fa = 0;
		float fb = 0;
		memcpy(&fa, &a, 4);
		memcpy(&fb, &b, 4);
		fa = fb / fa;
		memcpy(&a, &fa, 4);
		s.push_back_main(fif::fif_f32, a, nullptr);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif::fif_f32, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* f64_div(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto add_result = LLVMBuildFDiv(e->llvm_builder, s.main_ex_back(1), s.main_ex_back(0), "");
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif_f64, 0, add_result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		auto a = s.main_data_back(0);
		auto b = s.main_data_back(1);
		s.pop_main();
		s.pop_main();
		double fa = 0;
		double fb = 0;
		memcpy(&fa, &a, 8);
		memcpy(&fb, &b, 8);
		fa = fb / fa;
		memcpy(&a, &fa, 8);
		s.push_back_main(fif::fif_f64, a, nullptr);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif::fif_f64, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* simod(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		s.mark_used_from_main(2);
		auto add_result = LLVMBuildSRem(e->llvm_builder, s.main_ex_back(1), s.main_ex_back(0), "");
		s.pop_main();
		s.set_main_ex_back(0, add_result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		s.mark_used_from_main(2);
		auto a = s.main_data_back(0);
		auto b = s.main_data_back(1);
		s.pop_main();
		s.set_main_data_back(0, b % a);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.mark_used_from_main(2);
		s.pop_main();
	}
	return p + 2;
}
inline int32_t* uimod(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		s.mark_used_from_main(2);
		auto add_result = LLVMBuildURem(e->llvm_builder, s.main_ex_back(1), s.main_ex_back(0), "");
		s.pop_main();
		s.set_main_ex_back(0, add_result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		s.mark_used_from_main(2);
		auto a = uint64_t(s.main_data_back(0));
		auto b = uint64_t(s.main_data_back(1));
		s.pop_main();
		s.set_main_data_back(0, b % a);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.mark_used_from_main(2);
		s.pop_main();
	}
	return p + 2;
}
inline int32_t* f32_mod(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto add_result = LLVMBuildFRem(e->llvm_builder, s.main_ex_back(1), s.main_ex_back(0), "");
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif_f32, 0, add_result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		auto a = s.main_data_back(0);
		auto b = s.main_data_back(1);
		s.pop_main();
		s.pop_main();
		float fa = 0;
		float fb = 0;
		memcpy(&fa, &a, 4);
		memcpy(&fb, &b, 4);
		fa = fmodf(fb, fa);
		memcpy(&a, &fa, 4);
		s.push_back_main(fif::fif_f32, a, nullptr);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif::fif_f32, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* f64_mod(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto add_result = LLVMBuildFDiv(e->llvm_builder, s.main_ex_back(1), s.main_ex_back(0), "");
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif_f64, 0, add_result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		auto a = s.main_data_back(0);
		auto b = s.main_data_back(1);
		s.pop_main();
		s.pop_main();
		double fa = 0;
		double fb = 0;
		memcpy(&fa, &a, 8);
		memcpy(&fb, &b, 8);
		fa = fmod(fb, fa);
		memcpy(&a, &fa, 8);
		s.push_back_main(fif::fif_f64, a, nullptr);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif::fif_f64, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* dup(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
		s.mark_used_from_main(1);
		auto type = s.main_type_back(0);
		auto expr = s.main_ex_back(0);
		s.push_back_main(type, 0, expr);
	} else if(e->mode == fif::fif_mode::interpreting) {
		s.mark_used_from_main(1);
		auto type = s.main_type_back(0);
		auto dat = s.main_data_back(0);
		s.push_back_main(type, dat, nullptr);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.mark_used_from_main(1);
		auto type = s.main_type_back(0);
		s.push_back_main(type, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* init(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
		s.mark_used_from_main(1);
	} else if(e->mode == fif::fif_mode::interpreting) {
		s.mark_used_from_main(1);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.mark_used_from_main(1);
	}
	return p + 2;
}
inline int32_t* copy(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
		s.mark_used_from_main(1);
		auto type = s.main_type_back(0);
		auto expr = s.main_ex_back(0);
		s.push_back_main(type, 0, expr);
	} else if(e->mode == fif::fif_mode::interpreting) {
		s.mark_used_from_main(1);
		auto type = s.main_type_back(0);
		auto dat = s.main_data_back(0);
		s.push_back_main(type, dat, nullptr);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.mark_used_from_main(1);
		auto type = s.main_type_back(0);
		s.push_back_main(type, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* drop(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
		auto type = s.main_type_back(0);
		s.pop_main();
	} else if(e->mode == fif::fif_mode::interpreting) {
		auto type = s.main_type_back(0);
		s.pop_main();
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
	}
	return p + 2;
}
inline int32_t* fif_swap(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
		auto type_a = s.main_type_back(0);
		auto type_b = s.main_type_back(1);
		auto expr_a = s.main_ex_back(0);
		auto expr_b = s.main_ex_back(1);
		s.pop_main();
		s.pop_main();
		s.push_back_main(type_a, 0, expr_a);
		s.push_back_main(type_b, 0, expr_b);
	} else if(e->mode == fif::fif_mode::interpreting) {
		auto type_a = s.main_type_back(0);
		auto type_b = s.main_type_back(1);
		auto dat_a = s.main_data_back(0);
		auto dat_b = s.main_data_back(1);
		s.pop_main();
		s.pop_main();
		s.push_back_main(type_a, dat_a, nullptr);
		s.push_back_main(type_b, dat_b, nullptr);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		auto type_a = s.main_type_back(0);
		auto type_b = s.main_type_back(1);
		s.pop_main();
		s.pop_main();
		s.push_back_main(type_a, 0, nullptr);
		s.push_back_main(type_b, 0, nullptr);
	}
	return p + 2;
}


inline int32_t* fif_if(fif::state_stack& s, int32_t* p, fif::environment* e) {
	e->compiler_stack.emplace_back(std::make_unique<fif::conditional_scope>(e->compiler_stack.back().get(), *e, s));
	return p + 2;
}
inline int32_t* fif_else(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->compiler_stack.empty() || e->compiler_stack.back()->get_type() != fif::control_structure::str_if) {
		e->report_error("invalid use of else");
		e->mode = fif::fif_mode::error;
	} else {
		fif::conditional_scope* c = static_cast<fif::conditional_scope*>(e->compiler_stack.back().get());
		c->commit_first_branch(*e);
	}
	return p + 2;
}
inline int32_t* fif_then(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->compiler_stack.empty() || e->compiler_stack.back()->get_type() != fif::control_structure::str_if) {
		e->report_error("invalid use of then/end-if");
		e->mode = fif::fif_mode::error;
	} else {
		if(e->compiler_stack.back()->finish(*e))
			e->compiler_stack.pop_back();
	}
	return p + 2;
}

inline int32_t* fif_while(fif::state_stack& s, int32_t* p, fif::environment* e) {
	e->compiler_stack.emplace_back(std::make_unique<fif::while_loop_scope>(e->compiler_stack.back().get(), *e, s));
	return p + 2;
}
inline int32_t* fif_loop(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->compiler_stack.empty() || e->compiler_stack.back()->get_type() != fif::control_structure::str_while_loop) {
		e->report_error("invalid use of loop");
		e->mode = fif::fif_mode::error;
	} else {
		fif::while_loop_scope* c = static_cast<fif::while_loop_scope*>(e->compiler_stack.back().get());
		c->end_condition(*e);
	}
	return p + 2;
}
inline int32_t* fif_end_while(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->compiler_stack.empty() || e->compiler_stack.back()->get_type() != fif::control_structure::str_while_loop) {
		e->report_error("invalid use of end-while");
		e->mode = fif::fif_mode::error;
	} else {
		if(e->compiler_stack.back()->finish(*e))
			e->compiler_stack.pop_back();
	}
	return p + 2;
}
inline int32_t* fif_do(fif::state_stack& s, int32_t* p, fif::environment* e) {
	e->compiler_stack.emplace_back(std::make_unique<fif::do_loop_scope>(e->compiler_stack.back().get(), *e, s));
	return p + 2;
}
inline int32_t* fif_until(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->compiler_stack.empty() || e->compiler_stack.back()->get_type() != fif::control_structure::str_do_loop) {
		e->report_error("invalid use of until");
		e->mode = fif::fif_mode::error;
	} else {
		fif::do_loop_scope* c = static_cast<fif::do_loop_scope*>(e->compiler_stack.back().get());
		c->at_until(*e);
	}
	return p + 2;
}
inline int32_t* fif_end_do(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->compiler_stack.empty() || e->compiler_stack.back()->get_type() != fif::control_structure::str_do_loop) {
		e->report_error("invalid use of end-do");
		e->mode = fif::fif_mode::error;
	} else {
		if(e->compiler_stack.back()->finish(*e))
			e->compiler_stack.pop_back();
	}
	return p + 2;
}
inline int32_t* from_r(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
		auto type_a = s.return_type_back(0);
		auto expr_a = s.return_ex_back(0);
		s.push_back_main(type_a, 0, expr_a);
		s.pop_return();
	} else if(e->mode == fif::fif_mode::interpreting) {
		auto type_a = s.return_type_back(0);
		auto dat_a = s.return_data_back(0);
		s.push_back_main(type_a, dat_a, nullptr);
		s.pop_return();
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		auto type_a = s.return_type_back(0);
		s.push_back_main(type_a, 0, nullptr);
		s.pop_return();
	}
	return p + 2;
}
inline int32_t* r_at(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
		auto type_a = s.return_type_back(0);
		auto expr_a = s.return_ex_back(0);
		s.push_back_main(type_a, 0, expr_a);
		s.pop_return();

		execute_fif_word(fif::parse_result{ "dup", false }, *e, false);
		auto type_b = s.main_type_back(0);
		auto expr_b = s.main_ex_back(0);
		s.pop_main();

		s.push_back_return(type_b, 0, expr_b);

	} else if(e->mode == fif::fif_mode::interpreting) {
		auto type_a = s.return_type_back(0);
		auto dat_a = s.return_data_back(0);
		s.push_back_main(type_a, dat_a, nullptr);
		s.pop_return();

		execute_fif_word(fif::parse_result{ "dup", false }, *e, false);
		auto type_b = s.main_type_back(0);
		auto dat_b = s.main_data_back(0);
		s.pop_main();
		
		s.push_back_return(type_b, dat_b, nullptr);

	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		auto type_a = s.return_type_back(0);
		s.push_back_main(type_a, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* to_r(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
		auto type_a = s.main_type_back(0);
		auto expr_a = s.main_ex_back(0);
		s.push_back_return(type_a, 0, expr_a);
		s.pop_main();
	} else if(e->mode == fif::fif_mode::interpreting) {
		auto type_a = s.main_type_back(0);
		auto dat_a = s.main_data_back(0);
		s.push_back_return(type_a, dat_a, nullptr);
		s.pop_main();
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		auto type_a = s.main_type_back(0);
		s.push_back_return(type_a, 0, nullptr);
		s.pop_main();
	}
	return p + 2;
}


inline void add_precompiled(fif::environment& env, std::string name, fif::fif_call fn, std::vector<int32_t> types, bool immediate = false) {
	if(auto it = env.dict.words.find(name); it != env.dict.words.end()) {
		env.dict.word_array[it->second].instances.push_back(int32_t(env.dict.all_instances.size()));
		env.dict.word_array[it->second].immediate |= immediate;
	} else {
		env.dict.words.insert_or_assign(name, int32_t(env.dict.word_array.size()));
		env.dict.word_array.emplace_back();
		env.dict.word_array.back().instances.push_back(int32_t(env.dict.all_instances.size()));
		env.dict.word_array.back().immediate = immediate;
	}
	env.dict.all_instances.push_back(fif::compiled_word_instance{ });
	auto& w = std::get< fif::compiled_word_instance>(env.dict.all_instances.back());
	w.implementation = fn;
	w.stack_types_count = int32_t(types.size());
	w.stack_types_start = int32_t(env.dict.all_stack_types.size());
	env.dict.all_stack_types.insert(env.dict.all_stack_types.end(), types.begin(), types.end());
}

inline int32_t* ilt(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildICmp(e->llvm_builder, LLVMIntPredicate::LLVMIntSLT, s.main_ex_back(1), s.main_ex_back(0), "");
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif_bool, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		auto a = s.main_data_back(0);
		auto b = s.main_data_back(1);
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif::fif_bool, b < a, nullptr);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif::fif_bool, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* f32lt(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildFCmp(e->llvm_builder, LLVMRealPredicate::LLVMRealOLT, s.main_ex_back(1), s.main_ex_back(0), "");
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif_bool, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		auto ia = s.main_data_back(0);
		auto ib = s.main_data_back(1);
		float fa = 0;
		float fb = 0;
		memcpy(&fa, &ia, 4);
		memcpy(&fb, &ib, 4);
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif::fif_bool, fb < fa, nullptr);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif::fif_bool, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* f64lt(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildFCmp(e->llvm_builder, LLVMRealPredicate::LLVMRealOLT, s.main_ex_back(1), s.main_ex_back(0), "");
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif_bool, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		auto ia = s.main_data_back(0);
		auto ib = s.main_data_back(1);
		double fa = 0;
		double fb = 0;
		memcpy(&fa, &ia, 8);
		memcpy(&fb, &ib, 8);
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif::fif_bool, fb < fa, nullptr);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif::fif_bool, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* uilt(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildICmp(e->llvm_builder, LLVMIntPredicate::LLVMIntULT, s.main_ex_back(1), s.main_ex_back(0), "");
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif_bool, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		auto a = uint64_t(s.main_data_back(0));
		auto b = uint64_t(s.main_data_back(1));
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif::fif_bool, b < a, nullptr);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif::fif_bool, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* igt(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildICmp(e->llvm_builder, LLVMIntPredicate::LLVMIntSGT, s.main_ex_back(1), s.main_ex_back(0), "");
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif_bool, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		auto a = s.main_data_back(0);
		auto b = s.main_data_back(1);
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif::fif_bool, b > a, nullptr);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif::fif_bool, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* uigt(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildICmp(e->llvm_builder, LLVMIntPredicate::LLVMIntUGT, s.main_ex_back(1), s.main_ex_back(0), "");
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif_bool, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		auto a = uint64_t(s.main_data_back(0));
		auto b = uint64_t(s.main_data_back(1));
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif::fif_bool, b > a, nullptr);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif::fif_bool, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* f32gt(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildFCmp(e->llvm_builder, LLVMRealPredicate::LLVMRealOGT, s.main_ex_back(1), s.main_ex_back(0), "");
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif_bool, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		auto ia = s.main_data_back(0);
		auto ib = s.main_data_back(1);
		float fa = 0;
		float fb = 0;
		memcpy(&fa, &ia, 4);
		memcpy(&fb, &ib, 4);
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif::fif_bool, fb > fa, nullptr);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif::fif_bool, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* f64gt(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildFCmp(e->llvm_builder, LLVMRealPredicate::LLVMRealOGT, s.main_ex_back(1), s.main_ex_back(0), "");
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif_bool, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		auto ia = s.main_data_back(0);
		auto ib = s.main_data_back(1);
		double fa = 0;
		double fb = 0;
		memcpy(&fa, &ia, 8);
		memcpy(&fb, &ib, 8);
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif::fif_bool, fb > fa, nullptr);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif::fif_bool, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* ile(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildICmp(e->llvm_builder, LLVMIntPredicate::LLVMIntSLE, s.main_ex_back(1), s.main_ex_back(0), "");
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif_bool, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		auto a = s.main_data_back(0);
		auto b = s.main_data_back(1);
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif::fif_bool, b <= a, nullptr);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif::fif_bool, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* uile(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildICmp(e->llvm_builder, LLVMIntPredicate::LLVMIntULE, s.main_ex_back(1), s.main_ex_back(0), "");
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif_bool, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		auto a = uint64_t(s.main_data_back(0));
		auto b = uint64_t(s.main_data_back(1));
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif::fif_bool, b <= a, nullptr);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif::fif_bool, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* f32le(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildFCmp(e->llvm_builder, LLVMRealPredicate::LLVMRealOLE, s.main_ex_back(1), s.main_ex_back(0), "");
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif_bool, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		auto ia = s.main_data_back(0);
		auto ib = s.main_data_back(1);
		float fa = 0;
		float fb = 0;
		memcpy(&fa, &ia, 4);
		memcpy(&fb, &ib, 4);
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif::fif_bool, fb <= fa, nullptr);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif::fif_bool, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* f64le(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildFCmp(e->llvm_builder, LLVMRealPredicate::LLVMRealOLE, s.main_ex_back(1), s.main_ex_back(0), "");
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif_bool, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		auto ia = s.main_data_back(0);
		auto ib = s.main_data_back(1);
		double fa = 0;
		double fb = 0;
		memcpy(&fa, &ia, 8);
		memcpy(&fb, &ib, 8);
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif::fif_bool, fb <= fa, nullptr);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif::fif_bool, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* ige(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildICmp(e->llvm_builder, LLVMIntPredicate::LLVMIntSGE, s.main_ex_back(1), s.main_ex_back(0), "");
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif_bool, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		auto a = s.main_data_back(0);
		auto b = s.main_data_back(1);
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif::fif_bool, b >= a, nullptr);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif::fif_bool, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* uige(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildICmp(e->llvm_builder, LLVMIntPredicate::LLVMIntUGE, s.main_ex_back(1), s.main_ex_back(0), "");
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif_bool, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		auto a = uint64_t(s.main_data_back(0));
		auto b = uint64_t(s.main_data_back(1));
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif::fif_bool, b >= a, nullptr);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif::fif_bool, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* f32ge(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildFCmp(e->llvm_builder, LLVMRealPredicate::LLVMRealOGE, s.main_ex_back(1), s.main_ex_back(0), "");
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif_bool, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		auto ia = s.main_data_back(0);
		auto ib = s.main_data_back(1);
		float fa = 0;
		float fb = 0;
		memcpy(&fa, &ia, 4);
		memcpy(&fb, &ib, 4);
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif::fif_bool, fb >= fa, nullptr);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif::fif_bool, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* f64ge(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildFCmp(e->llvm_builder, LLVMRealPredicate::LLVMRealOGE, s.main_ex_back(1), s.main_ex_back(0), "");
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif_bool, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		auto ia = s.main_data_back(0);
		auto ib = s.main_data_back(1);
		double fa = 0;
		double fb = 0;
		memcpy(&fa, &ia, 8);
		memcpy(&fb, &ib, 8);
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif::fif_bool, fb >= fa, nullptr);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif::fif_bool, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* ieq(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildICmp(e->llvm_builder, LLVMIntPredicate::LLVMIntEQ, s.main_ex_back(1), s.main_ex_back(0), "");
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif_bool, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		auto a = s.main_data_back(0);
		auto b = s.main_data_back(1);
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif::fif_bool, b == a, nullptr);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif::fif_bool, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* f32eq(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildFCmp(e->llvm_builder, LLVMRealPredicate::LLVMRealOEQ, s.main_ex_back(1), s.main_ex_back(0), "");
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif_bool, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		auto ia = s.main_data_back(0);
		auto ib = s.main_data_back(1);
		float fa = 0;
		float fb = 0;
		memcpy(&fa, &ia, 4);
		memcpy(&fb, &ib, 4);
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif::fif_bool, fb == fa, nullptr);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif::fif_bool, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* f64eq(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildFCmp(e->llvm_builder, LLVMRealPredicate::LLVMRealOEQ, s.main_ex_back(1), s.main_ex_back(0), "");
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif_bool, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		auto ia = s.main_data_back(0);
		auto ib = s.main_data_back(1);
		double fa = 0;
		double fb = 0;
		memcpy(&fa, &ia, 8);
		memcpy(&fb, &ib, 8);
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif::fif_bool, fb == fa, nullptr);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif::fif_bool, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* ine(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildICmp(e->llvm_builder, LLVMIntPredicate::LLVMIntNE, s.main_ex_back(1), s.main_ex_back(0), "");
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif_bool, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		auto a = s.main_data_back(0);
		auto b = s.main_data_back(1);
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif::fif_bool, b != a, nullptr);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif::fif_bool, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* f32ne(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildFCmp(e->llvm_builder, LLVMRealPredicate::LLVMRealONE, s.main_ex_back(1), s.main_ex_back(0), "");
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif_bool, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		auto ia = s.main_data_back(0);
		auto ib = s.main_data_back(1);
		float fa = 0;
		float fb = 0;
		memcpy(&fa, &ia, 4);
		memcpy(&fb, &ib, 4);
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif::fif_bool, fb != fa, nullptr);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif::fif_bool, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* f64ne(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildFCmp(e->llvm_builder, LLVMRealPredicate::LLVMRealONE, s.main_ex_back(1), s.main_ex_back(0), "");
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif_bool, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		auto ia = s.main_data_back(0);
		auto ib = s.main_data_back(1);
		double fa = 0;
		double fb = 0;
		memcpy(&fa, &ia, 8);
		memcpy(&fb, &ib, 8);
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif::fif_bool, fb != fa, nullptr);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif::fif_bool, 0, nullptr);
	}
	return p + 2;
}

inline int32_t* f_select(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		s.mark_used_from_main(3);
		auto result = LLVMBuildSelect(e->llvm_builder, s.main_ex_back(0), s.main_ex_back(1), s.main_ex_back(2), "");

		if(e->dict.type_array[s.main_type_back(1)].flags != 0) {
			auto drop_result = LLVMBuildSelect(e->llvm_builder, s.main_ex_back(0), s.main_ex_back(2), s.main_ex_back(1), "");
			s.push_back_main(s.main_type_back(1), 0, drop_result);
			execute_fif_word(fif::parse_result{ "drop", false }, *e, false);
		}

		s.pop_main();
		s.pop_main();
		s.set_main_ex_back(0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		s.mark_used_from_main(3);
		auto ib = s.main_data_back(2);
		auto ia = s.main_data_back(1);
		auto ex = s.main_data_back(0);

		if(e->dict.type_array[s.main_type_back(1)].flags != 0) {
			s.push_back_main(s.main_type_back(1), ex != 0 ? ib : ia, nullptr);
			execute_fif_word(fif::parse_result{ "drop", false }, *e, false);
		}

		s.pop_main();
		s.pop_main();
		s.set_main_data_back(0, ex != 0 ? ia : ib);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.mark_used_from_main(3);
		s.pop_main();
		s.pop_main();
	}
	return p + 2;
}

inline int32_t* make_immediate(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
		e->report_error("cannot turn a word immediate in compiled code");
		e->mode = fif_mode::error;
		return nullptr;
	} else if(e->mode == fif::fif_mode::interpreting) {
		if(e->dict.word_array.back().specialization_of == -1) {
			e->dict.word_array.back().immediate = true;
		} else {
			e->report_error("cannot mark a specialized word as immediate");
			e->mode = fif_mode::error;
			return nullptr;
		}
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		
	}
	return p + 2;
}

inline int32_t* open_bracket(fif::state_stack& s, int32_t* p, fif::environment* e) {
	switch_compiler_stack_mode(*e, fif_mode::interpreting);
	return p + 2;
}
inline int32_t* close_bracket(fif::state_stack& s, int32_t* p, fif::environment* e) {
	restore_compiler_stack_mode(*e);
	return p + 2;
}

inline int32_t* impl_heap_allot(fif::state_stack& s, int32_t* p, fif::environment* e) { // must drop contents ?
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto val = s.main_ex_back(0);
		auto new_mem = LLVMBuildMalloc(e->llvm_builder, e->dict.type_array[s.main_type_back(0)].llvm_type, "");
		LLVMBuildStore(e->llvm_builder, val, new_mem);
		int32_t ptr_type[] = { fif_ptr, std::numeric_limits<int32_t>::max(), s.main_type_back(0), -1 };
		std::vector<int32_t> subs;
		auto mem_type = resolve_span_type(std::span<int32_t const>(ptr_type, ptr_type + 4), subs, *e);
		s.pop_main();
		s.push_back_main(mem_type.type, 0, new_mem);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		auto ptr = malloc(8);
		int64_t dat = s.main_data_back(0);
		memcpy(ptr, &dat, 8);

		int32_t ptr_type[] = { fif_ptr, std::numeric_limits<int32_t>::max(), s.main_type_back(0), -1 };
		std::vector<int32_t> subs;
		auto mem_type = resolve_span_type(std::span<int32_t const>(ptr_type, ptr_type + 4), subs, *e);
		s.pop_main();
		s.push_back_main(mem_type.type, (int64_t)ptr, nullptr);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		int32_t ptr_type[] = { fif_ptr, std::numeric_limits<int32_t>::max(), s.main_type_back(0), -1 };
		std::vector<int32_t> subs;
		auto mem_type = resolve_span_type(std::span<int32_t const>(ptr_type, ptr_type + 4), subs, *e);
		s.pop_main();
		s.push_back_main(mem_type.type, 0, nullptr);
	}
	return p + 2;
}

inline int32_t* impl_heap_free(fif::state_stack& s, int32_t* p, fif::environment* e) { // must drop contents ?
	if(fif::typechecking_failed(e->mode))
		return p + 2;

	auto ptr_type = s.main_type_back(0);
	auto decomp = e->dict.type_array[ptr_type].decomposed_types_start;
	auto pointer_contents = e->dict.all_stack_types[decomp + 1];

	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto iresult = LLVMBuildLoad2(e->llvm_builder, e->dict.type_array[pointer_contents].llvm_type, s.main_ex_back(0), "");
		LLVMBuildFree(e->llvm_builder, s.main_ex_back(0));
		s.pop_main();
		s.push_back_main(pointer_contents, 0, iresult);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {

		auto a = s.main_data_back(0);
		int64_t* ptr = (int64_t*)a;
		auto val = *ptr;
		free(ptr);
		s.pop_main();
		s.push_back_main(pointer_contents, val, 0);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.push_back_main(pointer_contents, 0, 0);
	}
	return p + 2;
}

inline int32_t* impl_load(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(fif::typechecking_failed(e->mode))
		return p + 2;

	auto ptr_type = s.main_type_back(0);
	auto decomp = e->dict.type_array[ptr_type].decomposed_types_start;
	auto pointer_contents = e->dict.all_stack_types[decomp + 1];

	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildLoad2(e->llvm_builder, e->dict.type_array[pointer_contents].llvm_type, s.main_ex_back(0), "");
		s.pop_main();
		s.push_back_main(pointer_contents, 0, result);

		if(e->dict.type_array[pointer_contents].flags != 0) {
			execute_fif_word(fif::parse_result{ "dup", false }, *e, false);

			// remove the extra value and save the duplicated expression on top of the stack
			auto expr_b = s.main_ex_back(0);
			s.set_main_ex_back(1, expr_b);
			s.pop_main();
		}
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		auto v = s.main_data_back(0);
		s.pop_main();
		int64_t* ptr_val = (int64_t*)v;
		auto effective_type = pointer_contents;

		if(pointer_contents != -1 && e->dict.type_array[pointer_contents].refcounted_type()) {
			if(e->dict.type_array[pointer_contents].decomposed_types_count >= 2) {
				auto child_index = e->dict.type_array[pointer_contents].decomposed_types_start + 1;
				auto child_type = e->dict.all_stack_types[child_index];

				if(e->dict.type_array[pointer_contents].single_member_struct()) {
					effective_type = child_type;
				}
			}
		}

		if(effective_type == fif_i32 || effective_type == fif_f32)
			s.push_back_main(pointer_contents, *(int32_t*)(ptr_val), nullptr);
		else if(effective_type == fif_u32)
			s.push_back_main(pointer_contents, *(uint32_t*)(ptr_val), nullptr);
		else if(effective_type == fif_i16)
			s.push_back_main(pointer_contents, *(int16_t*)(ptr_val), nullptr);
		else if(effective_type == fif_u16)
			s.push_back_main(pointer_contents, *(uint16_t*)(ptr_val), nullptr);
		else if(effective_type == fif_i8)
			s.push_back_main(pointer_contents, *(int8_t*)(ptr_val), nullptr);
		else if(effective_type == fif_u8 || effective_type == fif_bool)
			s.push_back_main(pointer_contents, *(uint8_t*)(ptr_val), nullptr);
		else
			s.push_back_main(pointer_contents, *ptr_val, nullptr);

		if(e->dict.type_array[pointer_contents].flags != 0) {
			execute_fif_word(fif::parse_result{ "dup", false }, *e, false);
			// remove the extra value and save the duplicated expression on top of the stack
			auto data_b = s.main_data_back(0);
			s.set_main_data_back(1, data_b);
			s.pop_main();
		}
	} else if(fif::typechecking_mode(e->mode)) {
		s.pop_main();
		s.push_back_main(pointer_contents, 0, nullptr);
	}
	return p + 2;
}

inline int32_t* impl_load_deallocated(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(fif::typechecking_failed(e->mode))
		return p + 2;

	auto ptr_type = s.main_type_back(0);
	auto decomp = e->dict.type_array[ptr_type].decomposed_types_start;
	auto pointer_contents = e->dict.all_stack_types[decomp + 1];

	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildLoad2(e->llvm_builder, e->dict.type_array[pointer_contents].llvm_type, s.main_ex_back(0), "");
		s.pop_main();
		s.push_back_main(pointer_contents, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		auto v = s.main_data_back(0);
		s.pop_main();
		int64_t* ptr_val = (int64_t*)v;
		auto effective_type = pointer_contents;

		if(pointer_contents != -1 && e->dict.type_array[pointer_contents].refcounted_type()) {
			if(e->dict.type_array[pointer_contents].decomposed_types_count >= 2) {
				auto child_index = e->dict.type_array[pointer_contents].decomposed_types_start + 1;
				auto child_type = e->dict.all_stack_types[child_index];

				if(e->dict.type_array[pointer_contents].single_member_struct()) {
					effective_type = child_type;
				}
			}
		}

		if(effective_type == fif_i32 || effective_type == fif_f32)
			s.push_back_main(pointer_contents, *(int32_t*)(ptr_val), nullptr);
		else if(effective_type == fif_u32)
			s.push_back_main(pointer_contents, *(uint32_t*)(ptr_val), nullptr);
		else if(effective_type == fif_i16)
			s.push_back_main(pointer_contents, *(int16_t*)(ptr_val), nullptr);
		else if(effective_type == fif_u16)
			s.push_back_main(pointer_contents, *(uint16_t*)(ptr_val), nullptr);
		else if(effective_type == fif_i8)
			s.push_back_main(pointer_contents, *(int8_t*)(ptr_val), nullptr);
		else if(effective_type == fif_u8 || effective_type == fif_bool)
			s.push_back_main(pointer_contents, *(uint8_t*)(ptr_val), nullptr);
		else
			s.push_back_main(pointer_contents, *ptr_val, nullptr);

	} else if(fif::typechecking_mode(e->mode)) {
		s.pop_main();
		s.push_back_main(pointer_contents, 0, nullptr);
	}
	return p + 2;
}

inline int32_t* impl_store(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(fif::typechecking_failed(e->mode))
		return p + 2;

	auto ptr_type = s.main_type_back(0);
	auto decomp = e->dict.type_array[ptr_type].decomposed_types_start;
	auto pointer_contents = e->dict.all_stack_types[decomp + 1];

	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		if(e->dict.type_array[pointer_contents].flags != 0) {
			auto iresult = LLVMBuildLoad2(e->llvm_builder, e->dict.type_array[pointer_contents].llvm_type, s.main_ex_back(0), "");
			s.push_back_main(pointer_contents, 0, iresult);
			execute_fif_word(fif::parse_result{ "drop", false }, *e, false);
		}

		auto result = LLVMBuildStore(e->llvm_builder, s.main_ex_back(1), s.main_ex_back(0));
		s.pop_main();
		s.pop_main();
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {

		auto v = s.main_data_back(0);
		int64_t* ptr_val = (int64_t*)v;

		if(e->dict.type_array[pointer_contents].flags != 0) {
			s.push_back_main(pointer_contents, *ptr_val, nullptr);
			execute_fif_word(fif::parse_result{ "drop", false }, *e, false);
		}

		auto to_write = s.main_data_back(1);

		auto effective_type = pointer_contents;
		if(pointer_contents != -1 && e->dict.type_array[pointer_contents].refcounted_type()) {
			if(e->dict.type_array[pointer_contents].decomposed_types_count >= 2) {
				auto child_index = e->dict.type_array[pointer_contents].decomposed_types_start + 1;
				auto child_type = e->dict.all_stack_types[child_index];

				if(e->dict.type_array[pointer_contents].single_member_struct()) {
					effective_type = child_type;
				}
			}
		}

		if(effective_type == fif_i32 || effective_type == fif_f32 || effective_type == fif_u32)
			memcpy(ptr_val, &to_write, 4);
		else if(effective_type == fif_u16 || effective_type == fif_i16)
			memcpy(ptr_val, &to_write, 2);
		else if(effective_type == fif_u8 || effective_type == fif_bool || effective_type == fif_i8)
			memcpy(ptr_val, &to_write, 1);
		else
			memcpy(ptr_val, &to_write, 8);

		s.pop_main();
		s.pop_main();
	} else if(fif::typechecking_mode(e->mode)) {
		s.pop_main();
		s.pop_main();
	}
	return p + 2;
}

inline int32_t* impl_uninit_store(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(fif::typechecking_failed(e->mode))
		return p + 2;

	auto ptr_type = s.main_type_back(0);
	auto decomp = e->dict.type_array[ptr_type].decomposed_types_start;
	auto pointer_contents = e->dict.all_stack_types[decomp + 1];

	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildStore(e->llvm_builder, s.main_ex_back(1), s.main_ex_back(0));
		s.pop_main();
		s.pop_main();
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {

		auto v = s.main_data_back(0);
		int64_t* ptr_val = (int64_t*)v;

		auto to_write = s.main_data_back(1);

		auto effective_type = pointer_contents;
		if(pointer_contents != -1 && e->dict.type_array[pointer_contents].refcounted_type()) {
			if(e->dict.type_array[pointer_contents].decomposed_types_count >= 2) {
				auto child_index = e->dict.type_array[pointer_contents].decomposed_types_start + 1;
				auto child_type = e->dict.all_stack_types[child_index];

				if(e->dict.type_array[pointer_contents].single_member_struct()) {
					effective_type = child_type;
				}
			}
		}

		if(effective_type == fif_i32 || effective_type == fif_f32 || effective_type == fif_u32)
			memcpy(ptr_val, &to_write, 4);
		else if(effective_type == fif_u16 || effective_type == fif_i16)
			memcpy(ptr_val, &to_write, 2);
		else if(effective_type == fif_u8 || effective_type == fif_bool || effective_type == fif_i8)
			memcpy(ptr_val, &to_write, 1);
		else
			memcpy(ptr_val, &to_write, 8);

		s.pop_main();
		s.pop_main();
	} else if(fif::typechecking_mode(e->mode)) {
		s.pop_main();
		s.pop_main();
	}
	return p + 2;
}

inline int32_t* do_pointer_cast(fif::state_stack& s, int32_t* p, fif::environment* e) {
	s.set_main_type_back(0, *(p + 2));
	return p + 3;
}


inline int32_t* pointer_cast(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->source_stack.empty()) {
		e->report_error("pointer cast was unable to read the word describing the pointer type");
		e->mode = fif_mode::error;
		return nullptr;
	}
	auto ptype = read_token(e->source_stack.back(), *e);
	bool bad_type = ptype.is_string;
	auto resolved_type = resolve_type(ptype.content, *e, e->compiler_stack.back()->type_substitutions());
	if(resolved_type == -1) {
		bad_type = true;
	} else if(resolved_type != fif_opaque_ptr) {
		if(e->dict.type_array[resolved_type].decomposed_types_count == 0) {
			bad_type = true;
		} else if(e->dict.all_stack_types[e->dict.type_array[resolved_type].decomposed_types_start] != fif_ptr) {
			bad_type = true;
		}
	}

	if(bad_type) {
		e->report_error("pointer attempted to be cast to a non pointer type");
		e->mode = fif_mode::error;
		return nullptr;
	}

	if(!typechecking_failed(e->mode)) {
		s.mark_used_from_main(1);
		s.set_main_type_back(0, resolved_type);
	}

	if(e->mode == fif::fif_mode::compiling_bytecode) {
		auto compile_bytes = e->compiler_stack.back()->bytecode_compilation_progress();
		if(compile_bytes) {
			fif_call imm = do_pointer_cast;
			uint64_t imm_bytes = 0;
			memcpy(&imm_bytes, &imm, 8);
			compile_bytes->push_back(int32_t(imm_bytes & 0xFFFFFFFF));
			compile_bytes->push_back(int32_t((imm_bytes >> 32) & 0xFFFFFFFF));
			compile_bytes->push_back(resolved_type);
		}
	}
	return p + 2;
}

inline int32_t* impl_sizeof(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->source_stack.empty()) {
		e->report_error("sizeof was unable to read the word describing the type");
		e->mode = fif_mode::error;
		return nullptr;
	}
	auto ptype = read_token(e->source_stack.back(), *e);
	bool bad_type = ptype.is_string;
	auto resolved_type = resolve_type(ptype.content, *e, e->compiler_stack.back()->type_substitutions());
	if(resolved_type == -1) {
		e->report_error("sizeof given an invalid type");
		e->mode = fif_mode::error;
		return nullptr;
	}

	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		s.push_back_main(fif_i32, 0, LLVMConstTrunc(LLVMSizeOf(e->dict.type_array[resolved_type].llvm_type), LLVMInt32TypeInContext(e->llvm_context)));
#endif
	} else if(e->mode == fif::fif_mode::compiling_bytecode) {
		auto compile_bytes = e->compiler_stack.back()->bytecode_compilation_progress();
		if(compile_bytes) {
			fif_call imm = immediate_i32;
			uint64_t imm_bytes = 0;
			memcpy(&imm_bytes, &imm, 8);
			compile_bytes->push_back(int32_t(imm_bytes & 0xFFFFFFFF));
			compile_bytes->push_back(int32_t((imm_bytes >> 32) & 0xFFFFFFFF));
			compile_bytes->push_back(interepreter_size(resolved_type, *e));
		}
		s.push_back_main(fif_i32, 8, 0);
	} else if(e->mode == fif::fif_mode::interpreting) {
		s.push_back_main(fif_i32, 8, 0);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.push_back_main(fif_i32, 0, 0);
	}
	return p + 2;
}

inline int32_t* impl_index(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto num_bytes = s.main_ex_back(1);
		auto iresult = LLVMBuildInBoundsGEP2(e->llvm_builder, LLVMInt8TypeInContext(e->llvm_context), s.main_ex_back(0), &num_bytes, 1, "");
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif_opaque_ptr, 0, iresult);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		auto bytes = s.main_data_back(1);
		auto pval = s.main_data_back(0);
		uint8_t* ptr = (uint8_t*)pval;
		pval += bytes;
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif_opaque_ptr, (int64_t)pval, 0);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif_opaque_ptr, 0, 0);
	}

	return p + 2;
}

inline int32_t* allocate_buffer(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto iresult = LLVMBuildArrayMalloc(e->llvm_builder, LLVMInt8TypeInContext(e->llvm_context), s.main_ex_back(0), "");
		LLVMBuildMemSet(e->llvm_builder, iresult, LLVMConstInt(LLVMInt8TypeInContext(e->llvm_context), 0, false), s.main_ex_back(0), 1);
		s.pop_main();
		s.push_back_main(fif_opaque_ptr, 0, iresult);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {

		auto bytes = s.main_data_back(0);
		auto val = malloc(size_t(bytes));
		memset(val, 0, size_t(bytes));
		s.pop_main();
		s.push_back_main(fif_opaque_ptr, (int64_t)val, 0);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.push_back_main(fif_opaque_ptr, 0, 0);
	}
	return p + 2;
}

inline int32_t* copy_buffer(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto bytes = s.main_ex_back(0);
		auto dest_ptr = s.main_ex_back(1);
		auto source_ptr = s.main_ex_back(2);
		s.pop_main();
		s.pop_main();
		s.pop_main();
		auto res = LLVMBuildMemCpy(e->llvm_builder, dest_ptr, 1, source_ptr, 1, bytes);
		s.push_back_main(fif_opaque_ptr, 0, dest_ptr);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		auto bytes = s.main_data_back(0);
		auto dest_ptr = s.main_data_back(1);
		auto source_ptr = s.main_data_back(2);
		s.pop_main();
		s.pop_main();
		s.pop_main();
		memcpy((void*)dest_ptr, (void*)source_ptr, size_t(bytes));
		s.push_back_main(fif_opaque_ptr, dest_ptr, 0);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.pop_main();
		s.pop_main();
		s.push_back_main(fif_opaque_ptr, 0, 0);
	}
	return p + 2;
}

inline int32_t* free_buffer(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(fif::typechecking_failed(e->mode))
		return p + 2;

	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		LLVMBuildFree(e->llvm_builder, s.main_ex_back(0));
		s.pop_main();
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		auto a = s.main_data_back(0);
		void* ptr = (void*)a;
		free(ptr);
		s.pop_main();
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
	}
	return p + 2;
}

inline int32_t* do_let_creation(fif::state_stack& s, int32_t* p, fif::environment* e) {
	char* string_ptr = nullptr;
	memcpy(&string_ptr, p + 2, 8);

	auto l = e->compiler_stack.back()->create_let(std::string{ string_ptr }, s.main_type_back(0), s.main_data_back(0), nullptr);
	if(!l) {
		e->report_error("could not create a let with that name");
		e->mode = fif_mode::error;
		return nullptr;
	}
	s.pop_main();
	return p + 4;
}

inline int32_t* create_let(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->source_stack.empty()) {
		e->report_error("let was unable to read the declaration name");
		e->mode = fif_mode::error;
		return nullptr;
	}
	auto name = read_token(e->source_stack.back(), *e);

	if(e->mode == fif_mode::interpreting || (typechecking_mode(e->mode) && !typechecking_failed(e->mode))) {
		auto l = e->compiler_stack.back()->create_let(std::string{ name.content }, s.main_type_back(0), s.main_data_back(0), nullptr);
		if(!l) {
			e->report_error("could not create a let with that name");
			e->mode = fif_mode::error;
			return nullptr;
		}
	} else if(e->mode == fif_mode::compiling_llvm) {
		auto l = e->compiler_stack.back()->create_let(std::string{ name.content }, s.main_type_back(0), 0, s.main_ex_back(0));
		if(!l) {
			e->report_error("could not create a let with that name");
			e->mode = fif_mode::error;
			return nullptr;
		}
	} else if(e->mode == fif_mode::compiling_bytecode) {
		auto l = e->compiler_stack.back()->create_let(std::string{ name.content }, s.main_type_back(0), 0, 0);
		if(!l) {
			e->report_error("could not create a let with that name");
			e->mode = fif_mode::error;
			return nullptr;
		}
		auto compile_bytes = e->compiler_stack.back()->bytecode_compilation_progress();
		if(compile_bytes) {
			fif_call imm = do_let_creation;
			uint64_t imm_bytes = 0;
			memcpy(&imm_bytes, &imm, 8);
			compile_bytes->push_back(int32_t(imm_bytes & 0xFFFFFFFF));
			compile_bytes->push_back(int32_t((imm_bytes >> 32) & 0xFFFFFFFF));

			auto string_constant = e->get_string_constant(name.content);
			char const* cptr = string_constant.data();
			uint64_t let_addr = 0;
			memcpy(&let_addr, &cptr, 8);
			compile_bytes->push_back(int32_t(let_addr & 0xFFFFFFFF));
			compile_bytes->push_back(int32_t((let_addr >> 32) & 0xFFFFFFFF));
		}
	}

	if(!typechecking_failed(e->mode)) {
		s.pop_main();
	}
	return p + 2;
}

inline int32_t* do_var_creation(fif::state_stack& s, int32_t* p, fif::environment* e) {
	char* string_ptr = nullptr;
	memcpy(&string_ptr, p + 2, 8);

	auto l = e->compiler_stack.back()->create_var(std::string{ string_ptr }, s.main_type_back(0));
	if(!l) {
		e->report_error("could not create a var with that name");
		e->mode = fif_mode::error;
		return nullptr;
	}
	l->data = s.main_data_back(0);
	s.pop_main();
	return p + 4;
}

inline int32_t* create_var(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->source_stack.empty()) {
		e->report_error("war was unable to read the declaration name");
		e->mode = fif_mode::error;
		return nullptr;
	}
	auto name = read_token(e->source_stack.back(), *e);

	if(e->mode == fif_mode::interpreting || (typechecking_mode(e->mode) && !typechecking_failed(e->mode))) {
		auto l = e->compiler_stack.back()->create_var(std::string{ name.content }, s.main_type_back(0));
		if(!l) {
			e->report_error("could not create a var with that name");
			e->mode = fif_mode::error;
			return nullptr;
		}
		l->data = s.main_data_back(0);
	} else if(e->mode == fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto l = e->compiler_stack.back()->create_var(std::string{ name.content }, s.main_type_back(0));
		if(!l) {
			e->report_error("could not create a var with that name");
			e->mode = fif_mode::error;
			return nullptr;
		}
		LLVMBuildStore(e->llvm_builder, s.main_ex_back(0), l->alloc);
#endif
	} else if(e->mode == fif_mode::compiling_bytecode) {
		auto l = e->compiler_stack.back()->create_var(std::string{ name.content }, s.main_type_back(0));
		if(!l) {
			e->report_error("could not create a var with that name");
			e->mode = fif_mode::error;
			return nullptr;
		}
		auto compile_bytes = e->compiler_stack.back()->bytecode_compilation_progress();
		if(compile_bytes) {
			fif_call imm = do_var_creation;
			uint64_t imm_bytes = 0;
			memcpy(&imm_bytes, &imm, 8);
			compile_bytes->push_back(int32_t(imm_bytes & 0xFFFFFFFF));
			compile_bytes->push_back(int32_t((imm_bytes >> 32) & 0xFFFFFFFF));

			auto string_constant = e->get_string_constant(name.content);
			char const* cptr = string_constant.data();
			uint64_t let_addr = 0;
			memcpy(&let_addr, &cptr, 8);
			compile_bytes->push_back(int32_t(let_addr & 0xFFFFFFFF));
			compile_bytes->push_back(int32_t((let_addr >> 32) & 0xFFFFFFFF));
		}
	}

	if(!typechecking_failed(e->mode)) {
		s.pop_main();
	}
	return p + 2;
}

inline int32_t* create_global_impl(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->source_stack.empty()) {
		e->report_error("global was unable to read the declaration name");
		e->mode = fif_mode::error;
		return nullptr;
	}
	auto name = read_token(e->source_stack.back(), *e);
	auto type = s.main_data_back(0);

	if(typechecking_mode(e->mode)) {
		if(!typechecking_failed(e->mode))
			s.pop_main();
		return p + 2;
	}

	s.pop_main();
	for(auto& ptr : e->compiler_stack) {
		if(ptr->get_type() == control_structure::globals) {
			auto existing = static_cast<compiler_globals_layer*>(ptr.get())->get_global_var(std::string{ name.content });

			if(existing) {
				e->report_error("duplicate global definition");
				e->mode = fif_mode::error;
				return nullptr;
			}

			static_cast<compiler_globals_layer*>(ptr.get())->create_global_var(std::string{ name.content }, int32_t(type));
			return p + 2;
		}
	}

	e->report_error("could not find the globals layer");
	e->mode = fif_mode::error;
	return nullptr;
}

inline int32_t* do_fextract(fif::state_stack& s, int32_t* p, fif::environment* e) {
	int32_t index_value = *(p + 2);
	auto stype = s.main_type_back(0);
	assert(1 + index_value < e->dict.type_array[stype].decomposed_types_count);
	auto child_index = e->dict.type_array[stype].decomposed_types_start + 1 + index_value;
	auto child_type = e->dict.all_stack_types[child_index];

	if(e->dict.type_array[stype].single_member_struct()) {
		s.mark_used_from_main(1);
		s.set_main_type_back(0, child_type);
	} else {
		auto ptr = s.main_data_back(0);
		auto children = (int64_t*)(ptr);
		auto child_data = children[index_value];

		if(e->dict.type_array[child_type].flags != 0) {
			s.push_back_main(child_type, child_data, nullptr);
			execute_fif_word(fif::parse_result{ "dup", false }, *e, false);
			child_data = s.main_data_back(0);
			s.pop_main();
			s.pop_main();
		}

		if(e->dict.type_array[stype].flags != 0) {
			execute_fif_word(fif::parse_result{ "drop", false }, *e, false);
		} else {
			s.pop_main();
		}

		s.push_back_main(child_type, child_data, nullptr);
	}

	return p + 3;
}

inline int32_t* forth_extract(fif::state_stack& s, int32_t* p, fif::environment* e) {
	auto index_str = read_token(e->source_stack.back(), *e);
	auto index_value = parse_int(index_str.content);
	auto stype = s.main_type_back(0);

	if(stype == -1 || e->dict.type_array[stype].refcounted_type() == false) {
		e->report_error("attempted to use a structure operation on a non-structure type");
		e->mode = fif_mode::error;
		return nullptr;
	}

	assert(1 + index_value < e->dict.type_array[stype].decomposed_types_count);
	auto child_index = e->dict.type_array[stype].decomposed_types_start + 1 + index_value;
	auto child_type = e->dict.all_stack_types[child_index];

	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		if(e->dict.type_array[stype].single_member_struct()) {
			s.mark_used_from_main(1);
			s.set_main_type_back(0, child_type);
		} else {
			auto struct_expr = s.main_ex_back(0);
			auto result = LLVMBuildExtractValue(e->llvm_builder, struct_expr, index_value, "");

			if(e->dict.type_array[child_type].flags != 0) {
				s.push_back_main(child_type, 0, result);
				execute_fif_word(fif::parse_result{ "dup", false }, *e, false);
				result = s.main_ex_back(0);
				s.pop_main();
				s.pop_main();
			}
			if(e->dict.type_array[stype].flags != 0) {
				execute_fif_word(fif::parse_result{ "drop", false }, *e, false);
			} else {
				s.pop_main();
			}
			s.push_back_main(child_type, 0, result);
		}
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		if(e->dict.type_array[stype].single_member_struct()) {
			s.mark_used_from_main(1);
			s.set_main_type_back(0, child_type);
		} else {
			auto ptr = s.main_data_back(0);
			auto children = (int64_t*)(ptr);
			auto child_data = children[index_value];


			if(e->dict.type_array[child_type].flags != 0) {
				s.push_back_main(child_type, child_data, nullptr);
				execute_fif_word(fif::parse_result{ "dup", false }, *e, false);
				child_data = s.main_data_back(0);
				s.pop_main();
				s.pop_main();
			}

			if(e->dict.type_array[stype].flags != 0) {
				execute_fif_word(fif::parse_result{ "drop", false }, *e, false);
			} else {
				s.pop_main();
			}

			s.push_back_main(child_type, child_data, nullptr);
		}
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.push_back_main(child_type, 0, nullptr);
	} else if(e->mode == fif_mode::compiling_bytecode) {
		auto compile_bytes = e->compiler_stack.back()->bytecode_compilation_progress();
		if(compile_bytes) {
			fif_call imm = do_fextract;
			uint64_t imm_bytes = 0;
			memcpy(&imm_bytes, &imm, 8);
			compile_bytes->push_back(int32_t(imm_bytes & 0xFFFFFFFF));
			compile_bytes->push_back(int32_t((imm_bytes >> 32) & 0xFFFFFFFF));
			compile_bytes->push_back(index_value);
		}
		s.pop_main();
		s.push_back_main(child_type, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* do_fextractc(fif::state_stack& s, int32_t* p, fif::environment* e) {
	int32_t index_value = *(p + 2);
	auto stype = s.main_type_back(0);
	assert(1 + index_value < e->dict.type_array[stype].decomposed_types_count);
	auto child_index = e->dict.type_array[stype].decomposed_types_start + 1 + index_value;
	auto child_type = e->dict.all_stack_types[child_index];

	if(e->dict.type_array[stype].single_member_struct()) {
		s.mark_used_from_main(1);
		s.set_main_type_back(0, child_type);
		execute_fif_word(fif::parse_result{ "dup", false }, *e, false);
		s.set_main_type_back(1, stype);
	} else {
		auto ptr = s.main_data_back(0);
		auto children = (int64_t*)(ptr);
		auto child_data = children[index_value];

		if(e->dict.type_array[child_type].flags != 0) {
			s.push_back_main(child_type, child_data, nullptr);
			execute_fif_word(fif::parse_result{ "dup", false }, *e, false);
			child_data = s.main_data_back(0);
			s.pop_main();
			s.pop_main();
		}

		s.mark_used_from_main(1);
		s.push_back_main(child_type, child_data, nullptr);
	}
	return p + 3;
}

inline int32_t* forth_extract_copy(fif::state_stack& s, int32_t* p, fif::environment* e) {
	auto index_str = read_token(e->source_stack.back(), *e);
	auto index_value = parse_int(index_str.content);
	auto stype = s.main_type_back(0);

	if(stype == -1 || e->dict.type_array[stype].refcounted_type() == false) {
		e->report_error("attempted to use a structure operation on a non-structure type");
		e->mode = fif_mode::error;
		return nullptr;
	}

	assert(1 + index_value < e->dict.type_array[stype].decomposed_types_count);
	auto child_index = e->dict.type_array[stype].decomposed_types_start + 1 + index_value;
	auto child_type = e->dict.all_stack_types[child_index];

	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		if(e->dict.type_array[stype].single_member_struct()) {
			s.mark_used_from_main(1);
			s.set_main_type_back(0, child_type);
			execute_fif_word(fif::parse_result{ "dup", false }, *e, false);
			s.set_main_type_back(1, stype);
		} else {
			auto struct_expr = s.main_ex_back(0);
			auto result = LLVMBuildExtractValue(e->llvm_builder, struct_expr, index_value, "");
			s.mark_used_from_main(1);

			if(e->dict.type_array[child_type].flags != 0) {
				s.push_back_main(child_type, 0, result);
				execute_fif_word(fif::parse_result{ "dup", false }, *e, false);
				result = s.main_ex_back(0);
				s.pop_main();
				s.pop_main();
			}
			s.push_back_main(child_type, 0, result);
		}
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		if(e->dict.type_array[stype].single_member_struct()) {
			s.mark_used_from_main(1);
			s.set_main_type_back(0, child_type);
			execute_fif_word(fif::parse_result{ "dup", false }, *e, false);
			s.set_main_type_back(1, stype);
		} else {
			auto ptr = s.main_data_back(0);
			auto children = (int64_t*)(ptr);
			auto child_data = children[index_value];
			s.mark_used_from_main(1);

			if(e->dict.type_array[child_type].flags != 0) {
				s.push_back_main(child_type, child_data, nullptr);
				execute_fif_word(fif::parse_result{ "dup", false }, *e, false);
				child_data = s.main_data_back(0);
				s.pop_main();
				s.pop_main();
			}

			s.push_back_main(child_type, child_data, nullptr);
		}
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.mark_used_from_main(1);
		s.push_back_main(child_type, 0, nullptr);
	} else if(e->mode == fif_mode::compiling_bytecode) {
		auto compile_bytes = e->compiler_stack.back()->bytecode_compilation_progress();
		if(compile_bytes) {
			fif_call imm = do_fextractc;
			uint64_t imm_bytes = 0;
			memcpy(&imm_bytes, &imm, 8);
			compile_bytes->push_back(int32_t(imm_bytes & 0xFFFFFFFF));
			compile_bytes->push_back(int32_t((imm_bytes >> 32) & 0xFFFFFFFF));
			compile_bytes->push_back(index_value);
		}
		s.mark_used_from_main(1);
		s.push_back_main(child_type, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* do_finsert(fif::state_stack& s, int32_t* p, fif::environment* e) {
	int32_t index_value = *(p + 2);
	auto stype = s.main_type_back(0);
	assert(1 + index_value < e->dict.type_array[stype].decomposed_types_count);
	auto child_index = e->dict.type_array[stype].decomposed_types_start + 1 + index_value;
	auto child_type = e->dict.all_stack_types[child_index];

	if(e->dict.type_array[stype].single_member_struct()) {
		s.mark_used_from_main(2);
		s.set_main_type_back(0, child_type);
		execute_fif_word(fif::parse_result{ "drop", false }, *e, false);
		s.set_main_type_back(0, stype);
	} else {
		auto ptr = s.main_data_back(0);
		auto children = (int64_t*)(ptr);

		if(e->dict.type_array[child_type].flags != 0) {
			s.push_back_main(child_type, children[index_value], 0);
			execute_fif_word(fif::parse_result{ "drop", false }, *e, false);
		}
		s.pop_main();
		children[index_value] = s.main_data_back(0);
		s.pop_main();

		s.push_back_main(stype, ptr, 0);
	}
	return p + 3;
}

inline int32_t* forth_insert(fif::state_stack& s, int32_t* p, fif::environment* e) {
	auto index_str = read_token(e->source_stack.back(), *e);
	auto index_value = parse_int(index_str.content);
	auto stype = s.main_type_back(0);

	if(stype == -1 || e->dict.type_array[stype].refcounted_type() == false) {
		e->report_error("attempted to use a structure operation on a non-structure type");
		e->mode = fif_mode::error;
		return nullptr;
	}

	assert(1 + index_value < e->dict.type_array[stype].decomposed_types_count);
	auto child_index = e->dict.type_array[stype].decomposed_types_start + 1 + index_value;
	auto child_type = e->dict.all_stack_types[child_index];

	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		if(e->dict.type_array[stype].single_member_struct()) {
			s.mark_used_from_main(2);
			s.set_main_type_back(0, child_type);
			execute_fif_word(fif::parse_result{ "drop", false }, *e, false);
			s.set_main_type_back(0, stype);
		} else {
			auto struct_expr = s.main_ex_back(0);

			if(e->dict.type_array[child_type].flags != 0) {
				auto oldv = LLVMBuildExtractValue(e->llvm_builder, struct_expr, index_value, "");
				s.push_back_main(child_type, 0, oldv);
				execute_fif_word(fif::parse_result{ "drop", false }, *e, false);
			}

			s.pop_main();
			struct_expr = LLVMBuildInsertValue(e->llvm_builder, struct_expr, s.main_ex_back(0), index_value, "");
			s.pop_main();
			s.push_back_main(stype, 0, struct_expr);
		}
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		if(e->dict.type_array[stype].single_member_struct()) {
			s.mark_used_from_main(2);
			s.set_main_type_back(0, child_type);
			execute_fif_word(fif::parse_result{ "drop", false }, *e, false);
			s.set_main_type_back(0, stype);
		} else {
			auto ptr = s.main_data_back(0);
			auto children = (int64_t*)(ptr);

			if(e->dict.type_array[child_type].flags != 0) {
				s.push_back_main(child_type, children[index_value], 0);
				execute_fif_word(fif::parse_result{ "drop", false }, *e, false);
			}
			s.pop_main();
			children[index_value] = s.main_data_back(0);
			s.pop_main();

			s.push_back_main(stype, ptr, 0);
		}
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.pop_main();
		s.push_back_main(stype, 0, nullptr);
	} else if(e->mode == fif_mode::compiling_bytecode) {
		auto compile_bytes = e->compiler_stack.back()->bytecode_compilation_progress();
		if(compile_bytes) {
			fif_call imm = do_finsert;
			uint64_t imm_bytes = 0;
			memcpy(&imm_bytes, &imm, 8);
			compile_bytes->push_back(int32_t(imm_bytes & 0xFFFFFFFF));
			compile_bytes->push_back(int32_t((imm_bytes >> 32) & 0xFFFFFFFF));
			compile_bytes->push_back(index_value);
		}
		s.pop_main();
		s.pop_main();
		s.push_back_main(stype, 0, nullptr);
	}
	return p + 2;
}

inline int32_t* do_fgep(fif::state_stack& s, int32_t* p, fif::environment* e) {
	int32_t index_value = *(p + 2);
	auto ptr_type = s.main_type_back(0);

	if(ptr_type == -1) {
		e->report_error("attempted to use a pointer operation on a non-pointer type");
		e->mode = fif_mode::error;
		return nullptr;
	}
	auto decomp = e->dict.type_array[ptr_type].decomposed_types_start;
	if(e->dict.type_array[ptr_type].decomposed_types_count == 0 || e->dict.all_stack_types[e->dict.type_array[ptr_type].decomposed_types_start] != fif_ptr) {
		e->report_error("attempted to use a struct-pointer operation on a non-struct-pointer type");
		e->mode = fif_mode::error;
		return nullptr;
	}
	auto stype = e->dict.all_stack_types[decomp + 1];

	assert(1 + index_value < e->dict.type_array[stype].decomposed_types_count);
	auto child_index = e->dict.type_array[stype].decomposed_types_start + 1 + index_value;
	auto child_type = e->dict.all_stack_types[child_index];

	if(e->dict.type_array[stype].single_member_struct()) {
		int32_t type_storage[] = { fif_ptr, std::numeric_limits<int32_t>::max(), child_type, -1 };
		std::vector<int32_t> subs;
		auto child_ptr_type = resolve_span_type(std::span<int32_t const>(type_storage, type_storage + 4), subs, *e);

		s.mark_used_from_main(1);
		s.set_main_type_back(0, child_ptr_type.type);
	} else {
		auto ptr = s.main_data_back(0);
		auto children = (int64_t*)(ptr);
		auto child_ptr = children + index_value;

		int32_t type_storage[] = { fif_ptr, std::numeric_limits<int32_t>::max(), child_type, -1 };
		std::vector<int32_t> subs;
		auto child_ptr_type = resolve_span_type(std::span<int32_t const>(type_storage, type_storage + 4), subs, *e);

		s.pop_main();
		s.push_back_main(child_ptr_type.type, (int64_t)child_ptr, 0);
	}
	return p + 3;
}

inline int32_t* forth_gep(fif::state_stack& s, int32_t* p, fif::environment* e) {
	auto index_str = read_token(e->source_stack.back(), *e);
	auto index_value = parse_int(index_str.content);
	auto ptr_type = s.main_type_back(0);

	if(ptr_type == -1) {
		e->report_error("attempted to use a pointer operation on a non-pointer type");
		e->mode = fif_mode::error;
		return nullptr;
	}

	auto decomp = e->dict.type_array[ptr_type].decomposed_types_start;

	if(e->dict.type_array[ptr_type].decomposed_types_count == 0 || e->dict.all_stack_types[e->dict.type_array[ptr_type].decomposed_types_start] != fif_ptr) {
		e->report_error("attempted to use a struct-pointer operation on a non-struct-pointer type");
		e->mode = fif_mode::error;
		return nullptr;
	}

	auto stype = e->dict.all_stack_types[decomp + 1];

	if(stype == -1 || e->dict.type_array[stype].refcounted_type() == false) {
		e->report_error("attempted to use a structure operation on a non-structure type");
		e->mode = fif_mode::error;
		return nullptr;
	}

	assert(1 + index_value < e->dict.type_array[stype].decomposed_types_count);
	auto child_index = e->dict.type_array[stype].decomposed_types_start + 1 + index_value;
	auto child_type = e->dict.all_stack_types[child_index];

	int32_t type_storage[] = { fif_ptr, std::numeric_limits<int32_t>::max(), child_type, -1 };
	std::vector<int32_t> subs;
	auto child_ptr_type = resolve_span_type(std::span<int32_t const>(type_storage, type_storage + 4), subs, *e);

	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		if(e->dict.type_array[stype].single_member_struct()) {
			s.mark_used_from_main(1);
			s.set_main_type_back(0, child_ptr_type.type);
		} else {
			auto struct_expr = s.main_ex_back(0);
			auto ptr_expr = LLVMBuildStructGEP2(e->llvm_builder, e->dict.type_array[stype].llvm_type, struct_expr, uint32_t(index_value), "");
			s.pop_main();
			s.push_back_main(child_ptr_type.type, 0, ptr_expr);
		}
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		if(e->dict.type_array[stype].single_member_struct()) {
			s.mark_used_from_main(1);
			s.set_main_type_back(0, child_ptr_type.type);
		} else {
			auto ptr = s.main_data_back(0);
			auto children = (int64_t*)(ptr);
			auto child_ptr = children + index_value;

			s.pop_main();
			s.push_back_main(child_ptr_type.type, (int64_t)child_ptr, 0);
		}
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.push_back_main(child_ptr_type.type, 0, nullptr);
	} else if(e->mode == fif_mode::compiling_bytecode) {
		auto compile_bytes = e->compiler_stack.back()->bytecode_compilation_progress();
		if(compile_bytes) {
			fif_call imm = do_fgep;
			uint64_t imm_bytes = 0;
			memcpy(&imm_bytes, &imm, 8);
			compile_bytes->push_back(int32_t(imm_bytes & 0xFFFFFFFF));
			compile_bytes->push_back(int32_t((imm_bytes >> 32) & 0xFFFFFFFF));
			compile_bytes->push_back(index_value);
		}
		s.pop_main();
		s.push_back_main(child_ptr_type.type, 0, nullptr);
	}
	return p + 2;
}

inline int32_t* do_fsmz(fif::state_stack& s, int32_t* p, fif::environment* e) {
	char* command = nullptr;
	memcpy(&command, p + 2, 8);

	auto stype = s.main_type_back(0);

	if(e->dict.type_array[stype].single_member_struct()) {
		auto child_index = e->dict.type_array[stype].decomposed_types_start + 1;
		auto child_type = e->dict.all_stack_types[child_index];

		s.mark_used_from_main(1);
		s.set_main_type_back(0, child_type);
		execute_fif_word(parse_result{ std::string_view{ command }, false }, *e, false);
	} else {
		auto children_count = struct_child_count(stype, *e);
		auto ptr = s.main_data_back(0);
		auto children = (int64_t*)(ptr);

		for(int32_t i = 0; i < children_count; ++i) {
			auto child_index = e->dict.type_array[stype].decomposed_types_start + 1 + i;
			auto child_type = e->dict.all_stack_types[child_index];
			s.push_back_main(child_type, children[i], nullptr);
			execute_fif_word(parse_result{ std::string_view{ command }, false }, *e, false);
		}

		free(children);
		s.pop_main();
	}
	return p + 4;
}

inline int32_t* forth_struct_map_zero(fif::state_stack& s, int32_t* p, fif::environment* e) {
	auto mapped_function = read_token(e->source_stack.back(), *e);
	auto stype = s.main_type_back(0);
	auto children_count = struct_child_count(stype, *e);


	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		if(e->dict.type_array[stype].single_member_struct()) {
			auto child_index = e->dict.type_array[stype].decomposed_types_start + 1;
			auto child_type = e->dict.all_stack_types[child_index];

			s.mark_used_from_main(1);
			s.set_main_type_back(0, child_type);
			execute_fif_word(mapped_function, *e, false);
		} else {
			auto struct_expr = s.main_ex_back(0);

			for(int32_t i = 0; i < children_count; ++i) {
				auto child_index = e->dict.type_array[stype].decomposed_types_start + 1 + i;
				auto child_type = e->dict.all_stack_types[child_index];
				s.push_back_main(child_type, 0, LLVMBuildExtractValue(e->llvm_builder, struct_expr, uint32_t(i), ""));
				execute_fif_word(mapped_function, *e, false);
			}

			s.pop_main();
		}
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		if(e->dict.type_array[stype].single_member_struct()) {
			auto child_index = e->dict.type_array[stype].decomposed_types_start + 1;
			auto child_type = e->dict.all_stack_types[child_index];

			s.mark_used_from_main(1);
			s.set_main_type_back(0, child_type);
			execute_fif_word(mapped_function, *e, false);
		} else {
			auto ptr = s.main_data_back(0);
			auto children = (int64_t*)(ptr);

			for(int32_t i = 0; i < children_count; ++i) {
				auto child_index = e->dict.type_array[stype].decomposed_types_start + 1 + i;
				auto child_type = e->dict.all_stack_types[child_index];
				s.push_back_main(child_type, children[i], nullptr);
				execute_fif_word(mapped_function, *e, false);
			}
			free(children);
			s.pop_main();
		}
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
	} else if(e->mode == fif_mode::compiling_bytecode) {
		auto compile_bytes = e->compiler_stack.back()->bytecode_compilation_progress();
		if(compile_bytes) {
			{
				fif_call imm = do_fsmz;
				uint64_t imm_bytes = 0;
				memcpy(&imm_bytes, &imm, 8);
				compile_bytes->push_back(int32_t(imm_bytes & 0xFFFFFFFF));
				compile_bytes->push_back(int32_t((imm_bytes >> 32) & 0xFFFFFFFF));
			}
			{
				auto str_const = e->get_string_constant(mapped_function.content).data();
				uint64_t imm_bytes = 0;
				memcpy(&imm_bytes, &str_const, 8);
				compile_bytes->push_back(int32_t(imm_bytes & 0xFFFFFFFF));
				compile_bytes->push_back(int32_t((imm_bytes >> 32) & 0xFFFFFFFF));
			}
		}
		s.pop_main();
	}
	return p + 2;
}

inline int32_t* do_fsmo(fif::state_stack& s, int32_t* p, fif::environment* e) {
	char* command = nullptr;
	memcpy(&command, p + 2, 8);

	auto stype = s.main_type_back(0);

	if(e->dict.type_array[stype].single_member_struct()) {
		auto child_index = e->dict.type_array[stype].decomposed_types_start + 1 + 0;
		auto child_type = e->dict.all_stack_types[child_index];
		s.set_main_type_back(0, child_type);
		execute_fif_word(parse_result{ std::string_view{ command }, false }, *e, false);
		s.set_main_type_back(0, stype);
	} else {
		auto children_count = struct_child_count(stype, *e);
		auto ptr = s.main_data_back(0);
		auto children = (int64_t*)(ptr);

		for(int32_t i = 0; i < children_count; ++i) {
			auto child_index = e->dict.type_array[stype].decomposed_types_start + 1 + i;
			auto child_type = e->dict.all_stack_types[child_index];
			s.push_back_main(child_type, children[i], nullptr);
			execute_fif_word(parse_result{ std::string_view{ command }, false }, *e, false);
			children[i] = s.main_data_back(0);
			s.pop_main();
		}
	}

	s.mark_used_from_main(1);
	return p + 4;
}
inline int32_t* forth_struct_map_one(fif::state_stack& s, int32_t* p, fif::environment* e) {
	auto mapped_function = read_token(e->source_stack.back(), *e);
	auto stype = s.main_type_back(0);
	auto children_count = struct_child_count(stype, *e);


	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		if(e->dict.type_array[stype].single_member_struct()) {
			assert(children_count == 1);
			auto child_index = e->dict.type_array[stype].decomposed_types_start + 1 + 0;
			auto child_type = e->dict.all_stack_types[child_index];
			s.set_main_type_back(0, child_type);
			execute_fif_word(mapped_function, *e, false);
			s.set_main_type_back(0, stype);
		} else {
			auto struct_expr = s.main_ex_back(0);

			for(int32_t i = 0; i < children_count; ++i) {
				auto child_index = e->dict.type_array[stype].decomposed_types_start + 1 + i;
				auto child_type = e->dict.all_stack_types[child_index];
				s.push_back_main(child_type, 0, LLVMBuildExtractValue(e->llvm_builder, struct_expr, uint32_t(i), ""));
				execute_fif_word(mapped_function, *e, false);
				struct_expr = LLVMBuildInsertValue(e->llvm_builder, struct_expr, s.main_ex_back(0), uint32_t(i), "");
				s.pop_main();
			}
			s.set_main_ex_back(0, struct_expr);
		}
		s.mark_used_from_main(1);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		if(e->dict.type_array[stype].single_member_struct()) {
			auto child_index = e->dict.type_array[stype].decomposed_types_start + 1 + 0;
			auto child_type = e->dict.all_stack_types[child_index];
			s.set_main_type_back(0, child_type);
			execute_fif_word(mapped_function, *e, false);
			s.set_main_type_back(0, stype);
		} else {
			auto ptr = s.main_data_back(0);
			auto children = (int64_t*)(ptr);

			for(int32_t i = 0; i < children_count; ++i) {
				auto child_index = e->dict.type_array[stype].decomposed_types_start + 1 + i;
				auto child_type = e->dict.all_stack_types[child_index];
				s.push_back_main(child_type, children[i], nullptr);
				execute_fif_word(mapped_function, *e, false);

				children[i] = s.main_data_back(0);

				s.pop_main();
			}
		}
		s.mark_used_from_main(1);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.mark_used_from_main(1);
	} else if(e->mode == fif_mode::compiling_bytecode) {
		auto compile_bytes = e->compiler_stack.back()->bytecode_compilation_progress();
		if(compile_bytes) {
			{
				fif_call imm = do_fsmo;
				uint64_t imm_bytes = 0;
				memcpy(&imm_bytes, &imm, 8);
				compile_bytes->push_back(int32_t(imm_bytes & 0xFFFFFFFF));
				compile_bytes->push_back(int32_t((imm_bytes >> 32) & 0xFFFFFFFF));
			}
			{
				auto str_const = e->get_string_constant(mapped_function.content).data();
				uint64_t imm_bytes = 0;
				memcpy(&imm_bytes, &str_const, 8);
				compile_bytes->push_back(int32_t(imm_bytes & 0xFFFFFFFF));
				compile_bytes->push_back(int32_t((imm_bytes >> 32) & 0xFFFFFFFF));
			}
		}
		s.mark_used_from_main(1);
	}
	return p + 2;
}
inline int32_t* do_fsmt(fif::state_stack& s, int32_t* p, fif::environment* e) {
	char* command = nullptr;
	memcpy(&command, p + 2, 8);

	auto stype = s.main_type_back(0);

	if(e->dict.type_array[stype].single_member_struct()) {
		s.mark_used_from_main(1);
		auto child_index = e->dict.type_array[stype].decomposed_types_start + 1 + 0;
		auto child_type = e->dict.all_stack_types[child_index];
		s.set_main_type_back(0, child_type);
		execute_fif_word(parse_result{ std::string_view{ command }, false }, *e, false);
		s.set_main_type_back(0, stype);
		s.set_main_type_back(1, stype);
	} else {
		auto children_count = struct_child_count(stype, *e);
		auto ptr = s.main_data_back(0);
		auto new_ptr = e->dict.type_array[stype].interpreter_zero(stype, e);

		auto children = (int64_t*)(ptr);
		auto new_children = (int64_t*)(new_ptr);

		for(int32_t i = 0; i < children_count; ++i) {
			auto child_index = e->dict.type_array[stype].decomposed_types_start + 1 + i;
			auto child_type = e->dict.all_stack_types[child_index];
			s.push_back_main(child_type, children[i], nullptr);
			execute_fif_word(parse_result{ std::string_view{ command }, false }, *e, false);

			new_children[i] = s.main_data_back(0);

			s.pop_main();
			s.pop_main();
		}

		s.mark_used_from_main(1);
		s.push_back_main(stype, new_ptr, nullptr);
	}
	return p + 4;
}
inline int32_t* forth_struct_map_two(fif::state_stack& s, int32_t* p, fif::environment* e) {
	auto mapped_function = read_token(e->source_stack.back(), *e);
	auto stype = s.main_type_back(0);
	auto children_count = struct_child_count(stype, *e);


	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		if(e->dict.type_array[stype].single_member_struct()) {
			s.mark_used_from_main(1);
			auto child_index = e->dict.type_array[stype].decomposed_types_start + 1 + 0;
			auto child_type = e->dict.all_stack_types[child_index];
			s.set_main_type_back(0, child_type);
			execute_fif_word(mapped_function, *e, false);
			s.set_main_type_back(0, stype);
			s.set_main_type_back(1, stype);
		} else {
			auto struct_expr = s.main_ex_back(0);
			auto new_struct_expr = e->dict.type_array[stype].zero_constant(e->llvm_context, stype, e);

			for(int32_t i = 0; i < children_count; ++i) {
				auto child_index = e->dict.type_array[stype].decomposed_types_start + 1 + i;
				auto child_type = e->dict.all_stack_types[child_index];
				s.push_back_main(child_type, 0, LLVMBuildExtractValue(e->llvm_builder, struct_expr, uint32_t(i), ""));
				execute_fif_word(mapped_function, *e, false);
				new_struct_expr = LLVMBuildInsertValue(e->llvm_builder, new_struct_expr, s.main_ex_back(0), uint32_t(i), "");
				s.pop_main();
				s.pop_main();
			}
			s.mark_used_from_main(1);
			s.push_back_main(stype, 0, new_struct_expr);
		}
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		if(e->dict.type_array[stype].single_member_struct()) {
			s.mark_used_from_main(1);
			auto child_index = e->dict.type_array[stype].decomposed_types_start + 1 + 0;
			auto child_type = e->dict.all_stack_types[child_index];
			s.set_main_type_back(0, child_type);
			execute_fif_word(mapped_function, *e, false);
			s.set_main_type_back(0, stype);
			s.set_main_type_back(1, stype);
		} else {
			auto ptr = s.main_data_back(0);
			auto new_ptr = e->dict.type_array[stype].interpreter_zero(stype, e);

			auto children = (int64_t*)(ptr);
			auto new_children = (int64_t*)(new_ptr);

			for(int32_t i = 0; i < children_count; ++i) {
				auto child_index = e->dict.type_array[stype].decomposed_types_start + 1 + i;
				auto child_type = e->dict.all_stack_types[child_index];
				s.push_back_main(child_type, children[i], nullptr);
				execute_fif_word(mapped_function, *e, false);


				new_children[i] = s.main_data_back(0);


				s.pop_main();
				s.pop_main();
			}

			s.mark_used_from_main(1);
			s.push_back_main(stype, new_ptr, nullptr);
		}
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.mark_used_from_main(1);
		s.push_back_main(stype, 0, nullptr);
	} else if(e->mode == fif_mode::compiling_bytecode) {
		auto compile_bytes = e->compiler_stack.back()->bytecode_compilation_progress();
		if(compile_bytes) {
			{
				fif_call imm = do_fsmt;
				uint64_t imm_bytes = 0;
				memcpy(&imm_bytes, &imm, 8);
				compile_bytes->push_back(int32_t(imm_bytes & 0xFFFFFFFF));
				compile_bytes->push_back(int32_t((imm_bytes >> 32) & 0xFFFFFFFF));
			}
			{
				auto str_const = e->get_string_constant(mapped_function.content).data();
				uint64_t imm_bytes = 0;
				memcpy(&imm_bytes, &str_const, 8);
				compile_bytes->push_back(int32_t(imm_bytes & 0xFFFFFFFF));
				compile_bytes->push_back(int32_t((imm_bytes >> 32) & 0xFFFFFFFF));
			}
		}
		s.mark_used_from_main(1);
		s.push_back_main(stype, 0, nullptr);
	}
	return p + 2;
}

inline int32_t* type_construction(state_stack& s, int32_t* p, environment* e) {
	auto type = *(p + 2);
	auto is_refcounted = e->dict.type_array[type].refcounted_type();
	s.push_back_main( type, (is_refcounted && e->dict.type_array[type].interpreter_zero) ? e->dict.type_array[type].interpreter_zero(type, e) : 0, nullptr);
	return p + 3;
}
inline int32_t* do_make(state_stack& s, int32_t* p, environment* env) {
	if(env->source_stack.empty()) {
		env->report_error("make was unable to read the word describing the type");
		env->mode = fif_mode::error;
		return nullptr;
	}
	auto type = read_token(env->source_stack.back(), *env);
	
	if(typechecking_failed(env->mode))
		return p + 2;

	auto resolved_type = resolve_type(type.content, *env, env->compiler_stack.back()->type_substitutions());
	
	if(resolved_type == -1) {
		env->report_error("make was unable to resolve the type");
		env->mode = fif_mode::error;
		return nullptr;
	}

	if(typechecking_mode(env->mode)) {
		s.push_back_main(resolved_type, 0, nullptr);
		return p + 2;
	}

	auto compile_bytes = env->compiler_stack.back()->bytecode_compilation_progress();
	if(compile_bytes && env->mode == fif_mode::compiling_bytecode) {
		fif_call imm = type_construction;
		uint64_t imm_bytes = 0;
		memcpy(&imm_bytes, &imm, 8);
		compile_bytes->push_back(int32_t(imm_bytes & 0xFFFFFFFF));
		compile_bytes->push_back(int32_t((imm_bytes >> 32) & 0xFFFFFFFF));
		compile_bytes->push_back(resolved_type);
	}
	LLVMValueRef val = nullptr;
	if(env->mode == fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		if(env->dict.type_array[resolved_type].zero_constant) {
			val = env->dict.type_array[resolved_type].zero_constant(env->llvm_context, resolved_type, env);
		} else {
			env->report_error("attempted to compile a type without an llvm representation");
			env->mode = fif_mode::error;
			return nullptr;
		}
#endif
	}
	int64_t data = 0;
	if(env->mode == fif_mode::interpreting) {
		if(env->dict.type_array[resolved_type].refcounted_type() && env->dict.type_array[resolved_type].interpreter_zero)
			data = env->dict.type_array[resolved_type].interpreter_zero(resolved_type, env);
	}
	s.push_back_main(resolved_type, data, val);
	execute_fif_word(fif::parse_result{ "init", false }, *env, false);

	return p + 2;
}

inline int32_t* struct_definition(fif::state_stack&, int32_t* p, fif::environment* e) {
	if(fif::typechecking_mode(e->mode))
		return p + 2;
	if(e->mode != fif::fif_mode::interpreting) {
		e->report_error("attempted to define a struct inside a definition");
		e->mode = fif::fif_mode::error;
		return nullptr;
	}

	if(e->source_stack.empty()) {
		e->report_error("attempted to define a struct without a source");
		e->mode = fif::fif_mode::error;
		return nullptr;
	}

	auto name_token = fif::read_token(e->source_stack.back(), *e);

	if(e->dict.types.find(std::string(name_token.content)) != e->dict.types.end()) {
		e->report_error("attempted to redefine an existing type");
		e->mode = fif::fif_mode::error;
		return nullptr;
	}

	std::vector<int32_t> stack_types;
	std::vector<std::string_view> names;
	int32_t max_variable = -1;
	bool read_extra_count = false;

	while(true) {
		auto next_token = fif::read_token(e->source_stack.back(), *e);
		if(next_token.content.length() == 0 || next_token.content == ";") {
			break;
		}
		if(next_token.content == "$") {
			read_extra_count = true;
			break;
		}

		auto result = internal_generate_type(next_token.content, *e);
		if(result.type_array.empty()) {
			e->mode = fif_mode::error;
			e->report_error("unable to resolve type from text");
			return nullptr;
		}
		stack_types.insert(stack_types.end(), result.type_array.begin(), result.type_array.end());
		max_variable = std::max(max_variable, result.max_variable);

		auto nnext_token = fif::read_token(e->source_stack.back(), *e);
		if(nnext_token.content.length() == 0 || nnext_token.content == ";") {
			e->report_error("struct contained a type without a matching name");
			e->mode = fif::fif_mode::error;
			return nullptr;
		}
		names.push_back(nnext_token.content);
	}

	int32_t extra_count = 0;
	if(read_extra_count) {
		auto next_token = fif::read_token(e->source_stack.back(), *e);
		auto next_next_token = fif::read_token(e->source_stack.back(), *e);
		if(next_next_token.content != ";") {
			e->report_error("struct definition ended incorrectly");
			e->mode = fif::fif_mode::error;
			return nullptr;
		}
		extra_count = parse_int(next_token.content);
	}

	make_struct_type(name_token.content, std::span<int32_t const>{stack_types.begin(), stack_types.end()}, names, *e, max_variable + 1, extra_count);

	return p + 2;
}
inline int32_t* export_definition(fif::state_stack&, int32_t* p, fif::environment* e) {
	if(fif::typechecking_mode(e->mode))
		return p + 2;
	if(e->mode != fif::fif_mode::interpreting) {
		e->report_error("attempted to define an export inside a definition");
		e->mode = fif::fif_mode::error;
		return nullptr;
	}

	if(e->source_stack.empty()) {
		e->report_error("attempted to define an export without a source");
		e->mode = fif::fif_mode::error;
		return nullptr;
	}

	auto name_token = fif::read_token(e->source_stack.back(), *e);

	std::vector<int32_t> stack_types;
	std::vector<std::string_view> names;
	int32_t max_variable = -1;
	bool read_extra_count = false;

	while(true) {
		auto next_token = fif::read_token(e->source_stack.back(), *e);
		if(next_token.content.length() == 0 || next_token.content == ";") {
			break;
		}
		names.push_back(next_token.content);
	}

	auto fn_to_export = names.back();
	names.pop_back();

	for(auto tyn : names) {
		auto result = resolve_type(tyn, *e, nullptr);
		if(result == -1) {
			e->mode = fif_mode::error;
			e->report_error("unable to resolve type from text");
			return nullptr;
		}
		stack_types.push_back(result);
	}
#ifdef USE_LLVM
	make_exportable_function(std::string(name_token.content), std::string(fn_to_export), stack_types, { }, *e);
#endif
	return p + 2;
}
inline int32_t* do_use_base(state_stack& s, int32_t* p, environment* env) {
	if(env->source_stack.empty()) {
		env->report_error("make was unable to read name of word");
		env->mode = fif_mode::error;
		return nullptr;
	}
	auto type = read_token(env->source_stack.back(), *env);

	if(typechecking_failed(env->mode))
		return p + 2;

	execute_fif_word(type, *env, true);

	return p + 2;
}

inline int32_t* long_comment(fif::state_stack&, int32_t* p, fif::environment* e) {
	if(e->source_stack.empty()) {
		return p + 2;
	}

	int32_t depth = 1;
	while(depth > 0) {
		auto token = fif::read_token(e->source_stack.back(), *e);
		if(token.content == "))" && token.is_string == false)
			--depth;
		if(token.content == "((" && token.is_string == false)
			++depth;
		if(token.content == "" && token.is_string == false)
			break;
	}
	
	return p + 2;
}
inline int32_t* line_comment(fif::state_stack&, int32_t* p, fif::environment* e) {
	if(e->source_stack.empty()) {
		return p + 2;
	}

	std::string_view& source = e->source_stack.back();
	while(source.length() > 0 && source[0] != '\n' && source[0] != '\r')
		source = source.substr(1);

	return p + 2;
}

inline int32_t* zext_i64(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildZExt(e->llvm_builder, s.main_ex_back(0), LLVMInt64TypeInContext(e->llvm_context), "");
		s.pop_main();
		s.push_back_main(fif_i64, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		s.mark_used_from_main(1);
		s.set_main_type_back(0, fif_i64);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.push_back_main(fif::fif_i64, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* zext_i32(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildZExt(e->llvm_builder, s.main_ex_back(0), LLVMInt32TypeInContext(e->llvm_context), "");
		s.pop_main();
		s.push_back_main(fif_i32, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		s.mark_used_from_main(1);
		s.set_main_data_back(0, s.main_data_back(0) & 0x0FFFFFFFF);
		s.set_main_type_back(0, fif_i32);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.push_back_main(fif::fif_i32, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* zext_i16(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildZExt(e->llvm_builder, s.main_ex_back(0), LLVMInt16TypeInContext(e->llvm_context), "");
		s.pop_main();
		s.push_back_main(fif_i16, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		s.mark_used_from_main(1);
		s.set_main_data_back(0, s.main_data_back(0) & 0x0FFFF);
		s.set_main_type_back(0, fif_i16);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.push_back_main(fif::fif_i16, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* zext_i8(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildZExt(e->llvm_builder, s.main_ex_back(0), LLVMInt8TypeInContext(e->llvm_context), "");
		s.pop_main();
		s.push_back_main(fif_i8, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		s.mark_used_from_main(1);
		s.set_main_data_back(0, s.main_data_back(0) & 0x0FF);
		s.set_main_type_back(0, fif_i8);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.push_back_main(fif::fif_i8, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* zext_ui64(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildZExt(e->llvm_builder, s.main_ex_back(0), LLVMInt64TypeInContext(e->llvm_context), "");
		s.pop_main();
		s.push_back_main(fif_u64, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		s.mark_used_from_main(1);
		s.set_main_type_back(0, fif_u64);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.push_back_main(fif::fif_u64, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* zext_ui32(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildZExt(e->llvm_builder, s.main_ex_back(0), LLVMInt32TypeInContext(e->llvm_context), "");
		s.pop_main();
		s.push_back_main(fif_u32, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		s.mark_used_from_main(1);
		s.set_main_data_back(0, s.main_data_back(0) & 0x0FFFFFFFF);
		s.set_main_type_back(0, fif_u32);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.push_back_main(fif::fif_u32, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* zext_ui16(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildZExt(e->llvm_builder, s.main_ex_back(0), LLVMInt16TypeInContext(e->llvm_context), "");
		s.pop_main();
		s.push_back_main(fif_u16, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		s.mark_used_from_main(1);
		s.set_main_data_back(0, s.main_data_back(0) & 0x0FFFF);
		s.set_main_type_back(0, fif_u16);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.push_back_main(fif::fif_u16, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* zext_ui8(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildZExt(e->llvm_builder, s.main_ex_back(0), LLVMInt8TypeInContext(e->llvm_context), "");
		s.pop_main();
		s.push_back_main(fif_u8, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		s.mark_used_from_main(1);
		s.set_main_data_back(0, s.main_data_back(0) & 0x0FF);
		s.set_main_type_back(0, fif_u8);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.push_back_main(fif::fif_u8, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* sext_i64(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildSExt(e->llvm_builder, s.main_ex_back(0), LLVMInt64TypeInContext(e->llvm_context), "");
		s.pop_main();
		s.push_back_main(fif_i64, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		s.mark_used_from_main(1);
		if(s.main_type_back(0) == fif_i8 || s.main_type_back(0) == fif_u8) {
			auto v = int8_t(s.main_data_back(0));
			s.set_main_data_back(0, v);
		} else if(s.main_type_back(0) == fif_i16 || s.main_type_back(0) == fif_u16) {
			auto v = int16_t(s.main_data_back(0));
			s.set_main_data_back(0, v);
		} else if(s.main_type_back(0) == fif_i32 || s.main_type_back(0) == fif_u32) {
			auto v = int32_t(s.main_data_back(0));
			s.set_main_data_back(0, v);
		} if(s.main_type_back(0) == fif_bool) {
			auto v = s.main_data_back(0);
			s.set_main_data_back(0, v != 0 ? -1 : 0);
		}
		s.set_main_type_back(0, fif_i64);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.push_back_main(fif::fif_i64, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* sext_i32(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildSExt(e->llvm_builder, s.main_ex_back(0), LLVMInt32TypeInContext(e->llvm_context), "");
		s.pop_main();
		s.push_back_main(fif_i32, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		s.mark_used_from_main(1);
		if(s.main_type_back(0) == fif_i8 || s.main_type_back(0) == fif_u8) {
			auto v = int8_t(s.main_data_back(0));
			s.set_main_data_back(0, v);
		} else if(s.main_type_back(0) == fif_i16 || s.main_type_back(0) == fif_u16) {
			auto v = int16_t(s.main_data_back(0));
			s.set_main_data_back(0, v);
		} else if(s.main_type_back(0) == fif_i32 || s.main_type_back(0) == fif_u32) {
			auto v = int32_t(s.main_data_back(0));
			s.set_main_data_back(0, v);
		} if(s.main_type_back(0) == fif_bool) {
			auto v = s.main_data_back(0);
			s.set_main_data_back(0, v != 0 ? -1 : 0);
		}
		s.set_main_type_back(0, fif_i32);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.push_back_main(fif::fif_i32, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* sext_i16(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildSExt(e->llvm_builder, s.main_ex_back(0), LLVMInt16TypeInContext(e->llvm_context), "");
		s.pop_main();
		s.push_back_main(fif_i16, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		s.mark_used_from_main(1);
		if(s.main_type_back(0) == fif_i8 || s.main_type_back(0) == fif_u8) {
			auto v = int8_t(s.main_data_back(0));
			s.set_main_data_back(0, v);
		} else if(s.main_type_back(0) == fif_i16 || s.main_type_back(0) == fif_u16) {
			auto v = int16_t(s.main_data_back(0));
			s.set_main_data_back(0, v);
		} else if(s.main_type_back(0) == fif_i32 || s.main_type_back(0) == fif_u32) {
			auto v = int32_t(s.main_data_back(0));
			s.set_main_data_back(0, v);
		} if(s.main_type_back(0) == fif_bool) {
			auto v = s.main_data_back(0);
			s.set_main_data_back(0, v != 0 ? -1 : 0);
		}
		s.set_main_type_back(0, fif_i16);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.push_back_main(fif::fif_i16, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* sext_i8(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildSExt(e->llvm_builder, s.main_ex_back(0), LLVMInt8TypeInContext(e->llvm_context), "");
		s.pop_main();
		s.push_back_main(fif_i8, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		s.mark_used_from_main(1);
		if(s.main_type_back(0) == fif_i8 || s.main_type_back(0) == fif_u8) {
			auto v = int8_t(s.main_data_back(0));
			s.set_main_data_back(0, v);
		} else if(s.main_type_back(0) == fif_i16 || s.main_type_back(0) == fif_u16) {
			auto v = int16_t(s.main_data_back(0));
			s.set_main_data_back(0, v);
		} else if(s.main_type_back(0) == fif_i32 || s.main_type_back(0) == fif_u32) {
			auto v = int32_t(s.main_data_back(0));
			s.set_main_data_back(0, v);
		} if(s.main_type_back(0) == fif_bool) {
			auto v = s.main_data_back(0);
			s.set_main_data_back(0, v != 0 ? -1 : 0);
		}
		s.set_main_type_back(0, fif_i8);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.push_back_main(fif::fif_i8, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* sext_ui64(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildSExt(e->llvm_builder, s.main_ex_back(0), LLVMInt64TypeInContext(e->llvm_context), "");
		s.pop_main();
		s.push_back_main(fif_u64, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		s.mark_used_from_main(1);
		if(s.main_type_back(0) == fif_i8 || s.main_type_back(0) == fif_u8) {
			auto v = int8_t(s.main_data_back(0));
			s.set_main_data_back(0, v);
		} else if(s.main_type_back(0) == fif_i16 || s.main_type_back(0) == fif_u16) {
			auto v = int16_t(s.main_data_back(0));
			s.set_main_data_back(0, v);
		} else if(s.main_type_back(0) == fif_i32 || s.main_type_back(0) == fif_u32) {
			auto v = int32_t(s.main_data_back(0));
			s.set_main_data_back(0, v);
		} if(s.main_type_back(0) == fif_bool) {
			auto v = s.main_data_back(0);
			s.set_main_data_back(0, v != 0 ? -1 : 0);
		}
		s.set_main_type_back(0, fif_u64);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.push_back_main(fif::fif_u64, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* sext_ui32(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildSExt(e->llvm_builder, s.main_ex_back(0), LLVMInt32TypeInContext(e->llvm_context), "");
		s.pop_main();
		s.push_back_main(fif_u32, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		s.mark_used_from_main(1);
		if(s.main_type_back(0) == fif_i8 || s.main_type_back(0) == fif_u8) {
			auto v = int8_t(s.main_data_back(0));
			s.set_main_data_back(0, v);
		} else if(s.main_type_back(0) == fif_i16 || s.main_type_back(0) == fif_u16) {
			auto v = int16_t(s.main_data_back(0));
			s.set_main_data_back(0, v);
		} else if(s.main_type_back(0) == fif_i32 || s.main_type_back(0) == fif_u32) {
			auto v = int32_t(s.main_data_back(0));
			s.set_main_data_back(0, v);
		} if(s.main_type_back(0) == fif_bool) {
			auto v = s.main_data_back(0);
			s.set_main_data_back(0, v != 0 ? -1 : 0);
		}
		s.set_main_type_back(0, fif_u32);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.push_back_main(fif::fif_u32, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* sext_ui16(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildSExt(e->llvm_builder, s.main_ex_back(0), LLVMInt16TypeInContext(e->llvm_context), "");
		s.pop_main();
		s.push_back_main(fif_u16, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		s.mark_used_from_main(1);
		if(s.main_type_back(0) == fif_i8 || s.main_type_back(0) == fif_u8) {
			auto v = int8_t(s.main_data_back(0));
			s.set_main_data_back(0, v);
		} else if(s.main_type_back(0) == fif_i16 || s.main_type_back(0) == fif_u16) {
			auto v = int16_t(s.main_data_back(0));
			s.set_main_data_back(0, v);
		} else if(s.main_type_back(0) == fif_i32 || s.main_type_back(0) == fif_u32) {
			auto v = int32_t(s.main_data_back(0));
			s.set_main_data_back(0, v);
		} if(s.main_type_back(0) == fif_bool) {
			auto v = s.main_data_back(0);
			s.set_main_data_back(0, v != 0 ? -1 : 0);
		}
		s.set_main_type_back(0, fif_u16);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.push_back_main(fif::fif_u16, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* sext_ui8(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildSExt(e->llvm_builder, s.main_ex_back(0), LLVMInt8TypeInContext(e->llvm_context), "");
		s.pop_main();
		s.push_back_main(fif_u8, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		s.mark_used_from_main(1);
		if(s.main_type_back(0) == fif_i8 || s.main_type_back(0) == fif_u8) {
			auto v = int8_t(s.main_data_back(0));
			s.set_main_data_back(0, v);
		} else if(s.main_type_back(0) == fif_i16 || s.main_type_back(0) == fif_u16) {
			auto v = int16_t(s.main_data_back(0));
			s.set_main_data_back(0, v);
		} else if(s.main_type_back(0) == fif_i32 || s.main_type_back(0) == fif_u32) {
			auto v = int32_t(s.main_data_back(0));
			s.set_main_data_back(0, v);
		} if(s.main_type_back(0) == fif_bool) {
			auto v = s.main_data_back(0);
			s.set_main_data_back(0, v != 0 ? -1 : 0);
		}
		s.set_main_type_back(0, fif_u8);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.push_back_main(fif::fif_u8, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* trunc_ui8(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildTrunc(e->llvm_builder, s.main_ex_back(0), LLVMInt8TypeInContext(e->llvm_context), "");
		s.pop_main();
		s.push_back_main(fif_u8, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		s.mark_used_from_main(1);
		s.set_main_data_back(0, s.main_data_back(0) & 0x0FF);
		s.set_main_type_back(0, fif_u8);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.push_back_main(fif::fif_u8, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* trunc_i8(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildTrunc(e->llvm_builder, s.main_ex_back(0), LLVMInt8TypeInContext(e->llvm_context), "");
		s.pop_main();
		s.push_back_main(fif_i8, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		s.mark_used_from_main(1);
		s.set_main_data_back(0, int8_t(s.main_data_back(0) & 0x0FF));
		s.set_main_type_back(0, fif_i8);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.push_back_main(fif::fif_i8, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* trunc_i1(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildTrunc(e->llvm_builder, s.main_ex_back(0), LLVMInt1TypeInContext(e->llvm_context), "");
		s.pop_main();
		s.push_back_main(fif_bool, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		s.mark_used_from_main(1);
		s.set_main_data_back(0, s.main_data_back(0) & 0x01);
		s.set_main_type_back(0, fif_bool);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.push_back_main(fif::fif_bool, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* trunc_ui16(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildTrunc(e->llvm_builder, s.main_ex_back(0), LLVMInt16TypeInContext(e->llvm_context), "");
		s.pop_main();
		s.push_back_main(fif_u16, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		s.mark_used_from_main(1);
		s.set_main_data_back(0, s.main_data_back(0) & 0x0FFFF);
		s.set_main_type_back(0, fif_u16);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.push_back_main(fif::fif_u16, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* trunc_i16(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildTrunc(e->llvm_builder, s.main_ex_back(0), LLVMInt16TypeInContext(e->llvm_context), "");
		s.pop_main();
		s.push_back_main(fif_i16, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		s.mark_used_from_main(1);
		s.set_main_data_back(0, int16_t(s.main_data_back(0) & 0x0FFFF));
		s.set_main_type_back(0, fif_i16);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.push_back_main(fif::fif_i16, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* trunc_ui32(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildTrunc(e->llvm_builder, s.main_ex_back(0), LLVMInt32TypeInContext(e->llvm_context), "");
		s.pop_main();
		s.push_back_main(fif_u32, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		s.mark_used_from_main(1);
		s.set_main_data_back(0, s.main_data_back(0) & 0x0FFFFFFFF);
		s.set_main_type_back(0, fif_u32);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.push_back_main(fif::fif_u32, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* trunc_i32(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildTrunc(e->llvm_builder, s.main_ex_back(0), LLVMInt32TypeInContext(e->llvm_context), "");
		s.pop_main();
		s.push_back_main(fif_i32, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		s.mark_used_from_main(1);
		s.set_main_data_back(0, int32_t(s.main_data_back(0) & 0x0FFFFFFFF));
		s.set_main_type_back(0, fif_i32);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.push_back_main(fif::fif_i32, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* nop1(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
		s.mark_used_from_main(1);
	} else if(e->mode == fif::fif_mode::interpreting) {
		s.mark_used_from_main(1);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.mark_used_from_main(1);
	}
	return p + 2;
}
inline int32_t* ftrunc(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildFPTrunc(e->llvm_builder, s.main_ex_back(0), LLVMFloatTypeInContext(e->llvm_context), "");
		s.pop_main();
		s.push_back_main(fif_f32, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		auto v = s.main_data_back(0);
		double fin = 0;
		memcpy(&fin, &v, 8);
		float fout = float(fin);
		int64_t iout = 0;
		memcpy(&iout, &fout, 4);
		s.pop_main();
		s.push_back_main(fif_f32, iout, nullptr);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.push_back_main(fif::fif_f32, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* fext(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildFPExt(e->llvm_builder, s.main_ex_back(0), LLVMFloatTypeInContext(e->llvm_context), "");
		s.pop_main();
		s.push_back_main(fif_f64, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		auto v = s.main_data_back(0);
		float fin = 0;
		memcpy(&fin, &v, 4);
		double fout = double(fin);
		int64_t iout = 0;
		memcpy(&iout, &fout, 8);
		s.pop_main();
		s.push_back_main(fif_f64, iout, nullptr);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.push_back_main(fif::fif_f64, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* f32i8(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildFPToSI(e->llvm_builder, s.main_ex_back(0), LLVMInt8TypeInContext(e->llvm_context), "");
		s.pop_main();
		s.push_back_main(fif_i8, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		auto v = s.main_data_back(0);
		float fin = 0;
		memcpy(&fin, &v, 4);
		int64_t iout = int8_t(fin);
		s.pop_main();
		s.push_back_main(fif_i8, iout, nullptr);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.push_back_main(fif::fif_i8, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* sif32(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildSIToFP(e->llvm_builder, s.main_ex_back(0), LLVMFloatTypeInContext(e->llvm_context), "");
		s.pop_main();
		s.push_back_main(fif_f32, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		auto v = s.main_data_back(0);
		float fout = float(v);
		int64_t iout = 0;
		memcpy(&iout, &fout, 4);
		s.pop_main();
		s.push_back_main(fif_f32, iout, nullptr);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.push_back_main(fif::fif_f32, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* uif32(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildUIToFP(e->llvm_builder, s.main_ex_back(0), LLVMFloatTypeInContext(e->llvm_context), "");
		s.pop_main();
		s.push_back_main(fif_f32, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		auto v = uint64_t(s.main_data_back(0));
		float fout = float(v);
		int64_t iout = 0;
		memcpy(&iout, &fout, 4);
		s.pop_main();
		s.push_back_main(fif_f32, iout, nullptr);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.push_back_main(fif::fif_f32, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* sif64(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildSIToFP(e->llvm_builder, s.main_ex_back(0), LLVMDoubleTypeInContext(e->llvm_context), "");
		s.pop_main();
		s.push_back_main(fif_f64, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		auto v = s.main_data_back(0);
		double fout = double(v);
		int64_t iout = 0;
		memcpy(&iout, &fout, 8);
		s.pop_main();
		s.push_back_main(fif_f64, iout, nullptr);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.push_back_main(fif::fif_f64, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* uif64(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildUIToFP(e->llvm_builder, s.main_ex_back(0), LLVMDoubleTypeInContext(e->llvm_context), "");
		s.pop_main();
		s.push_back_main(fif_f64, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		auto v = uint64_t(s.main_data_back(0));
		double fout = double(v);
		int64_t iout = 0;
		memcpy(&iout, &fout, 8);
		s.pop_main();
		s.push_back_main(fif_f64, iout, nullptr);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.push_back_main(fif::fif_f64, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* f32i16(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildFPToSI(e->llvm_builder, s.main_ex_back(0), LLVMInt16TypeInContext(e->llvm_context), "");
		s.pop_main();
		s.push_back_main(fif_i16, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		auto v = s.main_data_back(0);
		float fin = 0;
		memcpy(&fin, &v, 4);
		int64_t iout = int16_t(fin);
		s.pop_main();
		s.push_back_main(fif_i16, iout, nullptr);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.push_back_main(fif::fif_i16, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* f32i32(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildFPToSI(e->llvm_builder, s.main_ex_back(0), LLVMInt32TypeInContext(e->llvm_context), "");
		s.pop_main();
		s.push_back_main(fif_i32, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		auto v = s.main_data_back(0);
		float fin = 0;
		memcpy(&fin, &v, 4);
		int64_t iout = int32_t(fin);
		s.pop_main();
		s.push_back_main(fif_i32, iout, nullptr);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.push_back_main(fif::fif_i32, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* f32i64(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildFPToSI(e->llvm_builder, s.main_ex_back(0), LLVMInt64TypeInContext(e->llvm_context), "");
		s.pop_main();
		s.push_back_main(fif_i64, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		auto v = s.main_data_back(0);
		float fin = 0;
		memcpy(&fin, &v, 4);
		int64_t iout = int64_t(fin);
		s.pop_main();
		s.push_back_main(fif_i64, iout, nullptr);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.push_back_main(fif::fif_i64, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* f32ui8(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildFPToUI(e->llvm_builder, s.main_ex_back(0), LLVMInt8TypeInContext(e->llvm_context), "");
		s.pop_main();
		s.push_back_main(fif_u8, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		auto v = s.main_data_back(0);
		float fin = 0;
		memcpy(&fin, &v, 4);
		int64_t iout = int64_t(uint8_t(fin));
		s.pop_main();
		s.push_back_main(fif_u8, iout, nullptr);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.push_back_main(fif::fif_u8, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* f32ui16(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildFPToUI(e->llvm_builder, s.main_ex_back(0), LLVMInt16TypeInContext(e->llvm_context), "");
		s.pop_main();
		s.push_back_main(fif_u16, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		auto v = s.main_data_back(0);
		float fin = 0;
		memcpy(&fin, &v, 4);
		int64_t iout = int64_t(uint16_t(fin));
		s.pop_main();
		s.push_back_main(fif_u16, iout, nullptr);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.push_back_main(fif::fif_u16, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* f32ui32(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildFPToUI(e->llvm_builder, s.main_ex_back(0), LLVMInt32TypeInContext(e->llvm_context), "");
		s.pop_main();
		s.push_back_main(fif_u32, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		auto v = s.main_data_back(0);
		float fin = 0;
		memcpy(&fin, &v, 4);
		int64_t iout = int64_t(uint32_t(fin));
		s.pop_main();
		s.push_back_main(fif_u32, iout, nullptr);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.push_back_main(fif::fif_u32, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* f32ui64(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildFPToUI(e->llvm_builder, s.main_ex_back(0), LLVMInt64TypeInContext(e->llvm_context), "");
		s.pop_main();
		s.push_back_main(fif_u64, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		auto v = s.main_data_back(0);
		float fin = 0;
		memcpy(&fin, &v, 4);
		int64_t iout = int64_t(uint64_t(fin));
		s.pop_main();
		s.push_back_main(fif_u64, iout, nullptr);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.push_back_main(fif::fif_u64, 0, nullptr);
	}
	return p + 2;
}

inline int32_t* f64i8(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildFPToSI(e->llvm_builder, s.main_ex_back(0), LLVMInt8TypeInContext(e->llvm_context), "");
		s.pop_main();
		s.push_back_main(fif_i8, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		auto v = s.main_data_back(0);
		double fin = 0;
		memcpy(&fin, &v, 8);
		int64_t iout = int8_t(fin);
		s.pop_main();
		s.push_back_main(fif_i8, iout, nullptr);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.push_back_main(fif::fif_i8, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* f64i16(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildFPToSI(e->llvm_builder, s.main_ex_back(0), LLVMInt16TypeInContext(e->llvm_context), "");
		s.pop_main();
		s.push_back_main(fif_i16, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		auto v = s.main_data_back(0);
		double fin = 0;
		memcpy(&fin, &v, 8);
		int64_t iout = int16_t(fin);
		s.pop_main();
		s.push_back_main(fif_i16, iout, nullptr);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.push_back_main(fif::fif_i16, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* f64i32(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildFPToSI(e->llvm_builder, s.main_ex_back(0), LLVMInt32TypeInContext(e->llvm_context), "");
		s.pop_main();
		s.push_back_main(fif_i32, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		auto v = s.main_data_back(0);
		double fin = 0;
		memcpy(&fin, &v, 8);
		int64_t iout = int32_t(fin);
		s.pop_main();
		s.push_back_main(fif_i32, iout, nullptr);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.push_back_main(fif::fif_i32, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* f64i64(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildFPToSI(e->llvm_builder, s.main_ex_back(0), LLVMInt64TypeInContext(e->llvm_context), "");
		s.pop_main();
		s.push_back_main(fif_i64, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		auto v = s.main_data_back(0);
		double fin = 0;
		memcpy(&fin, &v, 8);
		int64_t iout = int64_t(fin);
		s.pop_main();
		s.push_back_main(fif_i64, iout, nullptr);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.push_back_main(fif::fif_i64, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* f64ui8(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildFPToUI(e->llvm_builder, s.main_ex_back(0), LLVMInt8TypeInContext(e->llvm_context), "");
		s.pop_main();
		s.push_back_main(fif_u8, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		auto v = s.main_data_back(0);
		double fin = 0;
		memcpy(&fin, &v, 8);
		int64_t iout = int64_t(uint8_t(fin));
		s.pop_main();
		s.push_back_main(fif_u8, iout, nullptr);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.push_back_main(fif::fif_u8, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* f64ui16(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildFPToUI(e->llvm_builder, s.main_ex_back(0), LLVMInt16TypeInContext(e->llvm_context), "");
		s.pop_main();
		s.push_back_main(fif_u16, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		auto v = s.main_data_back(0);
		double fin = 0;
		memcpy(&fin, &v, 8);
		int64_t iout = int64_t(uint16_t(fin));
		s.pop_main();
		s.push_back_main(fif_u16, iout, nullptr);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.push_back_main(fif::fif_u16, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* f64ui32(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildFPToUI(e->llvm_builder, s.main_ex_back(0), LLVMInt32TypeInContext(e->llvm_context), "");
		s.pop_main();
		s.push_back_main(fif_u32, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		auto v = s.main_data_back(0);
		double fin = 0;
		memcpy(&fin, &v, 8);
		int64_t iout = int64_t(uint32_t(fin));
		s.pop_main();
		s.push_back_main(fif_u32, iout, nullptr);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.push_back_main(fif::fif_u32, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* f64ui64(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		auto result = LLVMBuildFPToUI(e->llvm_builder, s.main_ex_back(0), LLVMInt64TypeInContext(e->llvm_context), "");
		s.pop_main();
		s.push_back_main(fif_u64, 0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		auto v = s.main_data_back(0);
		double fin = 0;
		memcpy(&fin, &v, 8);
		int64_t iout = int64_t(uint64_t(fin));
		s.pop_main();
		s.push_back_main(fif_u64, iout, nullptr);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.pop_main();
		s.push_back_main(fif::fif_u64, 0, nullptr);
	}
	return p + 2;
}
inline int32_t* bit_and(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		s.mark_used_from_main(2);
		auto result = LLVMBuildAnd(e->llvm_builder, s.main_ex_back(1), s.main_ex_back(0), "");
		s.pop_main();
		s.set_main_ex_back(0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		s.mark_used_from_main(2);
		auto a = s.main_data_back(0);
		auto b = s.main_data_back(1);
		s.pop_main();
		s.set_main_data_back(0, a & b);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.mark_used_from_main(2);
		s.pop_main();
	}
	return p + 2;
}
inline int32_t* bit_or(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		s.mark_used_from_main(2);
		auto result = LLVMBuildOr(e->llvm_builder, s.main_ex_back(1), s.main_ex_back(0), "");
		s.pop_main();
		s.set_main_ex_back(0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		s.mark_used_from_main(2);
		auto a = s.main_data_back(0);
		auto b = s.main_data_back(1);
		s.pop_main();
		s.set_main_data_back(0, a | b);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.mark_used_from_main(2);
		s.pop_main();
	}
	return p + 2;
}
inline int32_t* bit_xor(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		s.mark_used_from_main(2);
		auto result = LLVMBuildXor(e->llvm_builder, s.main_ex_back(1), s.main_ex_back(0), "");
		s.pop_main();
		s.set_main_ex_back(0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		s.mark_used_from_main(2);
		auto a = s.main_data_back(0);
		auto b = s.main_data_back(1);
		s.pop_main();
		s.set_main_data_back(0, a ^ b);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.mark_used_from_main(2);
		s.pop_main();
	}
	return p + 2;
}
inline int32_t* bit_not(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		s.mark_used_from_main(1);
		auto result = LLVMBuildNot(e->llvm_builder, s.main_ex_back(0), "");
		s.set_main_ex_back(0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		s.mark_used_from_main(1);
		auto a = s.main_data_back(0);
		if(s.main_type_back(0) == fif_bool)
			s.set_main_data_back(0, a == 0);
		else
			s.set_main_data_back(0, ~a);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.mark_used_from_main(1);
	}
	return p + 2;
}
inline int32_t* bit_shl(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		s.mark_used_from_main(2);
		auto result = LLVMBuildShl(e->llvm_builder, s.main_ex_back(1), s.main_ex_back(0), "");
		s.pop_main();
		s.set_main_ex_back(0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		s.mark_used_from_main(2);
		auto a = s.main_data_back(0);
		auto b = s.main_data_back(1);
		s.pop_main();
		s.set_main_data_back(0, b << a);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.mark_used_from_main(2);
		s.pop_main();
	}
	return p + 2;
}
inline int32_t* bit_ashr(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		s.mark_used_from_main(2);
		auto result = LLVMBuildAShr(e->llvm_builder, s.main_ex_back(1), s.main_ex_back(0), "");
		s.pop_main();
		s.set_main_ex_back(0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		s.mark_used_from_main(2);
		auto a = s.main_data_back(0);
		auto b = s.main_data_back(1);
		s.pop_main();
		s.set_main_data_back(0, b >> a);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.mark_used_from_main(2);
		s.pop_main();
	}
	return p + 2;
}
inline int32_t* bit_lshr(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
#ifdef USE_LLVM
		s.mark_used_from_main(2);
		auto result = LLVMBuildLShr(e->llvm_builder, s.main_ex_back(1), s.main_ex_back(0), "");
		s.pop_main();
		s.set_main_ex_back(0, result);
#endif
	} else if(e->mode == fif::fif_mode::interpreting) {
		s.mark_used_from_main(2);
		auto a = s.main_data_back(0);
		auto b = s.main_data_back(1);
		s.pop_main();
		s.set_main_data_back(0, uint64_t(b) >> a);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.mark_used_from_main(2);
		s.pop_main();
	}
	return p + 2;
}

inline int32_t* ident32(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
	} else if(e->mode == fif::fif_mode::interpreting) {
		s.mark_used_from_main(1);
		s.set_main_data_back(0, s.main_data_back(0) & 0x0FFFFFFFF);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.mark_used_from_main(1);
	}
	return p + 2;
}
inline int32_t* ident16(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
	} else if(e->mode == fif::fif_mode::interpreting) {
		s.mark_used_from_main(1);
		s.set_main_data_back(0, s.main_data_back(0) & 0x0FFFF);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.mark_used_from_main(1);
	}
	return p + 2;
}
inline int32_t* ident8(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
	} else if(e->mode == fif::fif_mode::interpreting) {
		s.mark_used_from_main(1);
		s.set_main_data_back(0, s.main_data_back(0) & 0x0FF);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.mark_used_from_main(1);
	}
	return p + 2;
}
inline int32_t* idents32(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
	} else if(e->mode == fif::fif_mode::interpreting) {
		s.mark_used_from_main(1);
		s.set_main_data_back(0, int32_t(s.main_data_back(0) & 0x0FFFFFFFF));
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.mark_used_from_main(1);
	}
	return p + 2;
}
inline int32_t* idents16(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
	} else if(e->mode == fif::fif_mode::interpreting) {
		s.mark_used_from_main(1);
		s.set_main_data_back(0, int16_t(s.main_data_back(0) & 0x0FFFF));
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.mark_used_from_main(1);
	}
	return p + 2;
}
inline int32_t* idents8(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
	} else if(e->mode == fif::fif_mode::interpreting) {
		s.mark_used_from_main(1);
		s.set_main_data_back(0, int8_t(s.main_data_back(0) & 0x0FF));
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.mark_used_from_main(1);
	}
	return p + 2;
}
inline int32_t* ident1(fif::state_stack& s, int32_t* p, fif::environment* e) {
	if(e->mode == fif::fif_mode::compiling_llvm) {
	} else if(e->mode == fif::fif_mode::interpreting) {
		s.mark_used_from_main(1);
		s.set_main_data_back(0, s.main_data_back(0) & 0x01);
	} else if(fif::typechecking_mode(e->mode) && !fif::typechecking_failed(e->mode)) {
		s.mark_used_from_main(1);
	}
	return p + 2;
}

inline void initialize_standard_vocab(environment& fif_env) {
	add_precompiled(fif_env, ":", colon_definition, { });
	add_precompiled(fif_env, ":s", colon_specialization, { });
	add_precompiled(fif_env, "((", long_comment, { }, true);
	add_precompiled(fif_env, "--", line_comment, { }, true);

	add_precompiled(fif_env, "+", iadd, { fif::fif_i32, fif::fif_i32, -1, fif::fif_i32 });
	add_precompiled(fif_env, "+", iadd, { fif::fif_u32, fif::fif_u32, -1, fif::fif_u32 });
	add_precompiled(fif_env, "+", iadd, { fif::fif_u64, fif::fif_u64, -1, fif::fif_u64 });
	add_precompiled(fif_env, "+", iadd, { fif::fif_i64, fif::fif_i64, -1, fif::fif_i64 });
	add_precompiled(fif_env, "+", iadd, { fif::fif_i16, fif::fif_i16, -1, fif::fif_i16 });
	add_precompiled(fif_env, "+", iadd, { fif::fif_u16, fif::fif_u16, -1, fif::fif_u16 });
	add_precompiled(fif_env, "+", iadd, { fif::fif_i8, fif::fif_i8, -1, fif::fif_i8 });
	add_precompiled(fif_env, "+", iadd, { fif::fif_u8, fif::fif_u8, -1, fif::fif_u8 });
	add_precompiled(fif_env, "+", f32_add, { fif::fif_f32, fif::fif_f32, -1, fif::fif_f32 });
	add_precompiled(fif_env, "+", f64_add, { fif::fif_f64, fif::fif_f64, -1, fif::fif_f64 });

	add_precompiled(fif_env, "-", isub, { fif::fif_i32, fif::fif_i32, -1, fif::fif_i32 });
	add_precompiled(fif_env, "-", isub, { fif::fif_u32, fif::fif_u32, -1, fif::fif_u32 });
	add_precompiled(fif_env, "-", isub, { fif::fif_u64, fif::fif_u64, -1, fif::fif_u64 });
	add_precompiled(fif_env, "-", isub, { fif::fif_i64, fif::fif_i64, -1, fif::fif_i64 });
	add_precompiled(fif_env, "-", isub, { fif::fif_i16, fif::fif_i16, -1, fif::fif_i16 });
	add_precompiled(fif_env, "-", isub, { fif::fif_u16, fif::fif_u16, -1, fif::fif_u16 });
	add_precompiled(fif_env, "-", isub, { fif::fif_i8, fif::fif_i8, -1, fif::fif_i8 });
	add_precompiled(fif_env, "-", isub, { fif::fif_u8, fif::fif_u8, -1, fif::fif_u8 });
	add_precompiled(fif_env, "-", f32_sub, { fif::fif_f32, fif::fif_f32, -1, fif::fif_f32 });
	add_precompiled(fif_env, "-", f64_sub, { fif::fif_f64, fif::fif_f64, -1, fif::fif_f64 });

	add_precompiled(fif_env, "/", sidiv, { fif::fif_i32, fif::fif_i32, -1, fif::fif_i32 });
	add_precompiled(fif_env, "/", uidiv, { fif::fif_u32, fif::fif_u32, -1, fif::fif_u32 });
	add_precompiled(fif_env, "/", uidiv, { fif::fif_u64, fif::fif_u64, -1, fif::fif_u64 });
	add_precompiled(fif_env, "/", sidiv, { fif::fif_i64, fif::fif_i64, -1, fif::fif_i64 });
	add_precompiled(fif_env, "/", sidiv, { fif::fif_i16, fif::fif_i16, -1, fif::fif_i16 });
	add_precompiled(fif_env, "/", uidiv, { fif::fif_u16, fif::fif_u16, -1, fif::fif_u16 });
	add_precompiled(fif_env, "/", sidiv, { fif::fif_i8, fif::fif_i8, -1, fif::fif_i8 });
	add_precompiled(fif_env, "/", uidiv, { fif::fif_u8, fif::fif_u8, -1, fif::fif_u8 });
	add_precompiled(fif_env, "/", f32_div, { fif::fif_f32, fif::fif_f32, -1, fif::fif_f32 });
	add_precompiled(fif_env, "/", f64_div, { fif::fif_f64, fif::fif_f64, -1, fif::fif_f64 });

	add_precompiled(fif_env, "mod", simod, { fif::fif_i32, fif::fif_i32, -1, fif::fif_i32 });
	add_precompiled(fif_env, "mod", uimod, { fif::fif_u32, fif::fif_u32, -1, fif::fif_u32 });
	add_precompiled(fif_env, "mod", uimod, { fif::fif_u64, fif::fif_u64, -1, fif::fif_u64 });
	add_precompiled(fif_env, "mod", simod, { fif::fif_i64, fif::fif_i64, -1, fif::fif_i64 });
	add_precompiled(fif_env, "mod", simod, { fif::fif_i16, fif::fif_i16, -1, fif::fif_i16 });
	add_precompiled(fif_env, "mod", uimod, { fif::fif_u16, fif::fif_u16, -1, fif::fif_u16 });
	add_precompiled(fif_env, "mod", simod, { fif::fif_i8, fif::fif_i8, -1, fif::fif_i8 });
	add_precompiled(fif_env, "mod", uimod, { fif::fif_u8, fif::fif_u8, -1, fif::fif_u8 });
	add_precompiled(fif_env, "mod", f32_mod, { fif::fif_f32, fif::fif_f32, -1, fif::fif_f32 });
	add_precompiled(fif_env, "mod", f64_mod, { fif::fif_f64, fif::fif_f64, -1, fif::fif_f64 });

	add_precompiled(fif_env, "*", imul, { fif::fif_i32, fif::fif_i32, -1, fif::fif_i32 });
	add_precompiled(fif_env, "*", imul, { fif::fif_u32, fif::fif_u32, -1, fif::fif_u32 });
	add_precompiled(fif_env, "*", imul, { fif::fif_u64, fif::fif_u64, -1, fif::fif_u64 });
	add_precompiled(fif_env, "*", imul, { fif::fif_i64, fif::fif_i64, -1, fif::fif_i64 });
	add_precompiled(fif_env, "*", imul, { fif::fif_i16, fif::fif_i16, -1, fif::fif_i16 });
	add_precompiled(fif_env, "*", imul, { fif::fif_u16, fif::fif_u16, -1, fif::fif_u16 });
	add_precompiled(fif_env, "*", imul, { fif::fif_i8, fif::fif_i8, -1, fif::fif_i8 });
	add_precompiled(fif_env, "*", imul, { fif::fif_u8, fif::fif_u8, -1, fif::fif_u8 });
	add_precompiled(fif_env, "*", f32_mul, { fif::fif_f32, fif::fif_f32, -1, fif::fif_f32 });
	add_precompiled(fif_env, "*", f64_mul, { fif::fif_f64, fif::fif_f64, -1, fif::fif_f64 });

	add_precompiled(fif_env, "<", ilt, { fif::fif_i32, fif::fif_i32, -1, fif::fif_bool });
	add_precompiled(fif_env, "<=", ile, { fif::fif_i32, fif::fif_i32, -1, fif::fif_bool });
	add_precompiled(fif_env, ">", igt, { fif::fif_i32, fif::fif_i32, -1, fif::fif_bool });
	add_precompiled(fif_env, ">=", ige, { fif::fif_i32, fif::fif_i32, -1, fif::fif_bool });
	add_precompiled(fif_env, "=", ieq, { fif::fif_i32, fif::fif_i32, -1, fif::fif_bool });
	add_precompiled(fif_env, "<>", ine, { fif::fif_i32, fif::fif_i32, -1, fif::fif_bool });
	add_precompiled(fif_env, "<", ilt, { fif::fif_i64, fif::fif_i64, -1, fif::fif_bool });
	add_precompiled(fif_env, "<=", ile, { fif::fif_i64, fif::fif_i64, -1, fif::fif_bool });
	add_precompiled(fif_env, ">", igt, { fif::fif_i64, fif::fif_i64, -1, fif::fif_bool });
	add_precompiled(fif_env, ">=", ige, { fif::fif_i64, fif::fif_i64, -1, fif::fif_bool });
	add_precompiled(fif_env, "=", ieq, { fif::fif_i64, fif::fif_i64, -1, fif::fif_bool });
	add_precompiled(fif_env, "<>", ine, { fif::fif_i64, fif::fif_i64, -1, fif::fif_bool });
	add_precompiled(fif_env, "<", ilt, { fif::fif_i16, fif::fif_i16, -1, fif::fif_bool });
	add_precompiled(fif_env, "<=", ile, { fif::fif_i16, fif::fif_i16, -1, fif::fif_bool });
	add_precompiled(fif_env, ">", igt, { fif::fif_i16, fif::fif_i16, -1, fif::fif_bool });
	add_precompiled(fif_env, ">=", ige, { fif::fif_i16, fif::fif_i16, -1, fif::fif_bool });
	add_precompiled(fif_env, "=", ieq, { fif::fif_i16, fif::fif_i16, -1, fif::fif_bool });
	add_precompiled(fif_env, "<>", ine, { fif::fif_i16, fif::fif_i16, -1, fif::fif_bool });
	add_precompiled(fif_env, "<", ilt, { fif::fif_i8, fif::fif_i8, -1, fif::fif_bool });
	add_precompiled(fif_env, "<=", ile, { fif::fif_i8, fif::fif_i8, -1, fif::fif_bool });
	add_precompiled(fif_env, ">", igt, { fif::fif_i8, fif::fif_i8, -1, fif::fif_bool });
	add_precompiled(fif_env, ">=", ige, { fif::fif_i8, fif::fif_i8, -1, fif::fif_bool });
	add_precompiled(fif_env, "=", ieq, { fif::fif_i8, fif::fif_i8, -1, fif::fif_bool });
	add_precompiled(fif_env, "<>", ine, { fif::fif_i8, fif::fif_i8, -1, fif::fif_bool });

	add_precompiled(fif_env, "<", uilt, { fif::fif_u32, fif::fif_u32, -1, fif::fif_bool });
	add_precompiled(fif_env, "<=", uile, { fif::fif_u32, fif::fif_u32, -1, fif::fif_bool });
	add_precompiled(fif_env, ">", uigt, { fif::fif_u32, fif::fif_u32, -1, fif::fif_bool });
	add_precompiled(fif_env, ">=", uige, { fif::fif_u32, fif::fif_u32, -1, fif::fif_bool });
	add_precompiled(fif_env, "=", ieq, { fif::fif_u32, fif::fif_u32, -1, fif::fif_bool });
	add_precompiled(fif_env, "<>", ine, { fif::fif_u32, fif::fif_u32, -1, fif::fif_bool });
	add_precompiled(fif_env, "<", uilt, { fif::fif_u64, fif::fif_u64, -1, fif::fif_bool });
	add_precompiled(fif_env, "<=", uile, { fif::fif_u64, fif::fif_u64, -1, fif::fif_bool });
	add_precompiled(fif_env, ">", uigt, { fif::fif_u64, fif::fif_u64, -1, fif::fif_bool });
	add_precompiled(fif_env, ">=", uige, { fif::fif_u64, fif::fif_u64, -1, fif::fif_bool });
	add_precompiled(fif_env, "=", ieq, { fif::fif_u64, fif::fif_u64, -1, fif::fif_bool });
	add_precompiled(fif_env, "<>", ine, { fif::fif_u64, fif::fif_u64, -1, fif::fif_bool });
	add_precompiled(fif_env, "<", uilt, { fif::fif_u16, fif::fif_u16, -1, fif::fif_bool });
	add_precompiled(fif_env, "<=", uile, { fif::fif_u16, fif::fif_u16, -1, fif::fif_bool });
	add_precompiled(fif_env, ">", uigt, { fif::fif_u16, fif::fif_u16, -1, fif::fif_bool });
	add_precompiled(fif_env, ">=", uige, { fif::fif_u16, fif::fif_u16, -1, fif::fif_bool });
	add_precompiled(fif_env, "=", ieq, { fif::fif_u16, fif::fif_u16, -1, fif::fif_bool });
	add_precompiled(fif_env, "<>", ine, { fif::fif_u16, fif::fif_u16, -1, fif::fif_bool });
	add_precompiled(fif_env, "<", uilt, { fif::fif_u8, fif::fif_u8, -1, fif::fif_bool });
	add_precompiled(fif_env, "<=", uile, { fif::fif_u8, fif::fif_u8, -1, fif::fif_bool });
	add_precompiled(fif_env, ">", uigt, { fif::fif_u8, fif::fif_u8, -1, fif::fif_bool });
	add_precompiled(fif_env, ">=", uige, { fif::fif_u8, fif::fif_u8, -1, fif::fif_bool });
	add_precompiled(fif_env, "=", ieq, { fif::fif_u8, fif::fif_u8, -1, fif::fif_bool });
	add_precompiled(fif_env, "<>", ine, { fif::fif_u8, fif::fif_u8, -1, fif::fif_bool });

	add_precompiled(fif_env, "<", f32lt, { fif::fif_f32, fif::fif_f32, -1, fif::fif_bool });
	add_precompiled(fif_env, "<=", f32le, { fif::fif_f32, fif::fif_f32, -1, fif::fif_bool });
	add_precompiled(fif_env, ">", f32gt, { fif::fif_f32, fif::fif_f32, -1, fif::fif_bool });
	add_precompiled(fif_env, ">=", f32ge, { fif::fif_f32, fif::fif_f32, -1, fif::fif_bool });
	add_precompiled(fif_env, "=", f32eq, { fif::fif_f32, fif::fif_f32, -1, fif::fif_bool });
	add_precompiled(fif_env, "<>", f32ne, { fif::fif_f32, fif::fif_f32, -1, fif::fif_bool });
	add_precompiled(fif_env, "<", f64lt, { fif::fif_f64, fif::fif_f64, -1, fif::fif_bool });
	add_precompiled(fif_env, "<=", f64le, { fif::fif_f64, fif::fif_f64, -1, fif::fif_bool });
	add_precompiled(fif_env, ">", f64gt, { fif::fif_f64, fif::fif_f64, -1, fif::fif_bool });
	add_precompiled(fif_env, ">=", f64ge, { fif::fif_f64, fif::fif_f64, -1, fif::fif_bool });
	add_precompiled(fif_env, "=", f64eq, { fif::fif_f64, fif::fif_f64, -1, fif::fif_bool });
	add_precompiled(fif_env, "<>", f64ne, { fif::fif_f64, fif::fif_f64, -1, fif::fif_bool });

	add_precompiled(fif_env, "=", ieq, { fif::fif_bool, fif::fif_bool, -1, fif::fif_bool });
	add_precompiled(fif_env, "<>", ine, { fif::fif_bool, fif::fif_bool, -1, fif::fif_bool });

	add_precompiled(fif_env, ">i64", zext_i64, { fif::fif_u64, -1, fif::fif_i64 });
	add_precompiled(fif_env, ">i64", zext_i64, { fif::fif_u32, -1, fif::fif_i64 });
	add_precompiled(fif_env, ">i64", zext_i64, { fif::fif_u16, -1, fif::fif_i64 });
	add_precompiled(fif_env, ">i64", zext_i64, { fif::fif_u8, -1, fif::fif_i64 });
	add_precompiled(fif_env, ">i64", nop1, { fif::fif_i64, -1, fif::fif_i64 });
	add_precompiled(fif_env, ">i64", sext_i64, { fif::fif_i32, -1, fif::fif_i64 });
	add_precompiled(fif_env, ">i64", sext_i64, { fif::fif_i16, -1, fif::fif_i64 });
	add_precompiled(fif_env, ">i64", sext_i64, { fif::fif_i8, -1, fif::fif_i64 });
	add_precompiled(fif_env, ">i64", zext_i64, { fif::fif_bool, -1, fif::fif_i64 });
	add_precompiled(fif_env, ">i64", f32i64, { fif::fif_f32, -1, fif::fif_i64 });
	add_precompiled(fif_env, ">i64", f64i64, { fif::fif_f64, -1, fif::fif_i64 });

	add_precompiled(fif_env, ">u64", nop1, { fif::fif_u64, -1, fif::fif_u64 });
	add_precompiled(fif_env, ">u64", zext_ui64, { fif::fif_u32, -1, fif::fif_u64 });
	add_precompiled(fif_env, ">u64", zext_ui64, { fif::fif_u16, -1, fif::fif_u64 });
	add_precompiled(fif_env, ">u64", zext_ui64, { fif::fif_u8, -1, fif::fif_u64 });
	add_precompiled(fif_env, ">u64", sext_ui64, { fif::fif_i64, -1, fif::fif_u64 });
	add_precompiled(fif_env, ">u64", sext_ui64, { fif::fif_i32, -1, fif::fif_u64 });
	add_precompiled(fif_env, ">u64", sext_ui64, { fif::fif_i16, -1, fif::fif_u64 });
	add_precompiled(fif_env, ">u64", sext_ui64, { fif::fif_i8, -1, fif::fif_u64 });
	add_precompiled(fif_env, ">u64", zext_ui64, { fif::fif_bool, -1, fif::fif_u64 });
	add_precompiled(fif_env, ">u64", f32ui64, { fif::fif_f32, -1, fif::fif_u64 });
	add_precompiled(fif_env, ">u64", f64ui64, { fif::fif_f64, -1, fif::fif_u64 });

	add_precompiled(fif_env, ">i32", trunc_i32, { fif::fif_u64, -1, fif::fif_i32 });
	add_precompiled(fif_env, ">i32", zext_i32, { fif::fif_u32, -1, fif::fif_i32 });
	add_precompiled(fif_env, ">i32", zext_i32, { fif::fif_u16, -1, fif::fif_i32 });
	add_precompiled(fif_env, ">i32", zext_i32, { fif::fif_u8, -1, fif::fif_i32 });
	add_precompiled(fif_env, ">i32", trunc_i32, { fif::fif_i64, -1, fif::fif_i32 });
	add_precompiled(fif_env, ">i32", idents32, { fif::fif_i32, -1, fif::fif_i32 });
	add_precompiled(fif_env, ">i32", sext_i32, { fif::fif_i16, -1, fif::fif_i32 });
	add_precompiled(fif_env, ">i32", sext_i32, { fif::fif_i8, -1, fif::fif_i32 });
	add_precompiled(fif_env, ">i32", zext_i32, { fif::fif_bool, -1, fif::fif_i32 });
	add_precompiled(fif_env, ">i32", f32i32, { fif::fif_f32, -1, fif::fif_i32 });
	add_precompiled(fif_env, ">i32", f64i32, { fif::fif_f64, -1, fif::fif_i32 });

	add_precompiled(fif_env, ">u32", trunc_ui32, { fif::fif_u64, -1, fif::fif_u32 });
	add_precompiled(fif_env, ">u32", ident32, { fif::fif_u32, -1, fif::fif_u32 });
	add_precompiled(fif_env, ">u32", zext_ui32, { fif::fif_u16, -1, fif::fif_u32 });
	add_precompiled(fif_env, ">u32", zext_ui32, { fif::fif_u8, -1, fif::fif_u32 });
	add_precompiled(fif_env, ">u32", trunc_ui32, { fif::fif_i64, -1, fif::fif_u32 });
	add_precompiled(fif_env, ">u32", sext_ui32, { fif::fif_i32, -1, fif::fif_u32 });
	add_precompiled(fif_env, ">u32", sext_ui32, { fif::fif_i16, -1, fif::fif_u32 });
	add_precompiled(fif_env, ">u32", sext_ui32, { fif::fif_i8, -1, fif::fif_u32 });
	add_precompiled(fif_env, ">u32", zext_ui32, { fif::fif_bool, -1, fif::fif_u32 });
	add_precompiled(fif_env, ">u32", f32ui32, { fif::fif_f32, -1, fif::fif_u32 });
	add_precompiled(fif_env, ">u32", f64ui32, { fif::fif_f64, -1, fif::fif_u32 });

	add_precompiled(fif_env, ">i16", trunc_i16, { fif::fif_u64, -1, fif::fif_i16 });
	add_precompiled(fif_env, ">i16", trunc_i16, { fif::fif_u32, -1, fif::fif_i16 });
	add_precompiled(fif_env, ">i16", zext_i16, { fif::fif_u16, -1, fif::fif_i16 });
	add_precompiled(fif_env, ">i16", zext_i16, { fif::fif_u8, -1, fif::fif_i16 });
	add_precompiled(fif_env, ">i16", trunc_i16, { fif::fif_i64, -1, fif::fif_i16 });
	add_precompiled(fif_env, ">i16", trunc_i16, { fif::fif_i32, -1, fif::fif_i16 });
	add_precompiled(fif_env, ">i16", idents16, { fif::fif_i16, -1, fif::fif_i16 });
	add_precompiled(fif_env, ">i16", sext_i16, { fif::fif_i8, -1, fif::fif_i16 });
	add_precompiled(fif_env, ">i16", zext_i16, { fif::fif_bool, -1, fif::fif_i16 });
	add_precompiled(fif_env, ">i16", f32i16, { fif::fif_f32, -1, fif::fif_i16 });
	add_precompiled(fif_env, ">i16", f64i16, { fif::fif_f64, -1, fif::fif_i16 });

	add_precompiled(fif_env, ">u16", trunc_ui16, { fif::fif_u64, -1, fif::fif_u16 });
	add_precompiled(fif_env, ">u16", trunc_ui16, { fif::fif_u32, -1, fif::fif_u16 });
	add_precompiled(fif_env, ">u16", ident16, { fif::fif_u16, -1, fif::fif_u16 });
	add_precompiled(fif_env, ">u16", zext_ui16, { fif::fif_u8, -1, fif::fif_u16 });
	add_precompiled(fif_env, ">u16", trunc_ui16, { fif::fif_i64, -1, fif::fif_u16 });
	add_precompiled(fif_env, ">u16", trunc_ui16, { fif::fif_i32, -1, fif::fif_u16 });
	add_precompiled(fif_env, ">u16", sext_ui16, { fif::fif_i16, -1, fif::fif_u16 });
	add_precompiled(fif_env, ">u16", sext_ui16, { fif::fif_i8, -1, fif::fif_u16 });
	add_precompiled(fif_env, ">u16", zext_ui16, { fif::fif_bool, -1, fif::fif_u16 });
	add_precompiled(fif_env, ">u16", f32ui16, { fif::fif_f32, -1, fif::fif_u16 });
	add_precompiled(fif_env, ">u16", f64ui16, { fif::fif_f64, -1, fif::fif_u16 });

	add_precompiled(fif_env, ">i8", trunc_i8, { fif::fif_u64, -1, fif::fif_i8 });
	add_precompiled(fif_env, ">i8", trunc_i8, { fif::fif_u32, -1, fif::fif_i8 });
	add_precompiled(fif_env, ">i8", trunc_i8, { fif::fif_u16, -1, fif::fif_i8 });
	add_precompiled(fif_env, ">i8", zext_i8, { fif::fif_u8, -1, fif::fif_i8 });
	add_precompiled(fif_env, ">i8", trunc_i8, { fif::fif_i64, -1, fif::fif_i8 });
	add_precompiled(fif_env, ">i8", trunc_i8, { fif::fif_i32, -1, fif::fif_i8 });
	add_precompiled(fif_env, ">i8", trunc_i8, { fif::fif_i16, -1, fif::fif_i8 });
	add_precompiled(fif_env, ">i8", idents8, { fif::fif_i8, -1, fif::fif_i8 });
	add_precompiled(fif_env, ">i8", zext_i8, { fif::fif_bool, -1, fif::fif_i8 });
	add_precompiled(fif_env, ">i8", f32i8, { fif::fif_f32, -1, fif::fif_i8 });
	add_precompiled(fif_env, ">i8", f64i8, { fif::fif_f64, -1, fif::fif_i8 });

	add_precompiled(fif_env, ">u8", trunc_ui8, { fif::fif_u64, -1, fif::fif_u8 });
	add_precompiled(fif_env, ">u8", trunc_ui8, { fif::fif_u32, -1, fif::fif_u8 });
	add_precompiled(fif_env, ">u8", trunc_ui8, { fif::fif_u16, -1, fif::fif_u8 });
	add_precompiled(fif_env, ">u8", ident8, { fif::fif_u8, -1, fif::fif_u8 });
	add_precompiled(fif_env, ">u8", trunc_ui8, { fif::fif_i64, -1, fif::fif_u8 });
	add_precompiled(fif_env, ">u8", trunc_ui8, { fif::fif_i32, -1, fif::fif_u8 });
	add_precompiled(fif_env, ">u8", trunc_ui8, { fif::fif_i16, -1, fif::fif_u8 });
	add_precompiled(fif_env, ">u8", sext_ui8, { fif::fif_i8, -1, fif::fif_u8 });
	add_precompiled(fif_env, ">u8", zext_ui8, { fif::fif_bool, -1, fif::fif_u8 });
	add_precompiled(fif_env, ">u8", f32ui8, { fif::fif_f32, -1, fif::fif_u8 });
	add_precompiled(fif_env, ">u8", f64ui8, { fif::fif_f64, -1, fif::fif_u8 });

	add_precompiled(fif_env, ">f32", uif32, { fif::fif_u64, -1, fif::fif_f32 });
	add_precompiled(fif_env, ">f32", uif32, { fif::fif_u32, -1, fif::fif_f32 });
	add_precompiled(fif_env, ">f32", uif32, { fif::fif_u16, -1, fif::fif_f32 });
	add_precompiled(fif_env, ">f32", uif32, { fif::fif_u8, -1, fif::fif_f32 });
	add_precompiled(fif_env, ">f32", sif32, { fif::fif_i64, -1, fif::fif_f32 });
	add_precompiled(fif_env, ">f32", sif32, { fif::fif_i32, -1, fif::fif_f32 });
	add_precompiled(fif_env, ">f32", sif32, { fif::fif_i16, -1, fif::fif_f32 });
	add_precompiled(fif_env, ">f32", sif32, { fif::fif_i8, -1, fif::fif_f32 });
	add_precompiled(fif_env, ">f32", nop1, { fif::fif_f32, -1, fif::fif_f32 });
	add_precompiled(fif_env, ">f32", ftrunc, { fif::fif_f64, -1, fif::fif_f32 });

	add_precompiled(fif_env, ">f64", uif64, { fif::fif_u64, -1, fif::fif_f64 });
	add_precompiled(fif_env, ">f64", uif64, { fif::fif_u32, -1, fif::fif_f64 });
	add_precompiled(fif_env, ">f64", uif64, { fif::fif_u16, -1, fif::fif_f64 });
	add_precompiled(fif_env, ">f64", uif64, { fif::fif_u8, -1, fif::fif_f64 });
	add_precompiled(fif_env, ">f64", sif64, { fif::fif_i64, -1, fif::fif_f64 });
	add_precompiled(fif_env, ">f64", sif64, { fif::fif_i32, -1, fif::fif_f64 });
	add_precompiled(fif_env, ">f64", sif64, { fif::fif_i16, -1, fif::fif_f64 });
	add_precompiled(fif_env, ">f64", sif64, { fif::fif_i8, -1, fif::fif_f64 });
	add_precompiled(fif_env, ">f64", fext, { fif::fif_f32, -1, fif::fif_f64 });
	add_precompiled(fif_env, ">f64", nop1, { fif::fif_f64, -1, fif::fif_f64 });

	add_precompiled(fif_env, ">bool", trunc_i1, { fif::fif_u64, -1, fif::fif_bool });
	add_precompiled(fif_env, ">bool", trunc_i1, { fif::fif_u32, -1, fif::fif_bool });
	add_precompiled(fif_env, ">bool", trunc_i1, { fif::fif_u16, -1, fif::fif_bool });
	add_precompiled(fif_env, ">bool", trunc_i1, { fif::fif_u8, -1, fif::fif_bool });
	add_precompiled(fif_env, ">bool", trunc_i1, { fif::fif_i64, -1, fif::fif_bool });
	add_precompiled(fif_env, ">bool", trunc_i1, { fif::fif_i32, -1, fif::fif_bool });
	add_precompiled(fif_env, ">bool", trunc_i1, { fif::fif_i16, -1, fif::fif_bool });
	add_precompiled(fif_env, ">bool", trunc_i1, { fif::fif_i8, -1, fif::fif_bool });
	add_precompiled(fif_env, ">bool", ident1, { fif::fif_bool, -1, fif::fif_bool });

	add_precompiled(fif_env, "and", bit_and, { fif::fif_u64, fif_u64, -1, fif::fif_u64 });
	add_precompiled(fif_env, "and", bit_and, { fif::fif_u32, fif_u32, -1, fif::fif_u32 });
	add_precompiled(fif_env, "and", bit_and, { fif::fif_u16, fif_u16, -1, fif::fif_u16 });
	add_precompiled(fif_env, "and", bit_and, { fif::fif_u8, fif_u8, -1, fif::fif_u8 });
	add_precompiled(fif_env, "and", bit_and, { fif::fif_i64, fif_i64, -1, fif::fif_i64 });
	add_precompiled(fif_env, "and", bit_and, { fif::fif_i32, fif_i32, -1, fif::fif_i32 });
	add_precompiled(fif_env, "and", bit_and, { fif::fif_i16, fif_i16, -1, fif::fif_i16 });
	add_precompiled(fif_env, "and", bit_and, { fif::fif_i8, fif_i8, -1, fif::fif_i8 });
	add_precompiled(fif_env, "and", bit_and, { fif::fif_bool, fif_bool, -1, fif::fif_bool });

	add_precompiled(fif_env, "or", bit_or, { fif::fif_u64, fif_u64, -1, fif::fif_u64 });
	add_precompiled(fif_env, "or", bit_or, { fif::fif_u32, fif_u32, -1, fif::fif_u32 });
	add_precompiled(fif_env, "or", bit_or, { fif::fif_u16, fif_u16, -1, fif::fif_u16 });
	add_precompiled(fif_env, "or", bit_or, { fif::fif_u8, fif_u8, -1, fif::fif_u8 });
	add_precompiled(fif_env, "or", bit_or, { fif::fif_i64, fif_i64, -1, fif::fif_i64 });
	add_precompiled(fif_env, "or", bit_or, { fif::fif_i32, fif_i32, -1, fif::fif_i32 });
	add_precompiled(fif_env, "or", bit_or, { fif::fif_i16, fif_i16, -1, fif::fif_i16 });
	add_precompiled(fif_env, "or", bit_or, { fif::fif_i8, fif_i8, -1, fif::fif_i8 });
	add_precompiled(fif_env, "or", bit_or, { fif::fif_bool, fif_bool, -1, fif::fif_bool });

	add_precompiled(fif_env, "xor", bit_xor, { fif::fif_u64, fif_u64, -1, fif::fif_u64 });
	add_precompiled(fif_env, "xor", bit_xor, { fif::fif_u32, fif_u32, -1, fif::fif_u32 });
	add_precompiled(fif_env, "xor", bit_xor, { fif::fif_u16, fif_u16, -1, fif::fif_u16 });
	add_precompiled(fif_env, "xor", bit_xor, { fif::fif_u8, fif_u8, -1, fif::fif_u8 });
	add_precompiled(fif_env, "xor", bit_xor, { fif::fif_i64, fif_i64, -1, fif::fif_i64 });
	add_precompiled(fif_env, "xor", bit_xor, { fif::fif_i32, fif_i32, -1, fif::fif_i32 });
	add_precompiled(fif_env, "xor", bit_xor, { fif::fif_i16, fif_i16, -1, fif::fif_i16 });
	add_precompiled(fif_env, "xor", bit_xor, { fif::fif_i8, fif_i8, -1, fif::fif_i8 });
	add_precompiled(fif_env, "xor", bit_xor, { fif::fif_bool, fif_bool, -1, fif::fif_bool });

	add_precompiled(fif_env, "not", bit_not, { fif::fif_u64, -1, fif::fif_u64 });
	add_precompiled(fif_env, "not", bit_not, { fif::fif_u32, -1, fif::fif_u32 });
	add_precompiled(fif_env, "not", bit_not, { fif::fif_u16, -1, fif::fif_u16 });
	add_precompiled(fif_env, "not", bit_not, { fif::fif_u8, -1, fif::fif_u8 });
	add_precompiled(fif_env, "not", bit_not, { fif::fif_i64, -1, fif::fif_i64 });
	add_precompiled(fif_env, "not", bit_not, { fif::fif_i32, -1, fif::fif_i32 });
	add_precompiled(fif_env, "not", bit_not, { fif::fif_i16, -1, fif::fif_i16 });
	add_precompiled(fif_env, "not", bit_not, { fif::fif_i8, -1, fif::fif_i8 });
	add_precompiled(fif_env, "not", bit_not, { fif::fif_bool, -1, fif::fif_bool });

	add_precompiled(fif_env, "shl", bit_shl, { fif::fif_u64, fif_i32, -1, fif::fif_u64 });
	add_precompiled(fif_env, "shl", bit_shl, { fif::fif_i64, fif_i32, -1, fif::fif_i64 });
	add_precompiled(fif_env, "shl", bit_shl, { fif::fif_u32, fif_i32, -1, fif::fif_u32 });
	add_precompiled(fif_env, "shl", bit_shl, { fif::fif_i32, fif_i32, -1, fif::fif_i32 });
	add_precompiled(fif_env, "shl", bit_shl, { fif::fif_u16, fif_i32, -1, fif::fif_u16 });
	add_precompiled(fif_env, "shl", bit_shl, { fif::fif_i16, fif_i32, -1, fif::fif_i16 });
	add_precompiled(fif_env, "shl", bit_shl, { fif::fif_u8, fif_i32, -1, fif::fif_u8 });
	add_precompiled(fif_env, "shl", bit_shl, { fif::fif_i8, fif_i32, -1, fif::fif_i8 });

	add_precompiled(fif_env, "shr", bit_lshr, { fif::fif_u64, fif_i32, -1, fif::fif_u64 });
	add_precompiled(fif_env, "shr", bit_ashr, { fif::fif_i64, fif_i32, -1, fif::fif_i64 });
	add_precompiled(fif_env, "shr", bit_lshr, { fif::fif_u32, fif_i32, -1, fif::fif_u32 });
	add_precompiled(fif_env, "shr", bit_ashr, { fif::fif_i32, fif_i32, -1, fif::fif_i32 });
	add_precompiled(fif_env, "shr", bit_lshr, { fif::fif_u16, fif_i32, -1, fif::fif_u16 });
	add_precompiled(fif_env, "shr", bit_ashr, { fif::fif_i16, fif_i32, -1, fif::fif_i16 });
	add_precompiled(fif_env, "shr", bit_lshr, { fif::fif_u8, fif_i32, -1, fif::fif_u8 });
	add_precompiled(fif_env, "shr", bit_ashr, { fif::fif_i8, fif_i32, -1, fif::fif_i8 });

	add_precompiled(fif_env, "init", init, { -2, -1, -2 });
	add_precompiled(fif_env, "dup", dup, { -2, -1, -2, -2 });
	add_precompiled(fif_env, "copy", copy, { -2, -1, -2, -2 });
	add_precompiled(fif_env, "drop", drop, { -2 });
	add_precompiled(fif_env, "swap", fif_swap, { -2, -3, -1, -2, -3 });
	add_precompiled(fif_env, "if", fif_if, { }, true);
	add_precompiled(fif_env, "else", fif_else, { }, true);
	add_precompiled(fif_env, "then", fif_then, { }, true);
	add_precompiled(fif_env, "end-if", fif_then, { }, true);
	add_precompiled(fif_env, "while", fif_while, { }, true);
	add_precompiled(fif_env, "loop", fif_loop, { }, true);
	add_precompiled(fif_env, "end-while", fif_end_while, { }, true);
	add_precompiled(fif_env, "do", fif_do, { }, true);
	add_precompiled(fif_env, "until", fif_until, { }, true);
	add_precompiled(fif_env, "end-do", fif_end_do, { fif::fif_bool }, true);
	add_precompiled(fif_env, ">r", to_r, { -2, -1, -1, -1, -2 });
	add_precompiled(fif_env, "r>", from_r, { -1, -2, -1, -2 });
	add_precompiled(fif_env, "r@", r_at, { -1, -2, -1, -2, -1, -2 });
	add_precompiled(fif_env, "immediate", make_immediate, {  });
	add_precompiled(fif_env, "[", open_bracket, { }, true);
	add_precompiled(fif_env, "]", close_bracket, { }, true);
	add_precompiled(fif_env, "ptr-cast", pointer_cast, { fif_opaque_ptr }, true);
	add_precompiled(fif_env, "ptr-cast", pointer_cast, { fif_ptr, std::numeric_limits<int32_t>::max(), -2, -1 }, true);
	add_precompiled(fif_env, "heap-alloc", impl_heap_allot, { -2, -1, fif_ptr, std::numeric_limits<int32_t>::max(), -2, -1 });
	add_precompiled(fif_env, "heap-free", impl_heap_free, { fif_ptr, std::numeric_limits<int32_t>::max(), -2, -1, -1, -2 });
	add_precompiled(fif_env, "@", impl_load, { fif_ptr, std::numeric_limits<int32_t>::max(), -2, -1, -1, -2 });
	add_precompiled(fif_env, "@@", impl_load_deallocated, { fif_ptr, std::numeric_limits<int32_t>::max(), -2, -1, -1, -2 });
	add_precompiled(fif_env, "!", impl_store, { fif_ptr, std::numeric_limits<int32_t>::max(), -2, -1, -2 });
	add_precompiled(fif_env, "!!", impl_uninit_store, { fif_ptr, std::numeric_limits<int32_t>::max(), -2, -1, -2 });
	add_precompiled(fif_env, "sizeof", impl_sizeof, { -1, fif_i32 }, true);
	add_precompiled(fif_env, "buf-free", free_buffer, { fif_opaque_ptr });
	add_precompiled(fif_env, "buf-alloc", allocate_buffer, { fif_i32, -1, fif_opaque_ptr });
	add_precompiled(fif_env, "buf-alloc", allocate_buffer, { fif_i64, -1, fif_opaque_ptr });
	add_precompiled(fif_env, "buf-alloc", allocate_buffer, { fif_i16, -1, fif_opaque_ptr });
	add_precompiled(fif_env, "buf-alloc", allocate_buffer, { fif_i8, -1, fif_opaque_ptr });
	add_precompiled(fif_env, "buf-copy", copy_buffer, { fif_i32, fif_opaque_ptr, fif_opaque_ptr, -1, fif_opaque_ptr });
	add_precompiled(fif_env, "buf-copy", copy_buffer, { fif_i64, fif_opaque_ptr, fif_opaque_ptr, -1, fif_opaque_ptr });
	add_precompiled(fif_env, "buf-copy", copy_buffer, { fif_i16, fif_opaque_ptr, fif_opaque_ptr, -1, fif_opaque_ptr });
	add_precompiled(fif_env, "buf-copy", copy_buffer, { fif_i8, fif_opaque_ptr, fif_opaque_ptr, -1, fif_opaque_ptr });
	add_precompiled(fif_env, "buf-add", impl_index, { fif_opaque_ptr, fif_i32, -1, fif_opaque_ptr });
	add_precompiled(fif_env, "buf-add", impl_index, { fif_opaque_ptr, fif_i64, -1, fif_opaque_ptr });
	add_precompiled(fif_env, "buf-add", impl_index, { fif_opaque_ptr, fif_i16, -1, fif_opaque_ptr });
	add_precompiled(fif_env, "buf-add", impl_index, { fif_opaque_ptr, fif_i8, -1, fif_opaque_ptr });
	add_precompiled(fif_env, "let", create_let, { -2 }, true);
	add_precompiled(fif_env, "var", create_var, { -2 }, true);
	add_precompiled(fif_env, "global", create_global_impl, { fif_type });
	add_precompiled(fif_env, "forth.insert", forth_insert, { }, true);
	add_precompiled(fif_env, "forth.extract", forth_extract, { }, true);
	add_precompiled(fif_env, "forth.extract-copy", forth_extract_copy, { }, true);
	add_precompiled(fif_env, "forth.gep", forth_gep, { }, true);
	add_precompiled(fif_env, "struct-map2", forth_struct_map_two, { }, true);
	add_precompiled(fif_env, "struct-map1", forth_struct_map_one, { }, true);
	add_precompiled(fif_env, "struct-map0", forth_struct_map_zero, { }, true);
	add_precompiled(fif_env, "make", do_make, { }, true);
	add_precompiled(fif_env, ":struct", struct_definition, { });
	add_precompiled(fif_env, ":export", export_definition, { });
	add_precompiled(fif_env, "use-base", do_use_base, { }, true);
	add_precompiled(fif_env, "select", f_select, { fif_bool, -2, -2, -1, -2 });

	auto preinterpreted =
		": over >r dup r> swap ; "
		": nip >r drop r> ; "
		": tuck swap over ; "
		": 2dup >r dup r> dup >r swap r> ; "
		": buf-resize " // ptr old new -> ptr
		"	buf-alloc swap >r >r dup r> r> buf-copy swap buf-free "
		" ; "
		":struct dy-array-block ptr(nil) memory i32 size i32 capacity i32 refcount ; "
		":struct dy-array ptr(dy-array-block) ptr $ 1 ; "
		":s init dy-array($0) s: " // array -> array
		"	sizeof dy-array-block buf-alloc ptr-cast ptr(dy-array-block) swap .ptr! "
		" ; "
		":s dup dy-array($0) s: " // array -> array, array
		"	use-base dup .ptr@ " // original copy ptr-to-block
		"	.refcount dup @ 1 +  swap ! " // increase ref count
		" ; "
		":s drop dy-array($0) s: .ptr@ " // array ->
		"	.refcount dup @ -1 + " // decrement refcount
		"	dup 0 >= if "
		"		swap ! " // store refcount back into pointer
		"	else "
		"		drop drop " // drop pointer to refcount and -1
		"		.ptr@ dup .size let sz .memory let mem " // grab values
		"		while "
		"			sz @ 0 > "
		"		loop "
		"			sz @ -1 + sz ! " // reduce sz
		"			sz @ sizeof $0 * mem @ buf-add ptr-cast ptr($0) @@ " // copy last value, dupless
		"			drop " // run its destructor
		"		end-while "
		"		mem @ buf-free " // free managed buffer
		"		.ptr@ ptr-cast ptr(nil) buf-free " // destroy control block
		"	end-if "
		"	use-base drop "
		" ; "
		":s push dy-array($0) $0 s: " // array , value -> array
		"	let val " // store value to be saved in val
		"	.ptr@ "
		"	dup dup .size let sz .capacity let cap .memory let mem" // destructure
		"	sz @ sizeof $0 * cap @ >= if " // size >= capacity ?
		"		mem @ " // put old buffer on stack
		"		cap @ sizeof $0 * " // old size
		"		cap @ 1 + 2 * sizeof $0 * " // new size
		"		dup cap ! " // copy new size to capacity
		"		buf-resize "
		"		mem ! "
		"	end-if "
		"	sz @ sizeof $0 * mem @ buf-add ptr-cast ptr($0) val swap !! " // move value into last position
		"	sz @ 1 + sz ! " // +1 to stored size
		" ; "
		":s pop dy-array($0) s: " // array -> array , value
		"	.ptr@ " // ptr to control block on stack
		"	dup .size let sz .memory let mem" // destructure
		"	sz @ 0 > if "
		"		sz @ -1 + sz ! " // reduce sz
		"		sz @ sizeof $0 * mem @ buf-add ptr-cast ptr($0) @@ " // copy last value, dupless
		"	else "
		"		make $0 " // nothing left, make new value
		"	end-if "
		" ; "
		":s empty? dy-array($0) s: " // array -> array, value
		"	.ptr@ .size @ <= 0 "
		" ; "
		":s index-into dy-array($0) i32 s:" // array, int -> array, ptr(0)
		"	let index .ptr@ .memory @ sizeof $0 index * swap buf-add ptr-cast ptr($0) "
		" ; "
		":s size dy-array($0) s:" // array -> array, int
		"	.ptr@ .size @ "
		" ; "
		;

	fif::interpreter_stack values{ };
	fif::run_fif_interpreter(fif_env, preinterpreted, values);

}

}