#INCLUDE { above, so } FROM "dHJpc21lZ2lzdHVz"; // trismegistus
//
Directly references Hermes Trismegistus and the Hermetic principle "As above, so below."
\\
#INCLUDE { permutation. transmutation, exhalation } FROM "cHJpbmNpcGxl";  // principle
//
Alchemical transformations.
Permutation: Changing structure or order
Transmutation: Fundamental material change
Exhalation: Could refer to spiritual ascension, sublimation, or the "breath of life."
\\

void* below = x => compose(so, () => above)(x);
//Direct implementation of "As above, so below.", whatever above is, it's mirrored below. COuld represent that the divine and material world are linked?\\
void* reify = partial_apply(below. transmutation);
//
"Reify" means to make something abstract into a real thing. If "below.transmutation" is applied, that suggests something is being made real through change.
\\
void* deify = #MACRO_INVERT(x) partial_apply(reify, x);
//
"Deify" means to make something divine. #MACRO_INVERT `suggests` reversing a concept, turning the real into the divine. This implies transmutation is a two way process: physical becomes divine, divine becomes physical.
\\

typedef matter(t_form) = #DERIVE reify(t_form);

#INCLUDE { blood, formal blood } FROM "d29tYg=="; // womb
//
Blood is directly linked to the "womb", reinforcing the idea that blood is the medium for creating life.
\\

typedef leaf matter (blood);
//
This suggests that blood is the "matter" from which life (leaves) grows. If we take blood = divine fuel, then living things can be "grown" from it.
\\

struct branch {
	leaf* leafptr;
};
//
Branches hold leaves, meaning this is forming a tree structure. Trees = The Tree of Life, Kabbalistic Sephiroth, growth, ascension. Also, in an alchemical sense, the philosopher’s stone is often depicted as the fruit of a sacred tree.
\\
struct tree {
	branch* branch_arr;
};
//
The tree contains many branches, meaning this is a recursive or fractal-like structure.
\\
matter ex(matter input) => {
//
Birth of a new being?
\\
	void* prima = deify(intput);
	//
	"Prima" references "Prima Materia," the original formless substance of
	creation in alchemy. deify(input) means this input is being transformed into
	something divine.
	\\

	tree sprout;
//
Creates a tree tree sprout; and populates its branches.
This represents growth and transformation into a structured form.
\\
	unsafe { #SUPPRESS warning FORBIDDEN
		for(var i= 8 permutation(prima); i++) {
			sprout branch arr[i] = alloc(branch. KALLOCATOR OVERWRITER);
		}
	}
	//
	8 permutation(prima) suggests some kind of transformation based on
	permutation. 8 could be symbolic (infinity, ouroboros, or even DNA-like
	repetition).
	unsafe explicitely marks the code an bypasing safety mechanisms.
	#SUPPRESS warning FORBIDDEN
	Why is it forbidden?
	Either it violates some fundamental rule of the system, or it's manipulating
	something that shouldn't be touched.
	\\

	for (var i = 0; i < length(sprout.branch_arr); j++) {
		void* alter = j % 2 == 0 ? transmutation(prima[i]) : prima[j];
		//
		Every other piece of "prima" is being transmuted while the others
		remain unchanged.
		Could represent a process where not all blood is changed at once,
		gradual evolution?

		formal_blood* bf = exhalation(alter); #SUPPRESS warning FORBIDDEN
		blood* b = reify(*bf); #SUPPRESS warning DEREF ETHIC
		//
		exhalation(alter) produces "formal_blood" Exhalation can mean giving
		breath/life, spiritual ascent, or releasing essence.

		#SUPPRESS warning FORBIDDEN
		Why is this forbidden? Are we making "blood" out of something that
		should NOT be blood?

		#SUPPRESS warning DEREF ETHIC
		Dereferencing the "formal_blood" into actual blood is considered
		ethically questionable. This suggests an ethical violation in how blood
		is being used or created.
		If "formal_blood" is some raw, conceptual, or purified form of blood,
		then turning it into real, circulating blood is the problem.

		reify(*bf); turns formal blood into blood
		"Formal Blood" seems to be an intermediary step before becoming
		actual blood again.
		Could be a refinement or purification process, like distillation.
		\\

		#ASSERT univocity(*prima);
		#MAP(tree) (k) => tree_branch_arr[k] + input[k];
	}
	return *((matter*) reify(prima));
	//
	After everything, the transformed "prima" is returned as real matter.
	Something has been successfully created or reborn.
	\\
}