{
	int myArray[] = {34, 23, 78, 41, 7, 87, 52, 36, 29, 42};
	//
	void selectoinSort(int a[], const int &n){
		int i = 0;
		while(i < n){
			int min = i;
			int j = i + 1;
			while(j < n){
				if(a[j] < a[min]){
					min = j;
				}
				j = j + 1;
			}
			if(min != i){
				swap(a[i], a[min])
			}
			i = i + 1;
		}
	}
	//
	selectionSort(myArray, 10);
}
  |  ID  |  PTR  |  INDEX  |   VALUE   |
  :------:-------:---------:-----------:
  |    x |   seq |       0 |
  // array
  |    1 |   int |       0 |        34 |
  			...
  |    1 |   int |       9 |        42 |

  class fun{
		WORD* argv[];
  };

//  | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |
//    1
//	A
//	|
//reserverd bit
//
//	| typename | var-0 | var-1 | var-2 | 
//		byte-0   addr-1  addr-2  addr-3
    Atom:
        +-----atom-----+
        |  +--------+  |
        |  | sor id |  |
        |  +--------+  |
        +--------------+
		>nem tudunk csak atomra ugrani
		>az atomok eddig instrukció fajtától függően határoztuk meg, viszont kreatívabban is lehetne

### Original ###
	Folyamatábra_elem	: "Folyamatábra elem"; atom név
	AD_ID				: "AlgoDetail ID"; atom id ^ ^ ^ \_ elsődleges kulcs
	Ssz					: "?!"; sor id . . . . . . . . . /
	V					: "Változó"; cím
	V_ndx				: "Változó iNDeX"; cím offset	// >>>NOTE1
	VM					: "Változó Művelet"
	func				: "FUNCió"; függvény hívás		// >>>NOTE3
	J id				: "Jump ID"; ugrás célpont; egy atom id	
														//	azt hiszem nyújt egy fajta biztonságot
	(																							\
		V1				: "Változó 1"															 \
		V_ndx			: "Változó iNDeX"; inkonzisztens módon nincs megszámozva	/* >>>NOTE1 */\
		C1				: "Constant 1"                                                             \
	)																								\
	AM					: "Alg Művelet"																 } >>>NOTE2
	(																								/
		V2																						   /
		V_ndx																					  /
		C2																						 /
	)																						    /
	VB1																							\
	CB1																							 \ 
	F1                                                                                            \
	VJ1                                                                                            \
	CJ1                                                                                         	\
	LM					: "?! Művelet"                                                          	 } >>>NOTE2
	VB2                                                                                         	/
	CB2                                                                                            /
	F2                                                                                            /
	VJ2                                                                                          /
	CJ2                                                                                         /

	NOTE:
		>hunglish
		>1*: a változónév alapból magasszintű absztraktció; csak az olvashatóság/parsibleness kedvéért van értelme külön kezelni
		>3*: teljesen redundáns az ugrás mező miatt, hacsak nem a paramétereket is belekódoljuk. 
				ebben az esetben kell egy módszer amivel egy kifejezésben utalhatunk egy tömb N. elemére ami inkonzistens
				a [Név] [Index] oszlop felépítéssel
		>2*: ismétéls; a 2 igazán indokolatlan szám; logikusan vagy 1 feltételt mentek és tovább kezelem,
				vagy végtelelen feltételt határozhatok meg egy sorban; az előbbi a logikus
				az oszlop számok homogenitása miatt

	30 oszlop
	legalább 10 redundáns

### Revoked ###
	enum JMP {
		no,
		always,
		wt,			//when true
		wf			//when false
	}
                                      (IN)                 (OUT)
  | LN | JMP |  DEST  | ASSIGNEMT |   OPR1   | OPERATOR |   OPR2   | COMMENT |
     1     0        i           =          0          0          0  
	 2     3   return           0          i          <    &argv[2]
	 3     0      min           =          i          0          0
	 4     0        j           =          i          +          1
	 5     3        9           0          j          <          n
	 6     3        8           0        a[j]         <      a[min]
	 7     0      min           =          j          0          0
	 8     0        j          +=          1          0          0
	 9     2       13           0        min          =          i
	10     0   call[0]          =       &a[i]         0          0
	11     0   call[1]          =     &a[min]         0          0
	12     1    &swap           0       call          0          0
	13     0        i          +=          1
	14     1   return           0          0          0          0

	9 oszlop
	0 redundancia


		                                         (IN)                 (OUT)
  | Address | PK2 | JMP |  DEST  | ASSIGNEMT |   OPR1   | OPERATOR |   OPR2   | COMMENT |
          1     1     0        i           =          0          0          0  
	      2     1     3   return           0          i          <    &argv[2]
	      3     1     0      min           =          i          0          0
	      3     2     0        j           =          i          +          1
	      4     1     3        9           0          j          <          n
	      5     1     3        8           0        a[j]         <      a[min]
	      6     1     0      min           =          j          0          0
	      6     2     0        j          +=          1          0          0
	      7     1     2       13           0        min          =          i
	      8     1     0   call[0]          =       &a[i]         0          0
	      8     2     0   call[1]          =     &a[min]         0          0
	      8     3     1    &swap           0       call          0          0
	      9     1     0        i          +=          1
	     10     1     1   return           0          0          0          0

	10 oszlop
	az atom fogalma megmaradt -> mivel JT-ben nincs ilyen mekötés ezért értelmetlen megtartani

// can oracle/mysql fork?
// is varchar allocated inline?

since JT is ordered insertion is a nightmare

the deletion problem is actually self evident. an elems life time is as long as we have any data on it.
