struct Vector {
	~void data,
	uint
		count,
		size,
		_elsz
}

uint VECTOR_MIN_ELEMENTS = 4
uint VECTOR_MAX_GROW = 256

~uint8 NUM_STR = "Num %d\n\0"

/; method Vector
	
	/; init (uint elsz)
		self._elsz = elsz
		self.size = VECTOR_MIN_ELEMENTS
		self.count = 0
		self.data = _alloc(self.size * self._elsz)
	;/

	/; from_cstr(~uint8 cstr)
		self.init(1)
		self.push_cstr(cstr)
	;/

	/; _grow (uint i)
		self.size = self.size + i
		self.data = _realloc(self.data, self.size * self._elsz)
	;/

	/; get (uint index) [~void]
		/; if (index !< self.count)
			return NULL
		;/

		return self.data + index * self._elsz
	;/

	/; push (~void el)
		/; if (self.size == self.count + 1)
			/; if (self.size < VECTOR_MAX_GROW)
				self._grow(self.size)
			;; else
				self._grow(VECTOR_MAX_GROW)
			;/
		;/

		~void start = self.data + self.count * self._elsz
		/; loop (int i = 0; i < self._elsz) [i++]
			~uint8 to = start + i
			~uint8 from = el + i
			to` = from`
		;/
		self.count++
	;/

	/; _shrink(uint i)
		/; if (i !< self.size)
			self.size = 1
		;; else
			self.size = self.size - i
		;/

		self.data = _realloc(self.data, self.size * self._elsz)
	;/

	/; pop
		self.remove(self.count - 1)
	;/

	/; remove (int index)
		/; if (index < 0 || index !< self.count)
			return
		;/

		/; if (self.count > 1)
			/; loop (int i = index * self._elsz; i < (self.count - 1) * self._elsz) [i++]
				~uint8 to = self.data + i
				~uint8 from = self.data + i + self._elsz
				to` = from`
			;/
		;/

		self.count--

		/; if (self.count < self.size / 2)
			self._shrink(self.size / 3)
		;/
	;/

	/; push_char (uint8 ch)
		self.push(~ch)
	;/

	/; push_cstr(~uint8 ch)
		/; loop (ch` !== 0) [ch++]
			self.push(ch)
		;/
	;/

	/; as_cstr [~uint8]
		~uint8 z = self.data + self.count
		z` = 0
		return self.data
	;/

	/; end
		self.count = 0
		self.size = 0
		self._elsz = 0
		_delete(self.data)
	;/

	/; copy [Vector]
		Vector out
		
		out.init(self._elsz)
		/; loop (int i = 0; i < self.count) [i++]
			~int tmp = self.get(i)
			out.push(tmp)
		;/

		return out
	;/

	/; back [~void]
		/; if (self.count > 0)
			return self.get(self.count - 1)
		;/
		return NULL
	;/
;/


# Artifacts

struct Artifact {
	~~uint8 strings,
	uint
		size,
		count
}

/; method Artifact

	/; init
		self.size = VECTOR_MIN_ELEMENTS
		self.count = 0
		self.strings = _alloc(len self.strings * self.size)
	;/

	/; split_cstr (~uint8 str, uint8 split)
		Vector track
		track.init(1)

		/; loop (str` !== 0) [str++]
			/; if (str` == split)
				self.push(track.as_cstr())
				track.init(1)
			;; else
				track.push(str)
			;/
		;/

		self.push(track.as_cstr())
	;/

	/; _grow (uint i)
		self.size = self.size + i
		self.strings = _realloc(self.strings, self.size * len self.strings)
	;/

	/; push (~uint8 str)
		/; if (self.size == self.count + 1)
			/; if (self.size < VECTOR_MAX_GROW)
				self._grow(self.size)
			;; else
				self._grow(VECTOR_MAX_GROW)
			;/
		;/

		self.strings{self.count} = str
		self.count++
	;/

	/; _shrink(uint i)
		/; if (i !< self.size)
			self.size = 1
		;; else
			self.size = self.size - i
		;/

		self.strings = _realloc(self.strings, self.size * len self.strings)
	;/

	/; pop
		_delete(self.get(self.count - 1))
		self.count--

		/; if (self.count < self.size / 2)
			self._shrink(self.size / 3)
		;/
	;/

	/; get (uint index) [~uint8]
		/; if (index !< self.count)
			return NULL
		;/

		return self.strings{index}
	;/
	
	/; to_cstr (uint8 join) [~uint8]
		Vector out
		out.init(1)

		/; loop (int i = 0; i < self.count) [i++]
			out.push_cstr(self.get(i))
			/; if (i < self.count - 1)
				out.push(~join)
			;/
		;/

		return out.as_cstr()
	;/

	/; end
		/; loop (int i = 0; i < self.count) [i++]
			_delete(self.get(i))
		;/
		_delete(self.strings)
	;/
;/