From 6836e07a9bad63acfad3ef459da7d47bcc1214ec Mon Sep 17 00:00:00 2001
From: borysr <borysr@gmail.com>
Date: Wed, 22 May 2024 22:25:06 +0200
Subject: [PATCH 1/2] funkcja alg + main

---
 cpp/._rvmain.cpp.swp | Bin 12288 -> 0 bytes
 cpp/_rvmain.cpp      | 113 ++++++++++++++++++++++++++++------
 cpp/_rvmain.cpp.save | 142 +++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 237 insertions(+), 18 deletions(-)
 delete mode 100644 cpp/._rvmain.cpp.swp
 create mode 100644 cpp/_rvmain.cpp.save

diff --git a/cpp/._rvmain.cpp.swp b/cpp/._rvmain.cpp.swp
deleted file mode 100644
index e6a5d76642f44fb5aa19862644f39b8a97850836..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 12288
zcmeI2&u`pB6vrn>v_ep*Xs$&siAcP0ySqtKN}6oi2q6?HG(uH-V2KjPJKIdxv0dAn
zCA&(09IGHCH~<F@RpErx6aPXFoVal+;tyy72YRZ6M87j0H=&h+lv69cQ9iLf^XB=@
zXJ!vkcBOiG?qixPR|VQpA+EU>n)T^rv35v^b}AFy{eSJuxb()W^3>$S%IW=Luj_=B
zPL#ANfwxle<M?Enc}a#&+*g*8^)*k0W!&$Vg~!+c8#tJOBjVKfnE9v=4Gz$;w=W$m
z4bNf&Y=8~00XDz}*Z><~18m@>G?2x8;sz>z#a2ISuYJ#4?IT~<02^QfY=8~00XDz}
z*Z><~18jf|uz{D*fY%V>)z^g>cmu`b|Nq6`|2uC9u?>C$_rX1I2Yd;>09#-Uw7@4|
z0h|HvfqwAlO(FgUe}Lb?18^Vw1bzfRfV&_8%itq$7Pz1U954d@IU>Yk@C*13d<(t-
zx4=yhg9yxm^PnI6i?#d(eg!{+@4?sLE3gG_gC6LDb6^HkK?Rh-5YRr}0ms2%@FyJY
zfNk&)aAN~(fDNz#Hoykh02^QfFSdcr12*wmBC~c9(%2LhNN8Sg#YwZIglGNeuX+iM
zqJwHQIM<|(7vd|uvO$Rqyi7$Qg%PFgBu-Q+DQaSVFo?M-%t(LX*C|nt#HPu$nWxlg
z^A3Hdn;*3iUZd)iFwgcEQbj&FW)$`89m>m!$1rI)t-G$jxI4Z{GC(c8|4z`aaNXS~
z)g&ja`-?Py_kKQJrQu;Jo<}~bj-c+m+-8)JgXO%xl#y?W#AUiha1zMSNlR1YyYAC)
zQ<*6l7S<!x&_=O{+@lE-l}e!e?gptKN_|R$sN<1BT-0h`l@xnxO8V3YJPMV(5|t6(
zNn2hwR4u}i&Ako`J&Kh~I%(IVKw(?FJl6?Kz)!Osw*0FYdM+(;HIO)uE@R{EcG$B}
zY=ae<d$eO_PhvVr;S}Wqw#TiZEAP>2P47y(NiNOK&o6v%aqiO(G0O(eAlMv?T=DK{
z2nl&65a@*TE=|~7*9pzD*{pnGPvlBXM!i2eqY(Jcd8T}OZ0*}>`D;-PYTg@A6j^^-
z;vyo%P(wCVDEAaTRz)i;byig%$r(*u7sp`~rwV2E^1a5P@Z*hQw@=tQvQnYgTGRs5
u-Ln`M2eU{W>xG(AXpGv^j<;cwUaCENdk@u+3jLtnkTjiU4aAgJXT%e8a&7DY

diff --git a/cpp/_rvmain.cpp b/cpp/_rvmain.cpp
index 53c49d3..fa5d9e2 100644
--- a/cpp/_rvmain.cpp
+++ b/cpp/_rvmain.cpp
@@ -31,35 +31,112 @@ char *alloc(int n)
      return 0;
 }
 
+// def. model danych
 
-//funkcja lokuje pamiec dla kazdego slowa.
+//pre processor
+#define LEN (8+2)*10
+
+struct model {
+    char *      str;
+    uint32_t    len ;
+};
+
+
+//alg
+// prosta implementacji func. z bibl. std. strok przy uzyciu  gpt3.5
 //
-//wskaznik p1 wskazuje na pierwsza litera slowa,
-//liczy ilosc slowa i alokuje pamiec dla niego.
 
+#define NULL ((void*) 0)
 
-void alg (char *s) {
-
-    char count;
-
-    for (int8_t c = 0; c <= strlen(s); c++) {
-
-        if (s[c] != 0x20 && s[c] != '\0') {
-            count++;
-        } else {
-            char *p1 = &s[++c];
-            alloc (count);
-            count = 0;
+//
+// Funkcja pomocnicza do sprawdzania, czy znak jest wśród delimiterów
+bool is_delim(char c, const char *delims) {
+    while (*delims) {
+        if (c == *delims) {
+            return true;
         }
-
+        delims++;
     }
+    return false;
 }
+
+// Najprostsza implementacja funkcji strtok
+char *simple_strtok(char *str, const char *delims) {
+    static char *static_str = (char *) NULL; // Przechowuje wskaźnik do bieżącej pozycji w ciągu
+
+    // Jeśli przekazano nowy ciąg, zaktualizuj static_str
+    if (str != NULL) {
+        static_str = str;
+    }
+    
+    // Jeśli static_str jest NULL, zwróć NULL
+    if (static_str == NULL) {
+        return (char *) NULL;
+    }
+
+    // Pomiń początkowe delimitery
+    while (*static_str && is_delim(*static_str, delims)) {
+        static_str++;
+    }
+    
+    // Jeśli doszliśmy do końca ciągu, zwróć NULL
+    if (*static_str == '\0') {
+        return (char *) NULL;
+    }
+
+    // Zapisz początek tokenu
+    char *token_start = static_str;
+    
+    // Znajdź koniec tokenu
+    while (*static_str && !is_delim(*static_str, delims)) {
+        static_str++;
+    }
+
+    // Jeśli znaleziono delimitery, zamień je na '\0' i zaktualizuj static_str
+    if (*static_str) {
+        *static_str = '\0';
+        static_str++;
+    }
+
+    // Zwróć początek tokenu
+    return token_start;
+}
+
+////func alg
+//in:       ptr to date
+//return:   count of words
+int alg (const char * ptr) {
+
+	char bufer[ALLOCSIZE];
+	strcpy(bufer, (char *)ptr);
+
+	const char *delims = " ,.!?:;\n\t";
+
+	int8_t  count = 0;
+
+	char *token = simple_strtok(bufer, delims);
+	while (token != (char *)NULL) {
+		count++;
+		token = simple_strtok((char *)NULL, delims);
+	}
+	return count;
+}
+
+
 int main() { 
 
     char *str = "If wantered relation no surprise of all";
 
-    alg(str);
-
+   struct model *ptr = (struct model *) alloc(LEN);
+	if (ptr != (struct model *)NULL) {
+		ptr->str = alloc(strlen((char *)str) + 1);
+		if (ptr->str != (char *)NULL) {
+			strcpy (ptr->str, (char *)str);
+			ptr->len = strlen(ptr->str);
 
+			int8_t count = alg(ptr->str);
+		}
+	}
+ 
 	return 1;
 }
diff --git a/cpp/_rvmain.cpp.save b/cpp/_rvmain.cpp.save
new file mode 100644
index 0000000..b986dde
--- /dev/null
+++ b/cpp/_rvmain.cpp.save
@@ -0,0 +1,142 @@
+#include <stdint.h>
+
+int strlen(char *s) {
+    char *p = s;
+    while (*p != '\0')
+        p++;
+    return p - s;
+}
+
+void strcpy(char *s, char *t)
+{
+     while (*s++ = *t++);
+}
+#define ALLOCSIZE 10000
+
+static char allocbuf[ALLOCSIZE]; 
+static char *allocp = allocbuf; 
+
+char *alloc(int n) 
+{
+
+    if (n % 4 != 0) { 
+        n += 4 - (n % 4);
+    }
+
+
+     if (allocbuf + ALLOCSIZE - allocp >= n) { 
+     allocp += n;
+     return allocp - n; 
+     } else 
+     return 0;
+}
+
+// def. model danych
+
+//pre processor
+#define LEN (8+2)*10
+
+struct model {
+    char *      str;
+    uint32_t    len ;
+};
+
+
+//alg
+// prosta implementacji func. z bibl. std. strok przy uzyciu  gpt3.5
+//
+
+#define NULL ((void*) 0)
+
+//
+// Funkcja pomocnicza do sprawdzania, czy znak jest wśród delimiterów
+bool is_delim(char c, const char *delims) {
+    while (*delims) {
+        if (c == *delims) {
+            return true;
+        }
+        delims++;
+    }
+    return false;
+}
+
+// Najprostsza implementacja funkcji strtok
+char *simple_strtok(char *str, const char *delims) {
+    static char *static_str = (char *) NULL; // Przechowuje wskaźnik do bieżącej pozycji w ciągu
+
+    // Jeśli przekazano nowy ciąg, zaktualizuj static_str
+    if (str != NULL) {
+        static_str = str;
+    }
+    
+    // Jeśli static_str jest NULL, zwróć NULL
+    if (static_str == NULL) {
+        return (char *) NULL;
+    }
+
+    // Pomiń początkowe delimitery
+    while (*static_str && is_delim(*static_str, delims)) {
+        static_str++;
+    }
+    
+    // Jeśli doszliśmy do końca ciągu, zwróć NULL
+    if (*static_str == '\0') {
+        return (char *) NULL;
+    }
+
+    // Zapisz początek tokenu
+    char *token_start = static_str;
+    
+    // Znajdź koniec tokenu
+    while (*static_str && !is_delim(*static_str, delims)) {
+        static_str++;
+    }
+
+    // Jeśli znaleziono delimitery, zamień je na '\0' i zaktualizuj static_str
+    if (*static_str) {
+        *static_str = '\0';
+        static_str++;
+    }
+
+    // Zwróć początek tokenu
+    return token_start;
+}
+
+////func alg
+//in:       ptr to date
+//return:   count of words
+int alg (const char * ptr) {
+
+	char bufer[ALLOCSIZE];
+	strcpy(bufer, (char *)ptr);
+
+	const char *delims = " ,.!?:;\n\t";
+
+	int8_t  count = 0;
+
+	char *token = simple_strtok(bufer, delims);
+	while (token != (char *)NULL) {
+		count++;
+		token = simple_strtok((char *)NULL, delims);
+	}
+	return count;
+}
+
+
+int main() { 
+
+    const char *str = "If wantered relation no surprise of all";
+
+   struct model *ptr = (struct model *) alloc(LEN);
+	if (ptr != (struct model *) NULL) {
+		ptr->str = alloc(strlen((char *)str) + 1);
+		if (ptr->str != (char *)NULL) {
+			strcpy (ptr->str, (char *)str);
+			ptr->len = strlen(ptr->str);
+
+			int8_t count = alg(ptr->str);
+		}
+	}
+ 
+	return 1;
+}

From 8bf34d9bad8847fc98a3fab1987fff6064187842 Mon Sep 17 00:00:00 2001
From: borysr <borysr@gmail.com>
Date: Thu, 23 May 2024 18:16:34 +0200
Subject: [PATCH 2/2] =?UTF-8?q?usuni=C4=99cie=20problemy=20z=20kompilacj?=
 =?UTF-8?q?=C4=99(Makefile)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 cpp/._rvmain.cpp.swl        | Bin 0 -> 12288 bytes
 cpp/._rvmain.cpp.swm        | Bin 0 -> 12288 bytes
 cpp/._rvmain.cpp.swn        | Bin 0 -> 12288 bytes
 cpp/._rvmain.cpp.swo        | Bin 0 -> 12288 bytes
 cpp/._rvmain.cpp.swp        | Bin 0 -> 12288 bytes
 cpp/Make.rules-kopia        |  81 ++++++
 cpp/Makefile                |   9 +-
 cpp/Murax.scala             | 543 ++++++++++++++++++++++++++++++++++++
 cpp/_crt0.S                 |   3 +-
 cpp/_crt0.S-k0              |  42 +++
 cpp/_crt0.S-k1              |  39 +++
 cpp/_rv-diss                |   1 -
 cpp/_rv-readelf             |   1 -
 cpp/_rvmain.cpp             |  47 ++--
 cpp/_rvmain.cpp.save        | 142 ----------
 cpp/gdb/z.py                |  17 --
 cpp/gdb/zero.py             |   5 -
 cpp/murax_128k_ram-sp.ld    |  43 +++
 cpp/murax_128k_ram.ld       |  67 +++++
 cpp/murax_128k_ram.ld-kopia |  13 +
 cpp/myfuncOOP.cpp           |  38 ---
 cpp/myfuncOOP.hpp           |  22 --
 cpp/myfuncStruct.cpp        |  29 --
 cpp/myfuncStruct.h          |  15 -
 cpp/myfuncStructOOP.cpp     |  44 ---
 cpp/myfuncStructOOP.h       |  21 --
 cpp/tracked_files.txt       |   5 -
 cpp/try/3.py                |  16 --
 cpp/try/__os-build          |   1 -
 cpp/try/__os-run            |   1 -
 cpp/try/main.cpp            | 155 ----------
 cpp/try/uri.cpp             |  53 ----
 32 files changed, 862 insertions(+), 591 deletions(-)
 create mode 100644 cpp/._rvmain.cpp.swl
 create mode 100644 cpp/._rvmain.cpp.swm
 create mode 100644 cpp/._rvmain.cpp.swn
 create mode 100644 cpp/._rvmain.cpp.swo
 create mode 100644 cpp/._rvmain.cpp.swp
 create mode 100644 cpp/Make.rules-kopia
 create mode 100644 cpp/Murax.scala
 create mode 100644 cpp/_crt0.S-k0
 create mode 100644 cpp/_crt0.S-k1
 delete mode 100644 cpp/_rv-diss
 delete mode 100644 cpp/_rv-readelf
 delete mode 100644 cpp/_rvmain.cpp.save
 delete mode 100644 cpp/gdb/z.py
 delete mode 100644 cpp/gdb/zero.py
 create mode 100644 cpp/murax_128k_ram-sp.ld
 create mode 100644 cpp/murax_128k_ram.ld
 create mode 100644 cpp/murax_128k_ram.ld-kopia
 delete mode 100644 cpp/myfuncOOP.cpp
 delete mode 100644 cpp/myfuncOOP.hpp
 delete mode 100644 cpp/myfuncStruct.cpp
 delete mode 100644 cpp/myfuncStruct.h
 delete mode 100644 cpp/myfuncStructOOP.cpp
 delete mode 100644 cpp/myfuncStructOOP.h
 delete mode 100644 cpp/tracked_files.txt
 delete mode 100644 cpp/try/3.py
 delete mode 100644 cpp/try/__os-build
 delete mode 100644 cpp/try/__os-run
 delete mode 100644 cpp/try/main.cpp
 delete mode 100644 cpp/try/uri.cpp

diff --git a/cpp/._rvmain.cpp.swl b/cpp/._rvmain.cpp.swl
new file mode 100644
index 0000000000000000000000000000000000000000..1080c395311c7737c4867a39fcbc7f858bcef4c9
GIT binary patch
literal 12288
zcmeI2U2Ggz8HP{zcYi2Qgs4Q(@dlc;*X(YbgrspDgrXD$Od1JVq{P9DXUFmE&dv-o
zvsrd6LoXT?@l&p71u3W!2!R9=kPD)Ms6_3HqM}HF3UUS9Py|K2fZT9Xp6{HQ?An9`
zDOZIV>se>coS*l+-#6zRE4$o$=;%lFz4fNzdW%w*+YhX?(?zxGR;7BWmq_uAuKlx~
zGu!m`+`D&q-}UN#Ryu6-qomVt<Jhp2oas7#Sm*wFEz4)61Em8u@4)S9&+KmVs_(2!
z>O0@|;LUeg_E0)dI#4=LI#4=LI#4=LI#4=LI`FD-Ad7dX&!P4;x#F+pzjti=o!^$f
zN(V{@N(V{@N(V{@N(V{@N(V{@N(V{@N(V{@UWE=gEv0_UAOG)uJ>vQQ|Kjiem+nyN
zukZqFzz^UlcnrP-UxWyj;6rc(4nrN@0dI#p;mVtp`a4{P-@-HSb9fTgU<fPF0v8rw
z7G|IZ)9}yRmHIPWgkQjU_!0aN&cWB=3($iMJU9*qVL!Yd_CW*wa+^{w!k^$*@H{*R
z55vdd5L93SUg0|se}fm{1^6{wg73hm;WoGxF5aTl1^5gkun3=k!>||bfZt3oZ@2*G
zVGS1H5FCL0@J{&0o0NJPF2UpQFbrV;Rd_30d81Olhs*FgxBySVH{l!bBzzf8!ErbM
zcY}gg-oSj|m+%~X8@>f!fycmsPr-dK2Y12C<i<<z6Zk%S555augD2o|_&huc3-A$`
zhZ(4W2Fb6x;azYS+yYl#$2{N?T!iQ02}t37cn|D=KfYF}Kfp8aQ@8;C&)52mFEx>P
zSueS9#sA?N;=%g5x~UoFK8AYt9C^&;q+MODgi&0XnzIGL>1vuK+?iW<)k*X;1$tgr
zj;`pw6J}oGwRGYIPUc6U4kMlRk~r~GPe&`-34#i3{V>z=O{nUWUeijgUme(udSOO|
z35q7nO|51}7CBke@j`}5{caq1ON>iNwQ5yN9eZ$LVMe#S!0)CAoR}~YrJY>yNz>h_
zdSJWA68=#&J?3+>^~P%2d6_EteEX|@;Az`RPtNP{p_vN0t(I#GUGA-T$(TYlfe#0k
zGOdj?Cf1axyHS{C+ID1TBkt;%`s4==&Mk(EnK(FsI5!?t^F9k9v5AdUVIH0Q;KITK
zhd*}o#F10965pNRG`h#e(9#I;jfQ!P!h;xL1rad5zt&25<eOq+B+<?y-EuOI@<wB&
z7rN4^LQ&5pt`Va3w2o0NxiVHZrO`B}8;$tn?o-Olkb;xDn@tf%8c6?EgpD;Jb`tVI
z${P)RqMtl_e&bOcNA7UrZ02=rt)5Lr+gz&BD)U{*kMZmwPm5xt?OJT^vK{*?x;pku
ztdLF^@5A2axxm-M&<VUD+03jZyL@tdFr$Y~*Y`Fb(QQwMj_FTR*Xd+EC-8^8_Lz(t
z3(PZXOozVb9zE%&OJ>M%fmbtVOzDZxX}30?)}1KyJ-4t$rlI6xEGw<07%*~U<gXL^
z>F|d3<`F7#PRomTO)K@h^?6KaZfPq@hk?I&t~=1J2-Ta9xQ=%HjkBkF7@LP#`Ze;+
z$MwQ{ZTJ3L^NvSdpE%}O)rtDvSe(t+<bu6ES=?5*ug`R2XW6fqGV?L=)EJytS4PUO
z>6~O5sj7*b?x!7x)G-+~Y&lXiIXP+imNb=Wcq+#HyQgt7^l0snreV|{SUV+6|8quK
zy?J_U5x+IKBJnugyQ@)O)QQZ^r$fIZ(Oc#%_}Ru;*K1?paNxFm-Opob-|^|K>$Ocr
zrZU4avwf+PX))L_ryVCznx#WWo5jBCg_+~F9nEsnks)Z$D!XmbSaE{X+itpDL&sNw
zQ9v|TvEU@Vyr~q5+pc&$ZJQT%7nwFHU5=taUrjYLIrlm<yWi+{u&Numq3<$5JWS)n
z>9>fT@6dKQkTs{n%ECs_-#o{v*BYhdv*-I*q}0xqx8jGM$p&4mo{9X{^ptK+arAG9
zhsMCI_W5F;Th~K^wj9(ku_Yf#)S)(`_6VQf)B1Fr?Wymh6Is{s*jn0S``9xp`<2$R
zi`r5fPAQXxmz3vYwC1mkbS@k@rmF{Pvs2T2DU&@Q@kFBQrD?<$uMy0A>iPCT>JQx2
zBDzJ0*dEO=>)IpEc4;e~ak7ZqSiet)bNPe3q&82HZ6`rBrR+Mormt>|w8|?VqB5c8
zOk!G$5+&61vzLn1P`_92&5sPyp}CjCK+`r{%ah*pSd|@@9y#Wl%_o1=^3mq)ux3--
zQlStzzI)S05%H05w$5fV-#B%Vn`y1a@-v;)YRFtuk{A*hIWFYy9yw-CZW+m9=hz>}
z+bp|+oQqg#><lI3aze=;O91%EL!MH<@=)Nk25I1&sm$49UDQr9Ia*B>MsT9alKtE3
zZr$xAaA_VTLL3)wYcZu*43;f>%EZMAkP`-t#9}MEn4Y|>YNsE%L9gZM`^a+Y)K?Fw
Fe*yJzWu*WB

literal 0
HcmV?d00001

diff --git a/cpp/._rvmain.cpp.swm b/cpp/._rvmain.cpp.swm
new file mode 100644
index 0000000000000000000000000000000000000000..ee08e76f78961876ed0fed3da5cfdf4038170c34
GIT binary patch
literal 12288
zcmeI2zfTlF6vqcEe<4II)L0Bh47<1d*gfDP;*k(SL4vU$U=)QcdwXHw*xT&x0p|s+
zETr&nFn0bZv`|WkwT-d#M}x7^!a`%Bg??vljynj!f{OSy`LMTdXWqQ`ncd=Y%$O4+
zmv~>N#c(t;Hq@HTrB}b5Y(B_XF>*r@{?}od*`99Kae7U+cek;(M8dA6LO9>$1c78a
zTwJg{zZ2KH&7^x|fDG*2K;w9K$}&Zs)<g?GaeRF5DJcUPAOmE843GgbKnBPF86X4u
z#y}i2u-mBifU0;{og22D)g_(C02v?yWPl8i0Wv@a$N(8217v^<kb!+@z|JzZc9^k^
zBPbrf|5v~Ne{Evy3wR6GzzgsI+z0o-BFKZQ;0l-k=Rq2r1!ur%a0)Q+=NMxjz<clx
ztb-@uF<1q6K@mhC1e0J8^n(ka4;%tN8yWiu-hfwN9lQk3z*BGs%z+6o4w9e={65Oq
zFR%e#gXiE8cnD^|C`f|@XaPUq<2(2aJ^|@xAMP)eOa{mR86X2>fDDiUGVuQySYaGT
z=*Gp+=T<+Hmm;JkgE$=1J4+cJ#bMs{xfWQup)Rx_rPmF%qXjMD7lH(WVzM~I^p1g2
z##~OB+oQ{fT6IyZP;_D*6g)rX$;w=w;o8=?&h31@;AoL|(=FsQIa=5Id9CP`+CriP
zWV6!KF)!^LUap0=EL5%~+^I2)b%GLfq}oN3LWEdM9L}sA%KB5NUKK0lX>#C}T6axt
z$<)?PsjVGSTNMq$p7@t(P3Ig<RQ9&IxmDdO+|5TWXR=_m@v_u_cW@sz<qZ`vG6+>7
zUXE)rI#bMXgAb05ULG17xi*YhYVZIC>%5HpkTcZsNau6p>A^tF=jV8j>PjS(*Ssae
z&C0|wt0<HiHPH_;;+tP=$DX6~s@0TWR3o2&DOooDR6k6y$!ci(`35SiPg!kia<i!$
zB4=yX&3V3C*Q#aWz+~0h(yW(v@uozEflW!qhJn_~Y_Z^F#e0IMM60wDwX51=eRHx>
zFRVvOabOtgQ#ErS+_YUc+jJ(IsH6+98s?Ol5QK&Bc2*Zc{>_IF&n5;Y<_k-9KAQKu
iM1TD~@f;=QY~P(noV9wslP_jneld!(NZUC(!2SZ9@K1IC

literal 0
HcmV?d00001

diff --git a/cpp/._rvmain.cpp.swn b/cpp/._rvmain.cpp.swn
new file mode 100644
index 0000000000000000000000000000000000000000..d0b40fbbb6019a04fa7498f224d80ed3cebe972b
GIT binary patch
literal 12288
zcmeI2!B5jr9LFD+=s{4U-qi5eFtjVMb<PRS5sV=b#dsi^h#1m!T_}vUX**ypz#UJ<
zzrYw1<H5Tg^ncKJ(1Y<P(SsK+p8US{jSaHkffLE^C7*Tuz4w0o{XT6^TPbsY>JA?p
z(HX`m#<nL1Dwnr@pItf1SS_%85&qv8%at-_K5Lcox%_@>H$=kps_QSMP0x#%_g9t;
z+Zn<6emiN743L3?8|Y=1vU*13NhbRFnbY?Uo{}<<0Wv@a$N(8217v^<kO4AqXbgm2
z7u!U&-Lm2ddF<MAl&5qc17v^<kO4A42FL&zAOmE843GgbKn4z>0i(=V-*LvS^q_eB
z{y!mm_;r%8pWrii2i}60;01UJ>c9naU=}<81uzEszy)v~oC8NdH~4;nu@B%qcnw~G
z=U@wXU=f(01hRmGW8iNuY608e2lxuUfH&Y7*aRD328@CMkOV#85BmBBK7o(m38;a2
za2wnLQ{X1J3Pyo&kq0!$02v?yWPl8i0Wv@a$N(9L4XiVc;ag$Nceq{<K@kwc2$q$E
z<9Z3Tz@h*?ywIN+9<LWOYuU`+=o+GWTQms$ni+D>wVjZs;=R1cmECcb8`Y|7DuMmj
zaw|%-T2%|YRmXbkLZS?0)AREouXhfwwZgkD)MzE_)EL&9UY#pmc1SdtZR^=wF#M?g
zEUK5qhJMv@lxX3uTK7$@N2&Ersr3%2^;m<jC;nTlsGOsT_=Yv_SX1{px2l1~nGn>R
zi%RwQFn3@xnvfB#h)^7{D_n`9rCNn+{QC6t-5WDgvy<2*7ms7H${X^2q|(toSp<?g
z9NBVMt~mT6&&l3I+UT737kMVyE(%DeScAnnqwI?44cQqBLL;<I-Ztkoji55r-@c$(
z@WY*QABpEBS+**+W3@G*XE4}~v(*K=YH=kMXd05ILQO-t4YuOiWgg#uB`zQsl9hz&
z&Sv?F2%mwJ=V_Y!*39gQeh23=gKDHnW)ZDmPlJheaUt>O$O|EV{4IJt!~>RCa#xLN
iuw*9+?Nj0bNh}%;qAY1UX0=wf__ZJ`Bj?D%IQs_$gEi&=

literal 0
HcmV?d00001

diff --git a/cpp/._rvmain.cpp.swo b/cpp/._rvmain.cpp.swo
new file mode 100644
index 0000000000000000000000000000000000000000..afb7b4f5d5178c0e319ad1b35eda4e5ab73a16e9
GIT binary patch
literal 12288
zcmeI2&u`mg7{}jo07mHwlt18U3agWBNt{w>6;d&+MHGg1n8tx_4A*g}6UR2TQ#Xyu
zkk~Y7hm8p|Y2pBvapJ}#*mhipgtT2a@FyU|&vN6yf$wWORR~=Z6$xq5^GcuEexDzH
z{Cyr*t&-)!8;h^gY_1@%o)F^4`Be36YwPJhzj|0SeZ!O6{nopFpy~B~UP8Pl6Xrw5
ztLJq!ue)x<X>YZmnRX7>{Zp_9E5HiuMS*5eJv1|NVydV{ulhu4oW`Cyv6oC7!wRqh
ztN<&(3a|pK04u->umTUL0)aau&Y<>(lKP)Zjzc}i<dP4p04u->umY?AE5Hh{0;~Wl
zzzVPetN<(U04ktWgiwa@(f{Kp9-ser{{R1FREVF!H{f${4O|A7zy>hD5_ko?3>Ls7
zcoqzUec(~>2>5-!5Wj)zU=4)eB`^p68WG|runDe#E8t`B5jY3Vf)Bu3U>3}PNw9@_
ze*m9>3*c=~1{v@S7zbnENg$u?J3QmJ;1;+Ez5t(s%iu%sKB$3tkOJf2*T;mo0lo&8
zz(w#HcomF-KlY&x@IAN(?gCz{04u->umY?AE5Hi;zY1&!BF_k#qI2Teq?Yj4n8@d8
zIyWt=xvz<^cDMSW=AL!~kCX$AwS#n^(Mp$OW-LGKlX=%z%_T)<96ZP1o?Vsh<>>~v
z(O_wJ_Uhg3y<K;=dVRZXrEMclw$K07{<u{;bg>f?g~me^2V*8^sz|uklq#dQZG{rH
z3h~wk8J2HQK10i%R;Pw()O=l|OkPlNHg=I?iHw?MIl4=S$Sz5Dd~?_{$c;T`V$Z}S
zTZRwfUx;_jDk+g=xml$w9X@*W*pcIlZ!REJ5-^8=G__?~6maJg-6Y@Kyc*|z9tJF-
zuV@}+q6o#b0~rDT_0ZE$Z|K*xJ2!2!P8El2TDP_O?JvV90nt*Zz2m^97EcyV34vsB
zE^>=hj%y&r4?N4TNx@4}OsBh@)E%8vI0+#Ok>7z<(nRgJ6G)#ZCUur;7mcO4zrNDz
zpW4cu|D<bsuX+kJJ}~t}!lbH1MKm~?jk;qQH5*-VEc|qx^_E_XW~w_j3Pr@y_CTD9
zf?chF-fy0#ilrsZ!8D4AicvLfqicNB0v388UnZ<@#k34kGJZCThGl|m7Qf=!V%0G#
z7*<brTT0w^|6o#lfDR_XNe|?B`$^Z_Y&JRTWOix1Op_-IlhJr|rpU$J5YvukA)cbn
wjgVh=Y(MDCTYMoW3^6ISm@3`JE=MkvOf8(mglX$mvtrPTeo(>8<yPjz-ww#}%>V!Z

literal 0
HcmV?d00001

diff --git a/cpp/._rvmain.cpp.swp b/cpp/._rvmain.cpp.swp
new file mode 100644
index 0000000000000000000000000000000000000000..e06101101d17e477f5bb2249e71bdf7b73952042
GIT binary patch
literal 12288
zcmeI2yKfv-6o-$IB4H8(B1%JbypgP(@n&adZKFiaMnNC}MIJ6l5o=}5?#|l7?mRS)
z>?3jl4O9p^koW_TC`i(#1R{YH5LGGy1&=f-Qc#op?mWDX6D5wKAVoS?`aHUG&%Jx*
zyXTH<d0VwJ@15WyRg=(OC3^ec{oOtEG5tPEltgx@Za=P>Z!9h?)LSj9ySVhI*b8bw
zW8jB9qa6e(YvDQ9a=a?~kD4iCVn7T$y@458sGBvl&cV_w?|<$6r(aT55CdXB42S_S
zAO^&M7!U(u;JGmn2UBzr*}jlxd?LS2?YQP$xrhNVAO^&M7!U(uKn#chF(3xSfEW-1
z&!GXUL-f&$L_bd>dHnys`1}9%D@1>SpTLjc8{h*E%mW=v0Rq=wCi)V50TOTu903|A
zgV(_fxI07iAGiZ<fxp3D;0m}5J_nzHiy#E+;4D}Hr@%?D2o}KIeMH}b@4#hn3499H
z!3sDH-U4re<Dd>qum{}OOY}7uf&q93OoN**5q%3j1S{Y)Fu(yo;1(SH1O5Ov!EfMK
z@C#7>t^;XeKn#chF(3xSfEf6H4Qvu~XvazDvAK+2YRE8nsfsUUGFmjSg0&zHxjg3%
zD?I0pv}F~L4{=%DO>e4O-Nb8ix$JoH;kB4`Ew)++S0n8WD`a$6o7~{iyLP|tGrrW>
z@649)nJU6{0u0T$<JDSonGK!MA4ENCoP1z&Y=_pE)e!4O8m?#YwPiII(L;8vJZxZv
zv48EWA3ot)5$%q!wwh9ej~*6oZiVN$42$pwa~T$~#lvn}9MLfz56NG<>N!2``0TeF
zyB8-MkAj3TWyfrHi2O`t64yGe<5jcPZ18!rQm-sj7As4e(3E-4a@&QbEL>0Hci|}u
zPetv<)AnQ@=ZVx4tMBZVHRkg~n>3wQT<iw<{;PddZBmL^pV{eh*>deDvexZYr`c!(
zMaOJvq@ub$3N*=g!r=y<);Vh8=lr~*W#yF*;`1<yDo+biFIIx}a&|{6ja|p`JXK7+
zC{9XgEl&0l<(JLf$|$X9&mXW8alC<AbzD1}g?jHhZA<NSY9Kovc_upJSZSG!;z`qo
zQ9F=oQFm2cjItwyd*}?a&g60MFz0-ylb+P#<l#)_0i*O2uvdqktf@UxpRXFJANjT@
zcdD!3m!+=K)bGnvN1|!u_Dt2xqCJCsesEKt-Dav6+~nn0?CC_jo|!KOxTrJ}riyLS
zwbG8dsXwILaO{g!Cg*aOub8c=`THe*y`*m!?2lm_bi8&y>DXLyN2)xl8zr?t7>ULs
S*Y{{E;Aj+gkVkdn7~KPhivlzN

literal 0
HcmV?d00001

diff --git a/cpp/Make.rules-kopia b/cpp/Make.rules-kopia
new file mode 100644
index 0000000..2bd12e9
--- /dev/null
+++ b/cpp/Make.rules-kopia
@@ -0,0 +1,81 @@
+
+ARCH=riscv64-unknown-elf
+GNU_DIR=$(HOME)/riscv/riscv/
+GNU_BIN=$(GNU_DIR)/bin
+
+
+CC=$(GNU_BIN)/$(ARCH)-gcc
+CXX=$(GNU_BIN)/$(ARCH)-g++
+AS=$(GNU_BIN)/$(ARCH)-as
+LD=$(GNU_BIN)/$(ARCH)-ld
+OBJCOPY=$(GNU_BIN)/$(ARCH)-objcopy
+OBJDUMP=$(GNU_BIN)/$(ARCH)-objdump
+SIZE=$(GNU_BIN)/$(ARCH)-size
+AR=$(GNU_BIN)/$(ARCH)-ar
+RANLIB=$(GNU_BIN)/$(ARCH)-ranlib
+
+
+CFLAGS+=-ffreestanding 
+CFLAGS+=-fno-pic
+CFLAGS+=-march=rv32i -mabi=ilp32
+CFLAGS+=  -g
+
+
+LDFLAGS+=-nostdlib
+LDFLAGS+=-Wl,-Ttext=0x00000000
+
+# see: https://github.com/riscv/riscv-gcc/issues/120
+#LDFLAGS+=-Wl,--no-relax
+
+
+
+ASFLAGS+=$(CFLAGS)
+CXXFLAGS+=$(CFLAGS)
+
+CLEAN_DIRS=$(SUBDIRS:%=clean-%)
+ALL_DIRS=$(SUBDIRS:%=all-%)
+
+OBJDUMPFLAGS+=-Mnumeric,no-aliases
+
+.PHONY: all clean world $(CLEAN_DIRS) $(ALL_DIRS)
+
+
+%.bin : %
+	$(OBJCOPY) $< -O binary $@
+
+%.lst : %
+	$(OBJDUMP) $(OBJDUMPFLAGS) -dr --disassemble-all $< > $<.lst
+
+% : %.o
+	$(LINK.cc) $(LDFLAGS) -o $@ $^ $(LDLIBS)
+	$(SIZE) -x -A $@
+
+%.s: %.c
+	$(COMPILE.c) -S -o $@ $<
+
+%.s: %.cc
+	$(COMPILE.cc) -S -o $@ $<
+
+%.o: %.c
+	$(COMPILE.c) -o $@ $<
+
+%.o: %.cc
+	$(COMPILE.cc) -o $@ $<
+
+%.srec: %
+	$(OBJCOPY) $< -O srec $@ 
+
+
+
+
+all:: $(ALL_DIRS)
+
+clean:: $(CLEAN_DIRS)
+
+$(ALL_DIRS)::
+	$(MAKE) -C $(@:all-%=%) all
+
+$(CLEAN_DIRS)::
+	$(MAKE) -C $(@:clean-%=%) clean
+
+world:: clean all
diff --git a/cpp/Makefile b/cpp/Makefile
index e677ff3..1456d22 100644
--- a/cpp/Makefile
+++ b/cpp/Makefile
@@ -2,16 +2,19 @@ TOP=./
 include $(TOP)/Make.rules
 
 LDLIBS=
-CFLAGS+=-O0 -g
+#CFLAGS+=-O0 -g
+# CFLAGS+=-Og -ggdb3
+CFLAGS+=-O0 -ggdb3
 
 LDFLAGS+=-Wl,--no-relax
-LDFLAGS+=-Wl,-Tdata=0x10000
+LDFLAGS+=-Wl,-Ttext=0x80000000,-Tdata=0x80010000
+# LDFLAGS+=-T murax_128k_ram.ld
 
 PROGS=prog prog.bin prog.lst 
 
 all:: $(PROGS)
 
-prog: _crt0.o _rvmain.o myfunc.o myfuncStruct.o myfuncStructOOP.o myfuncOOP.o
+prog: _crt0.o _rvmain.o myfunc.o
 	$(LINK.cc) -o $@ $^ $(LDLIBS)
 	$(SIZE) -A -x $@
 
diff --git a/cpp/Murax.scala b/cpp/Murax.scala
new file mode 100644
index 0000000..2260833
--- /dev/null
+++ b/cpp/Murax.scala
@@ -0,0 +1,543 @@
+package vexriscv.demo
+
+import spinal.core._
+import spinal.lib._
+import spinal.lib.bus.amba3.apb._
+import spinal.lib.bus.misc.SizeMapping
+import spinal.lib.bus.simple.PipelinedMemoryBus
+import spinal.lib.com.jtag.Jtag
+import spinal.lib.com.spi.ddr.SpiXdrMaster
+import spinal.lib.com.uart._
+import spinal.lib.io.{InOutWrapper, TriStateArray}
+import spinal.lib.misc.{InterruptCtrl, Prescaler, Timer}
+import spinal.lib.soc.pinsec.{PinsecTimerCtrl, PinsecTimerCtrlExternal}
+import vexriscv.plugin._
+import vexriscv.{VexRiscv, VexRiscvConfig, plugin}
+import spinal.lib.com.spi.ddr._
+import spinal.lib.bus.simple._
+import scala.collection.mutable.ArrayBuffer
+import scala.collection.Seq
+
+/**
+ * Created by PIC32F_USER on 28/07/2017.
+ *
+ * Murax is a very light SoC which could work without any external component.
+ * - ICE40-hx8k + icestorm =>  53 Mhz, 2142 LC
+ * - 0.37 DMIPS/Mhz
+ * - 8 kB of on-chip ram
+ * - JTAG debugger (eclipse/GDB/openocd ready)
+ * - Interrupt support
+ * - APB bus for peripherals
+ * - 32 GPIO pin
+ * - one 16 bits prescaler, two 16 bits timers
+ * - one UART with tx/rx fifo
+ */
+
+
+case class MuraxConfig(coreFrequency : HertzNumber,
+                       onChipRamSize      : BigInt,
+                       onChipRamHexFile   : String,
+                       pipelineDBus       : Boolean,
+                       pipelineMainBus    : Boolean,
+                       pipelineApbBridge  : Boolean,
+                       gpioWidth          : Int,
+                       uartCtrlConfig     : UartCtrlMemoryMappedConfig,
+                       xipConfig          : SpiXdrMasterCtrl.MemoryMappingParameters,
+                       hardwareBreakpointCount : Int,
+                       cpuPlugins         : ArrayBuffer[Plugin[VexRiscv]]){
+  require(pipelineApbBridge || pipelineMainBus, "At least pipelineMainBus or pipelineApbBridge should be enable to avoid wipe transactions")
+  val genXip = xipConfig != null
+
+}
+
+
+
+object MuraxConfig{
+  def default : MuraxConfig = default(false, false)
+  def default(withXip : Boolean = false, bigEndian : Boolean = false) =  MuraxConfig(
+    coreFrequency         = 12 MHz,
+    onChipRamSize         = 128 kB,
+    onChipRamHexFile      = null,
+    pipelineDBus          = true,
+    pipelineMainBus       = false,
+    pipelineApbBridge     = true,
+    gpioWidth = 32,
+    xipConfig = ifGen(withXip) (SpiXdrMasterCtrl.MemoryMappingParameters(
+      SpiXdrMasterCtrl.Parameters(8, 12, SpiXdrParameter(2, 2, 1)).addFullDuplex(0,1,false),
+      cmdFifoDepth = 32,
+      rspFifoDepth = 32,
+      xip = SpiXdrMasterCtrl.XipBusParameters(addressWidth = 24, lengthWidth = 2)
+    )),
+    hardwareBreakpointCount = if(withXip) 3 else 0,
+    cpuPlugins = ArrayBuffer( //DebugPlugin added by the toplevel
+      new IBusSimplePlugin(
+        resetVector = if(withXip) 0xF001E000l else 0x00000000l,
+        cmdForkOnSecondStage = true,
+        cmdForkPersistence = withXip, //Required by the Xip controller
+        prediction = NONE,
+        catchAccessFault = false,
+        compressedGen = false,
+        bigEndian = bigEndian
+      ),
+      new DBusSimplePlugin(
+        catchAddressMisaligned = false,
+        catchAccessFault = false,
+        earlyInjection = false,
+        bigEndian = bigEndian
+      ),
+      new CsrPlugin(CsrPluginConfig.smallest(mtvecInit = if(withXip) 0xE0040020l else 0x00000020l)),
+      new DecoderSimplePlugin(
+        catchIllegalInstruction = false
+      ),
+      new RegFilePlugin(
+        regFileReadyKind = plugin.SYNC,
+        zeroBoot = false
+      ),
+      new IntAluPlugin,
+      new SrcPlugin(
+        separatedAddSub = false,
+        executeInsertion = false
+      ),
+      new LightShifterPlugin,
+      new HazardSimplePlugin(
+        bypassExecute = false,
+        bypassMemory = false,
+        bypassWriteBack = false,
+        bypassWriteBackBuffer = false,
+        pessimisticUseSrc = false,
+        pessimisticWriteRegFile = false,
+        pessimisticAddressMatch = false
+      ),
+      new BranchPlugin(
+        earlyBranch = false,
+        catchAddressMisaligned = false
+      ),
+      new YamlPlugin("cpu0.yaml")
+    ),
+    uartCtrlConfig = UartCtrlMemoryMappedConfig(
+      uartCtrlConfig = UartCtrlGenerics(
+        dataWidthMax      = 8,
+        clockDividerWidth = 20,
+        preSamplingSize   = 1,
+        samplingSize      = 3,
+        postSamplingSize  = 1
+      ),
+      initConfig = UartCtrlInitConfig(
+        baudrate = 115200,
+        dataLength = 7,  //7 => 8 bits
+        parity = UartParityType.NONE,
+        stop = UartStopType.ONE
+      ),
+      busCanWriteClockDividerConfig = false,
+      busCanWriteFrameConfig = false,
+      txFifoDepth = 16,
+      rxFifoDepth = 16
+    )
+
+  )
+
+  def fast = {
+    val config = default
+
+    //Replace HazardSimplePlugin to get datapath bypass
+    config.cpuPlugins(config.cpuPlugins.indexWhere(_.isInstanceOf[HazardSimplePlugin])) = new HazardSimplePlugin(
+      bypassExecute = true,
+      bypassMemory = true,
+      bypassWriteBack = true,
+      bypassWriteBackBuffer = true
+    )
+//    config.cpuPlugins(config.cpuPlugins.indexWhere(_.isInstanceOf[LightShifterPlugin])) = new FullBarrelShifterPlugin()
+
+    config
+  }
+}
+
+
+case class Murax(config : MuraxConfig) extends Component{
+  import config._
+
+  val io = new Bundle {
+    //Clocks / reset
+    val asyncReset = in Bool()
+    val mainClk = in Bool()
+
+    //Main components IO
+    val jtag = slave(Jtag())
+
+    //Peripherals IO
+    val gpioA = master(TriStateArray(gpioWidth bits))
+    val uart = master(Uart())
+
+    val xip = ifGen(genXip)(master(SpiXdrMaster(xipConfig.ctrl.spi)))
+  }
+
+
+  val resetCtrlClockDomain = ClockDomain(
+    clock = io.mainClk,
+    config = ClockDomainConfig(
+      resetKind = BOOT
+    )
+  )
+
+  val resetCtrl = new ClockingArea(resetCtrlClockDomain) {
+    val mainClkResetUnbuffered  = False
+
+    //Implement an counter to keep the reset axiResetOrder high 64 cycles
+    // Also this counter will automatically do a reset when the system boot.
+    val systemClkResetCounter = Reg(UInt(6 bits)) init(0)
+    when(systemClkResetCounter =/= U(systemClkResetCounter.range -> true)){
+      systemClkResetCounter := systemClkResetCounter + 1
+      mainClkResetUnbuffered := True
+    }
+    when(BufferCC(io.asyncReset)){
+      systemClkResetCounter := 0
+    }
+
+    //Create all reset used later in the design
+    val mainClkReset = RegNext(mainClkResetUnbuffered)
+    val systemReset  = RegNext(mainClkResetUnbuffered)
+  }
+
+
+  val systemClockDomain = ClockDomain(
+    clock = io.mainClk,
+    reset = resetCtrl.systemReset,
+    frequency = FixedFrequency(coreFrequency)
+  )
+
+  val debugClockDomain = ClockDomain(
+    clock = io.mainClk,
+    reset = resetCtrl.mainClkReset,
+    frequency = FixedFrequency(coreFrequency)
+  )
+
+  val system = new ClockingArea(systemClockDomain) {
+    val pipelinedMemoryBusConfig = PipelinedMemoryBusConfig(
+      addressWidth = 32,
+      dataWidth = 32
+    )
+
+    val bigEndianDBus = config.cpuPlugins.exists(_ match{ case plugin : DBusSimplePlugin => plugin.bigEndian case _ => false})
+
+    //Arbiter of the cpu dBus/iBus to drive the mainBus
+    //Priority to dBus, !! cmd transactions can change on the fly !!
+    val mainBusArbiter = new MuraxMasterArbiter(pipelinedMemoryBusConfig, bigEndianDBus)
+
+    //Instanciate the CPU
+    val cpu = new VexRiscv(
+      config = VexRiscvConfig(
+        plugins = cpuPlugins += new DebugPlugin(debugClockDomain, hardwareBreakpointCount)
+      )
+    )
+
+    //Checkout plugins used to instanciate the CPU to connect them to the SoC
+    val timerInterrupt = False
+    val externalInterrupt = False
+    for(plugin <- cpu.plugins) plugin match{
+      case plugin : IBusSimplePlugin =>
+        mainBusArbiter.io.iBus.cmd <> plugin.iBus.cmd
+        mainBusArbiter.io.iBus.rsp <> plugin.iBus.rsp
+      case plugin : DBusSimplePlugin => {
+        if(!pipelineDBus)
+          mainBusArbiter.io.dBus <> plugin.dBus
+        else {
+          mainBusArbiter.io.dBus.cmd << plugin.dBus.cmd.halfPipe()
+          mainBusArbiter.io.dBus.rsp <> plugin.dBus.rsp
+        }
+      }
+      case plugin : CsrPlugin        => {
+        plugin.externalInterrupt := externalInterrupt
+        plugin.timerInterrupt := timerInterrupt
+      }
+      case plugin : DebugPlugin         => plugin.debugClockDomain{
+        resetCtrl.systemReset setWhen(RegNext(plugin.io.resetOut))
+        io.jtag <> plugin.io.bus.fromJtag()
+      }
+      case _ =>
+    }
+
+
+
+    //****** MainBus slaves ********
+    val mainBusMapping = ArrayBuffer[(PipelinedMemoryBus,SizeMapping)]()
+    val ram = new MuraxPipelinedMemoryBusRam(
+      onChipRamSize = onChipRamSize,
+      onChipRamHexFile = onChipRamHexFile,
+      pipelinedMemoryBusConfig = pipelinedMemoryBusConfig,
+      bigEndian = bigEndianDBus
+    )
+    mainBusMapping += ram.io.bus -> (0x00000000l, onChipRamSize)
+
+    val apbBridge = new PipelinedMemoryBusToApbBridge(
+      apb3Config = Apb3Config(
+        addressWidth = 20,
+        dataWidth = 32
+      ),
+      pipelineBridge = pipelineApbBridge,
+      pipelinedMemoryBusConfig = pipelinedMemoryBusConfig
+    )
+    mainBusMapping += apbBridge.io.pipelinedMemoryBus -> (0xF0000000l, 1 MB)
+
+
+
+    //******** APB peripherals *********
+    val apbMapping = ArrayBuffer[(Apb3, SizeMapping)]()
+    val gpioACtrl = Apb3Gpio(gpioWidth = gpioWidth, withReadSync = true)
+    io.gpioA <> gpioACtrl.io.gpio
+    apbMapping += gpioACtrl.io.apb -> (0x00000, 4 kB)
+
+    val uartCtrl = Apb3UartCtrl(uartCtrlConfig)
+    uartCtrl.io.uart <> io.uart
+    externalInterrupt setWhen(uartCtrl.io.interrupt)
+    apbMapping += uartCtrl.io.apb  -> (0x10000, 4 kB)
+
+    val timer = new MuraxApb3Timer()
+    timerInterrupt setWhen(timer.io.interrupt)
+    apbMapping += timer.io.apb     -> (0x20000, 4 kB)
+
+    val xip = ifGen(genXip)(new Area{
+      val ctrl = Apb3SpiXdrMasterCtrl(xipConfig)
+      ctrl.io.spi <> io.xip
+      externalInterrupt setWhen(ctrl.io.interrupt)
+      apbMapping += ctrl.io.apb     -> (0x1F000, 4 kB)
+
+      val accessBus = new PipelinedMemoryBus(PipelinedMemoryBusConfig(24,32))
+      mainBusMapping += accessBus -> (0xE0000000l, 16 MB)
+
+      ctrl.io.xip.fromPipelinedMemoryBus() << accessBus
+      val bootloader = Apb3Rom("src/main/c/murax/xipBootloader/crt.bin")
+      apbMapping += bootloader.io.apb     -> (0x1E000, 4 kB)
+    })
+
+
+
+    //******** Memory mappings *********
+    val apbDecoder = Apb3Decoder(
+      master = apbBridge.io.apb,
+      slaves = apbMapping.toSeq
+    )
+
+    val mainBusDecoder = new Area {
+      val logic = new MuraxPipelinedMemoryBusDecoder(
+        master = mainBusArbiter.io.masterBus,
+        specification = mainBusMapping.toSeq,
+        pipelineMaster = pipelineMainBus
+      )
+    }
+  }
+}
+
+
+
+object Murax{
+  def main(args: Array[String]) {
+    SpinalVerilog(Murax(MuraxConfig.default))
+  }
+}
+
+object MuraxCfu{
+  def main(args: Array[String]) {
+    SpinalVerilog{
+      val config = MuraxConfig.default
+      config.cpuPlugins += new CfuPlugin(
+        stageCount = 1,
+        allowZeroLatency = true,
+        encodings = List(
+          CfuPluginEncoding (
+            instruction = M"-------------------------0001011",
+            functionId = List(14 downto 12),
+            input2Kind = CfuPlugin.Input2Kind.RS
+          )
+        ),
+        busParameter = CfuBusParameter(
+          CFU_VERSION = 0,
+          CFU_INTERFACE_ID_W = 0,
+          CFU_FUNCTION_ID_W = 3,
+          CFU_REORDER_ID_W = 0,
+          CFU_REQ_RESP_ID_W = 0,
+          CFU_INPUTS = 2,
+          CFU_INPUT_DATA_W = 32,
+          CFU_OUTPUTS = 1,
+          CFU_OUTPUT_DATA_W = 32,
+          CFU_FLOW_REQ_READY_ALWAYS = false,
+          CFU_FLOW_RESP_READY_ALWAYS = false,
+          CFU_WITH_STATUS = true,
+          CFU_RAW_INSN_W = 32,
+          CFU_CFU_ID_W = 4,
+          CFU_STATE_INDEX_NUM = 5
+        )
+      )
+
+      val toplevel = Murax(config)
+
+      toplevel.rework {
+        for (plugin <- toplevel.system.cpu.plugins) plugin match {
+          case plugin: CfuPlugin => plugin.bus.toIo().setName("miaou")
+          case _ =>
+        }
+      }
+
+      toplevel
+    }
+  }
+}
+
+
+object Murax_iCE40_hx8k_breakout_board_xip{
+
+  case class SB_GB() extends BlackBox{
+    val USER_SIGNAL_TO_GLOBAL_BUFFER = in Bool()
+    val GLOBAL_BUFFER_OUTPUT = out Bool()
+  }
+
+  case class SB_IO_SCLK() extends BlackBox{
+    addGeneric("PIN_TYPE", B"010000")
+    val PACKAGE_PIN = out Bool()
+    val OUTPUT_CLK = in Bool()
+    val CLOCK_ENABLE = in Bool()
+    val D_OUT_0 = in Bool()
+    val D_OUT_1 = in Bool()
+    setDefinitionName("SB_IO")
+  }
+
+  case class SB_IO_DATA() extends BlackBox{
+    addGeneric("PIN_TYPE", B"110000")
+    val PACKAGE_PIN = inout(Analog(Bool))
+    val CLOCK_ENABLE = in Bool()
+    val INPUT_CLK = in Bool()
+    val OUTPUT_CLK = in Bool()
+    val OUTPUT_ENABLE = in Bool()
+    val D_OUT_0 = in Bool()
+    val D_OUT_1 = in Bool()
+    val D_IN_0 = out Bool()
+    val D_IN_1 = out Bool()
+    setDefinitionName("SB_IO")
+  }
+
+  case class Murax_iCE40_hx8k_breakout_board_xip() extends Component{
+    val io = new Bundle {
+      val mainClk  = in  Bool()
+      val jtag_tck = in  Bool()
+      val jtag_tdi = in  Bool()
+      val jtag_tdo = out Bool()
+      val jtag_tms = in  Bool()
+      val uart_txd = out Bool()
+      val uart_rxd = in  Bool()
+
+      val mosi = inout(Analog(Bool))
+      val miso = inout(Analog(Bool))
+      val sclk = out Bool()
+      val spis = out Bool()
+
+      val led = out Bits(8 bits)
+    }
+    val murax = Murax(MuraxConfig.default(withXip = true).copy(onChipRamSize = 8 kB))
+    murax.io.asyncReset := False
+
+    val mainClkBuffer = SB_GB()
+    mainClkBuffer.USER_SIGNAL_TO_GLOBAL_BUFFER <> io.mainClk
+    mainClkBuffer.GLOBAL_BUFFER_OUTPUT <> murax.io.mainClk
+
+    val jtagClkBuffer = SB_GB()
+    jtagClkBuffer.USER_SIGNAL_TO_GLOBAL_BUFFER <> io.jtag_tck
+    jtagClkBuffer.GLOBAL_BUFFER_OUTPUT <> murax.io.jtag.tck
+
+    io.led <> murax.io.gpioA.write(7 downto 0)
+
+    murax.io.jtag.tdi <> io.jtag_tdi
+    murax.io.jtag.tdo <> io.jtag_tdo
+    murax.io.jtag.tms <> io.jtag_tms
+    murax.io.gpioA.read <> 0
+    murax.io.uart.txd <> io.uart_txd
+    murax.io.uart.rxd <> io.uart_rxd
+
+
+
+    val xip = new ClockingArea(murax.systemClockDomain) {
+      RegNext(murax.io.xip.ss.asBool) <> io.spis
+
+      val sclkIo = SB_IO_SCLK()
+      sclkIo.PACKAGE_PIN <> io.sclk
+      sclkIo.CLOCK_ENABLE := True
+
+      sclkIo.OUTPUT_CLK := ClockDomain.current.readClockWire
+      sclkIo.D_OUT_0 <> murax.io.xip.sclk.write(0)
+      sclkIo.D_OUT_1 <> RegNext(murax.io.xip.sclk.write(1))
+
+      val datas = for ((data, pin) <- (murax.io.xip.data, List(io.mosi, io.miso)).zipped) yield new Area {
+        val dataIo = SB_IO_DATA()
+        dataIo.PACKAGE_PIN := pin
+        dataIo.CLOCK_ENABLE := True
+
+        dataIo.OUTPUT_CLK := ClockDomain.current.readClockWire
+        dataIo.OUTPUT_ENABLE <> data.writeEnable
+        dataIo.D_OUT_0 <> data.write(0)
+        dataIo.D_OUT_1 <> RegNext(data.write(1))
+
+        dataIo.INPUT_CLK := ClockDomain.current.readClockWire
+        data.read(0) := dataIo.D_IN_0
+        data.read(1) := RegNext(dataIo.D_IN_1)
+      }
+    }
+
+  }
+
+  def main(args: Array[String]) {
+    SpinalVerilog(Murax_iCE40_hx8k_breakout_board_xip())
+  }
+}
+
+object MuraxDhrystoneReady{
+  def main(args: Array[String]) {
+    SpinalVerilog(Murax(MuraxConfig.fast.copy(onChipRamSize = 256 kB)))
+  }
+}
+
+object MuraxDhrystoneReadyMulDivStatic{
+  def main(args: Array[String]) {
+    SpinalVerilog({
+      val config = MuraxConfig.fast.copy(onChipRamSize = 256 kB)
+      config.cpuPlugins += new MulPlugin
+      config.cpuPlugins += new DivPlugin
+      config.cpuPlugins.remove(config.cpuPlugins.indexWhere(_.isInstanceOf[BranchPlugin]))
+      config.cpuPlugins +=new BranchPlugin(
+        earlyBranch = false,
+        catchAddressMisaligned = false
+      )
+      config.cpuPlugins += new IBusSimplePlugin(
+        resetVector = 0x00000000l,
+        cmdForkOnSecondStage = true,
+        cmdForkPersistence = false,
+        prediction = STATIC,
+        catchAccessFault = false,
+        compressedGen = false
+      )
+      config.cpuPlugins.remove(config.cpuPlugins.indexWhere(_.isInstanceOf[LightShifterPlugin]))
+      config.cpuPlugins += new FullBarrelShifterPlugin
+      Murax(config)
+    })
+  }
+}
+
+//Will blink led and echo UART RX to UART TX   (in the verilator sim, type some text and press enter to send UART frame to the Murax RX pin)
+object MuraxWithRamInit{
+  def main(args: Array[String]) {
+    SpinalVerilog(Murax(MuraxConfig.default.copy(onChipRamSize = 4 kB, onChipRamHexFile = "src/main/ressource/hex/muraxDemo.hex")))
+  }
+}
+
+object Murax_arty{
+  def main(args: Array[String]) {
+    val hex = "src/main/c/murax/hello_world/build/hello_world.hex"
+    SpinalVerilog(Murax(MuraxConfig.default(false).copy(coreFrequency = 100 MHz,onChipRamSize = 32 kB, onChipRamHexFile = hex)))
+  }
+}
+
+
+object MuraxAsicBlackBox extends App{
+  println("Warning this soc do not has any rom to boot on.")
+  val config = SpinalConfig()
+  config.addStandardMemBlackboxing(blackboxAll)
+  config.generateVerilog(Murax(MuraxConfig.default()))
+}
+
diff --git a/cpp/_crt0.S b/cpp/_crt0.S
index bc6a10a..50a0e46 100644
--- a/cpp/_crt0.S
+++ b/cpp/_crt0.S
@@ -9,13 +9,12 @@ _start:
   la    gp, __global_pointer$
   .option pop
 
-  li sp, 0x1fff0
+  li sp, 0x800ffff0
 
   # Clear the bss segment
   la    a0, __bss_start
   la    a1, __BSS_END__
 
-  j finish_bss
 clear_bss:
   bgeu  a0, a1, finish_bss
   sb    x0, 0(a0)
diff --git a/cpp/_crt0.S-k0 b/cpp/_crt0.S-k0
new file mode 100644
index 0000000..dbe07d9
--- /dev/null
+++ b/cpp/_crt0.S-k0
@@ -0,0 +1,42 @@
+  .text
+  .global _start
+  .type   _start, @function
+
+_start:
+  # Initialize global pointer
+  .option push
+  .option norelax
+  la    gp, __global_pointer$
+  .option pop
+
+  li sp, 0x1fff0
+
+  # Clear the bss segment
+  la    a0, __bss_start
+  la    a1, __BSS_END__
+
+clear_bss:
+  bgeu  a0, a1, finish_bss
+  sb    x0, 0(a0)
+  addi  a0, a0, 1
+  beq   x0, x0, clear_bss
+finish_bss:
+
+  nop //!
+
+  call  main
+
+  nop //!
+
+  # abort execution here
+  ebreak
+
+  .section .rodata
+alfabet:
+    .string "abcdefghijklmnopqrstuwxyz"
+slowo:
+
+  .section .data
+wynik:
+    .string "mpabi"
+    .space 26   # rezerwuje 26 bajtów dla wyniku, zainicjowane na 0
\ No newline at end of file
diff --git a/cpp/_crt0.S-k1 b/cpp/_crt0.S-k1
new file mode 100644
index 0000000..09af34b
--- /dev/null
+++ b/cpp/_crt0.S-k1
@@ -0,0 +1,39 @@
+  .text
+  .global _start
+  .type   _start, @function
+
+_start:
+  # Initialize global pointer
+  .option push
+  .option norelax
+  la    gp, __global_pointer$
+  .option pop
+
+  # Initialize stack pointer from linker script symbol
+  la    sp, __stack_top
+
+  # Clear the BSS segment
+  la    a0, __bss_start
+  la    a1, __bss_end
+
+clear_bss:
+  bgeu  a0, a1, finish_bss
+  sb    x0, 0(a0)
+  addi  a0, a0, 1
+  j     clear_bss
+finish_bss:
+
+  call  main
+
+  ebreak
+
+.section .rodata
+
+alfabet:
+    .string "abcdefghijklmnopqrstuwxyz"
+slowo:
+
+  .section .data
+wynik:
+    .string "mpabi"
+    .space 26   # rezerwuje 26 bajtów dla wyniku, zainicjowane na 0
diff --git a/cpp/_rv-diss b/cpp/_rv-diss
deleted file mode 100644
index 9a22230..0000000
--- a/cpp/_rv-diss
+++ /dev/null
@@ -1 +0,0 @@
-riscv64-unknown-elf-objdump -S  --disassemble prog > prog.dis
diff --git a/cpp/_rv-readelf b/cpp/_rv-readelf
deleted file mode 100644
index 940c525..0000000
--- a/cpp/_rv-readelf
+++ /dev/null
@@ -1 +0,0 @@
-readelf -S -W prog
diff --git a/cpp/_rvmain.cpp b/cpp/_rvmain.cpp
index fa5d9e2..809ea30 100644
--- a/cpp/_rvmain.cpp
+++ b/cpp/_rvmain.cpp
@@ -7,6 +7,15 @@ int strlen(char *s) {
     return p - s;
 }
 
+char *  ptr7 = "Vladyslav";
+int mojstlen(){
+char * s = "Vladyslav";
+ 
+ 
+   uint8_t wynik =0;
+    wynik = strlen (s);
+}
+
 void strcpy(char *s, char *t)
 {
      while (*s++ = *t++);
@@ -65,15 +74,13 @@ char *simple_strtok(char *str, const char *delims) {
     static char *static_str = (char *) NULL; // Przechowuje wskaźnik do bieżącej pozycji w ciągu
 
     // Jeśli przekazano nowy ciąg, zaktualizuj static_str
-    if (str != NULL) {
-        static_str = str;
+    if (str == NULL) {
+        return (char *) NULL; // str nie wskazuje na zdanie !!!
     }
+    static_str = str;
     
-    // Jeśli static_str jest NULL, zwróć NULL
-    if (static_str == NULL) {
-        return (char *) NULL;
-    }
-
+    // "   .,mpabi"
+    //       ^
     // Pomiń początkowe delimitery
     while (*static_str && is_delim(*static_str, delims)) {
         static_str++;
@@ -102,6 +109,9 @@ char *simple_strtok(char *str, const char *delims) {
     return token_start;
 }
 
+
+char buf[100];
+struct model * p = (struct model *) buf; //p[1]
 ////func alg
 //in:       ptr to date
 //return:   count of words
@@ -115,28 +125,25 @@ int alg (const char * ptr) {
 	int8_t  count = 0;
 
 	char *token = simple_strtok(bufer, delims);
-	while (token != (char *)NULL) {
+
+    while (token != (char *)NULL) {
+
+            p[count].str = token;
+            p[count].len = strlen(token);
+		
+        token = simple_strtok((char *)NULL, delims);
 		count++;
-		token = simple_strtok((char *)NULL, delims);
 	}
+
 	return count;
 }
 
-
 int main() { 
 
     char *str = "If wantered relation no surprise of all";
 
-   struct model *ptr = (struct model *) alloc(LEN);
-	if (ptr != (struct model *)NULL) {
-		ptr->str = alloc(strlen((char *)str) + 1);
-		if (ptr->str != (char *)NULL) {
-			strcpy (ptr->str, (char *)str);
-			ptr->len = strlen(ptr->str);
+    alg(str);
+    asm ("nop");
 
-			int8_t count = alg(ptr->str);
-		}
-	}
- 
 	return 1;
 }
diff --git a/cpp/_rvmain.cpp.save b/cpp/_rvmain.cpp.save
deleted file mode 100644
index b986dde..0000000
--- a/cpp/_rvmain.cpp.save
+++ /dev/null
@@ -1,142 +0,0 @@
-#include <stdint.h>
-
-int strlen(char *s) {
-    char *p = s;
-    while (*p != '\0')
-        p++;
-    return p - s;
-}
-
-void strcpy(char *s, char *t)
-{
-     while (*s++ = *t++);
-}
-#define ALLOCSIZE 10000
-
-static char allocbuf[ALLOCSIZE]; 
-static char *allocp = allocbuf; 
-
-char *alloc(int n) 
-{
-
-    if (n % 4 != 0) { 
-        n += 4 - (n % 4);
-    }
-
-
-     if (allocbuf + ALLOCSIZE - allocp >= n) { 
-     allocp += n;
-     return allocp - n; 
-     } else 
-     return 0;
-}
-
-// def. model danych
-
-//pre processor
-#define LEN (8+2)*10
-
-struct model {
-    char *      str;
-    uint32_t    len ;
-};
-
-
-//alg
-// prosta implementacji func. z bibl. std. strok przy uzyciu  gpt3.5
-//
-
-#define NULL ((void*) 0)
-
-//
-// Funkcja pomocnicza do sprawdzania, czy znak jest wśród delimiterów
-bool is_delim(char c, const char *delims) {
-    while (*delims) {
-        if (c == *delims) {
-            return true;
-        }
-        delims++;
-    }
-    return false;
-}
-
-// Najprostsza implementacja funkcji strtok
-char *simple_strtok(char *str, const char *delims) {
-    static char *static_str = (char *) NULL; // Przechowuje wskaźnik do bieżącej pozycji w ciągu
-
-    // Jeśli przekazano nowy ciąg, zaktualizuj static_str
-    if (str != NULL) {
-        static_str = str;
-    }
-    
-    // Jeśli static_str jest NULL, zwróć NULL
-    if (static_str == NULL) {
-        return (char *) NULL;
-    }
-
-    // Pomiń początkowe delimitery
-    while (*static_str && is_delim(*static_str, delims)) {
-        static_str++;
-    }
-    
-    // Jeśli doszliśmy do końca ciągu, zwróć NULL
-    if (*static_str == '\0') {
-        return (char *) NULL;
-    }
-
-    // Zapisz początek tokenu
-    char *token_start = static_str;
-    
-    // Znajdź koniec tokenu
-    while (*static_str && !is_delim(*static_str, delims)) {
-        static_str++;
-    }
-
-    // Jeśli znaleziono delimitery, zamień je na '\0' i zaktualizuj static_str
-    if (*static_str) {
-        *static_str = '\0';
-        static_str++;
-    }
-
-    // Zwróć początek tokenu
-    return token_start;
-}
-
-////func alg
-//in:       ptr to date
-//return:   count of words
-int alg (const char * ptr) {
-
-	char bufer[ALLOCSIZE];
-	strcpy(bufer, (char *)ptr);
-
-	const char *delims = " ,.!?:;\n\t";
-
-	int8_t  count = 0;
-
-	char *token = simple_strtok(bufer, delims);
-	while (token != (char *)NULL) {
-		count++;
-		token = simple_strtok((char *)NULL, delims);
-	}
-	return count;
-}
-
-
-int main() { 
-
-    const char *str = "If wantered relation no surprise of all";
-
-   struct model *ptr = (struct model *) alloc(LEN);
-	if (ptr != (struct model *) NULL) {
-		ptr->str = alloc(strlen((char *)str) + 1);
-		if (ptr->str != (char *)NULL) {
-			strcpy (ptr->str, (char *)str);
-			ptr->len = strlen(ptr->str);
-
-			int8_t count = alg(ptr->str);
-		}
-	}
- 
-	return 1;
-}
diff --git a/cpp/gdb/z.py b/cpp/gdb/z.py
deleted file mode 100644
index 98c6a26..0000000
--- a/cpp/gdb/z.py
+++ /dev/null
@@ -1,17 +0,0 @@
-# set args 0x1FF80 0x80 0x30
-# source gdb/z.py
-
-import gdb
-import sys
-
-# Parse arguments from the GDB command
-args = gdb.string_to_argv(gdb.parameter("args"))
-if len(args) != 3:
-    print("Usage: source gdb/zero_with_params.py <start_address> <num_bytes> <pattern>")
-else:
-    start_address = int(args[0], 16)  # Convert start address from hex to int
-    num_bytes = int(args[1], 16)      # Convert number of bytes from hex to int
-    pattern = int(args[2], 16)        # Convert pattern from hex to int
-    
-    for i in range(num_bytes):
-        gdb.execute("set *((char*)%x + %x) = %x" % (start_address, i, pattern))
diff --git a/cpp/gdb/zero.py b/cpp/gdb/zero.py
deleted file mode 100644
index 0095bd7..0000000
--- a/cpp/gdb/zero.py
+++ /dev/null
@@ -1,5 +0,0 @@
-#source gdb/z.py
-
-import gdb
-for i in range(0, 128): # 128 bajtów
-    gdb.execute("set *((char*)(0x1FF80 + %x)) = 0xaa" % i)
diff --git a/cpp/murax_128k_ram-sp.ld b/cpp/murax_128k_ram-sp.ld
new file mode 100644
index 0000000..b3ac278
--- /dev/null
+++ b/cpp/murax_128k_ram-sp.ld
@@ -0,0 +1,43 @@
+MEMORY
+{
+  RAM (wx) : ORIGIN = 0x0, LENGTH = 128K
+}
+
+SECTIONS
+{
+  .text :
+  {
+    *(.text*)
+    *(.rodata*)
+  } > RAM
+
+  .data : 
+  {
+    *(.data*)
+  } > RAM
+
+  .bss :
+  {
+    *(.bss*)
+    *(COMMON)
+  } > RAM
+
+  /* Add stack at the end of RAM */
+  . = ALIGN(4);
+  _end = .;
+  PROVIDE(end = .);
+  
+  /* Define stack size and location */
+  _stack_size = 0x4000; /* Example stack size: 16KB */
+  _stack_end = ORIGIN(RAM) + LENGTH(RAM); /* End of RAM */
+  _stack_start = _stack_end - _stack_size; /* Calculate start of the stack */
+  .stack (NOLOAD) :
+  {
+    . = ALIGN(4);
+    . = . + _stack_size;
+    . = ALIGN(4);
+    _sp = .;
+  } > RAM
+
+  PROVIDE(__stack = _sp);
+}
diff --git a/cpp/murax_128k_ram.ld b/cpp/murax_128k_ram.ld
new file mode 100644
index 0000000..244668e
--- /dev/null
+++ b/cpp/murax_128k_ram.ld
@@ -0,0 +1,67 @@
+/* Linker script for a system with 128KB RAM starting at 0x10000 */
+MEMORY
+{
+    RAM (wx) : ORIGIN = 0x0000, LENGTH = 128K
+}
+
+SECTIONS
+{
+    /* Place code and readonly data at the beginning of RAM */
+    .text :
+    {
+        *(.text*)
+        *(.rodata*)
+    } > RAM
+
+    /* Place initialized data right after the .text section */
+    .data : 
+    {
+        . = ALIGN(4);
+        *(.data*)
+    } > RAM
+
+    /* Uninitialized data (BSS) follows initialized data */
+    .bss :
+    {
+        . = ALIGN(4);
+        __bss_start = .;
+        *(.bss*)
+        *(COMMON)
+        . = ALIGN(4);
+        __bss_end = .;
+    } > RAM
+
+    /* Define heap start right after bss */
+    . = ALIGN(4);
+    __heap_start = .;
+    PROVIDE(heap_start = __heap_start);
+
+    /* Leave space for the heap by not explicitly defining its end */
+    /* The heap grows towards the stack */
+
+    /* Reserve space for the stack at the end of RAM */
+    /* Let's say we want a 16KB stack */
+    . = ALIGN(4);
+    __stack_size = 16K; /* Size of the stack */
+    __stack_top = ORIGIN(RAM) + LENGTH(RAM); /* Top of the stack */
+    __stack_start = __stack_top - __stack_size; /* Start of the stack */
+    .stack (NOLOAD) :
+    {
+        . = __stack_start;
+        . += __stack_size; /* Allocate space for the stack */
+        . = ALIGN(4);
+    } > RAM
+
+    PROVIDE(__stack = __stack_top);
+    PROVIDE(stack_top = __stack_top);
+    PROVIDE(stack_start = __stack_start);
+    
+    /* Heap end is dynamically located at the start of the stack */
+    __heap_end = __stack_start;
+    PROVIDE(heap_end = __heap_end);
+
+    /* End of RAM usage */
+    . = ALIGN(4);
+    _end = .;
+    PROVIDE(end = _end);
+}
diff --git a/cpp/murax_128k_ram.ld-kopia b/cpp/murax_128k_ram.ld-kopia
new file mode 100644
index 0000000..6488ff3
--- /dev/null
+++ b/cpp/murax_128k_ram.ld-kopia
@@ -0,0 +1,13 @@
+MEMORY
+{
+  RAM (wx) : ORIGIN = 0x10000, LENGTH = 128K
+}
+
+SECTIONS
+{
+  .text : { *(.text*) } > RAM
+  .rodata : { *(.rodata*) } > RAM
+  .data : { *(.data*) } > RAM
+  .bss : { *(.bss*) } > RAM
+  _end = .; /* Definiuje koniec sekcji danych, może być używane do określenia rozmiaru sterty */
+}
diff --git a/cpp/myfuncOOP.cpp b/cpp/myfuncOOP.cpp
deleted file mode 100644
index 02e929d..0000000
--- a/cpp/myfuncOOP.cpp
+++ /dev/null
@@ -1,38 +0,0 @@
-#include "myfuncOOP.hpp"
-
-MyfuncOOP::MyfuncOOP(const char* alfabet, const char* slowo, uint8_t* wynik)
-    : alfabet(alfabet), slowo(slowo), wynik(wynik) {
-}
-
-void MyfuncOOP::countCharacters() {
-    int alfabet_length = myStrlen(alfabet);
-
-    for (int i = 0; i < alfabet_length; ++i) {
-        wynik[i] = 0; // Initialize counts to zero
-    }
-
-    for (int i = 0; i < alfabet_length; ++i) {
-        for (int j = 0; slowo[j] != '\0'; ++j) {
-            if (alfabet[i] == slowo[j]) {
-                wynik[i]++;
-            }
-        }
-    }
-}
-
-const uint8_t* MyfuncOOP::getResults() const {
-    return wynik;
-}
-
-int MyfuncOOP::myStrlen(const char* str) {
-    int length = 0;
-    while (str[length] != '\0') {
-        ++length;
-    }
-    return length;
-}
-
-
-// MyfuncOOP zliczacz(alfabet, slowo, wynik);
-// zliczacz.countCharacters();
-// const uint8_t* results = zliczacz.getResults();
\ No newline at end of file
diff --git a/cpp/myfuncOOP.hpp b/cpp/myfuncOOP.hpp
deleted file mode 100644
index 277e918..0000000
--- a/cpp/myfuncOOP.hpp
+++ /dev/null
@@ -1,22 +0,0 @@
-#ifndef MYFUNC_OOP_HPP
-#define MYFUNC_OOP_HPP
-
-#include <cstdint>
-
-class MyfuncOOP {
-public:
-    MyfuncOOP(const char* alfabet, const char* slowo, uint8_t* wynik);
-
-    void countCharacters();
-
-    const uint8_t* getResults() const;
-
-private:
-    const char* alfabet;
-    const char* slowo;
-    uint8_t* wynik;
-
-    static int myStrlen(const char* str);
-};
-
-#endif // MYFUNC_OOP_HPP
diff --git a/cpp/myfuncStruct.cpp b/cpp/myfuncStruct.cpp
deleted file mode 100644
index 47e307f..0000000
--- a/cpp/myfuncStruct.cpp
+++ /dev/null
@@ -1,29 +0,0 @@
-#include "myfuncStruct.h"
-
-// Static function for string length calculation
-static int my_strlen(const char *str) {
-    int length = 0;
-    while (str[length] != '\0') {
-        length++;
-    }
-    return length;
-}
-
-// Function to count occurrences of each character in 'alfabet' within 'slowo'
-void count_charactersStruct(ZliczaczStruct* zliczacz) {
-    int alfabet_length = my_strlen(zliczacz->alfabet);
-
-    // Initialize the result array to zero
-    for (int i = 0; i < alfabet_length; ++i) {
-        zliczacz->wynik[i] = 0;
-    }
-
-    // Count occurrences
-    for (int i = 0; i < alfabet_length; ++i) {
-        for (int j = 0; zliczacz->slowo[j] != '\0'; ++j) {
-            if (zliczacz->alfabet[i] == zliczacz->slowo[j]) {
-                zliczacz->wynik[i]++;
-            }
-        }
-    }
-}
diff --git a/cpp/myfuncStruct.h b/cpp/myfuncStruct.h
deleted file mode 100644
index 2671140..0000000
--- a/cpp/myfuncStruct.h
+++ /dev/null
@@ -1,15 +0,0 @@
-#ifndef MYFUNCSTRUCT_H
-#define MYFUNCSTRUCT_H
-
-#include <stdint.h>
-
-typedef struct {
-    const char* alfabet;
-    const char* slowo;
-    uint8_t* wynik; // Pointer to an array for results
-} ZliczaczStruct;
-
-// Function declaration for counting character occurrences
-void count_charactersStruct(ZliczaczStruct* zliczacz);
-
-#endif // MYFUNCSTRUCT_H
diff --git a/cpp/myfuncStructOOP.cpp b/cpp/myfuncStructOOP.cpp
deleted file mode 100644
index 8138dc3..0000000
--- a/cpp/myfuncStructOOP.cpp
+++ /dev/null
@@ -1,44 +0,0 @@
-#include "myfuncStructOOP.h"
-
-// Static function for string length calculation
-static int my_strlen(const char *str) {
-    int length = 0;
-    while (str[length] != '\0') {
-        length++;
-    }
-    return length;
-}
-
-// 'Method' to count occurrences of each character
-static void count_charactersStructOOP(ZliczaczStructOOP* zliczacz) {
-    int alfabet_length = my_strlen(zliczacz->alfabet);
-    
-    // Initialize the result array to zero
-    for (int i = 0; i < alfabet_length; ++i) {
-        zliczacz->wynik[i] = 0;
-    }
-
-    // Count occurrences
-    for (int i = 0; i < alfabet_length; ++i) {
-        for (int j = 0; zliczacz->slowo[j] != '\0'; ++j) {
-            if (zliczacz->alfabet[i] == zliczacz->slowo[j]) {
-                zliczacz->wynik[i]++;
-            }
-        }
-    }
-}
-
-// Constructor-like function to initialize a ZliczaczStructOOP
-void initializeZliczaczStructOOP(ZliczaczStructOOP* zliczacz, const char* alfabet, const char* slowo, uint8_t* wynik) {
-    zliczacz->alfabet = alfabet;
-    zliczacz->slowo = slowo;
-    zliczacz->wynik = wynik;
-    zliczacz->count_characters = count_charactersStructOOP;
-}
-
-// #include "myfuncStructOOP.h"
-
-// ZliczaczStructOOP zliczacz;
-// initializeZliczaczStructOOP(&zliczacz, alfabet, slowo, wynik);
-
-// zliczacz.count_characters(&zliczacz);
diff --git a/cpp/myfuncStructOOP.h b/cpp/myfuncStructOOP.h
deleted file mode 100644
index dd3e7e4..0000000
--- a/cpp/myfuncStructOOP.h
+++ /dev/null
@@ -1,21 +0,0 @@
-#ifndef MYFUNCSTRUCTOOP_H
-#define MYFUNCSTRUCTOOP_H
-
-#include <stdint.h>
-
-typedef struct ZliczaczStructOOP ZliczaczStructOOP;
-
-struct ZliczaczStructOOP {
-    // Data members
-    const char* alfabet;
-    const char* slowo;
-    uint8_t* wynik; // Pointer to an array for results
-
-    // Function pointers, acting as 'methods'
-    void (*count_characters)(ZliczaczStructOOP*);
-};
-
-void initializeZliczaczStructOOP(ZliczaczStructOOP* zliczacz, const char* alfabet, const char* slowo, uint8_t* wynik);
-
-
-#endif // MYFUNCSTRUCTOOP_H
diff --git a/cpp/tracked_files.txt b/cpp/tracked_files.txt
deleted file mode 100644
index fb2f94e..0000000
--- a/cpp/tracked_files.txt
+++ /dev/null
@@ -1,5 +0,0 @@
-_crt0.S
-main.cpp
-myfunc.cpp
-myfunc.h
-_rvmain.cc
diff --git a/cpp/try/3.py b/cpp/try/3.py
deleted file mode 100644
index d12e3b0..0000000
--- a/cpp/try/3.py
+++ /dev/null
@@ -1,16 +0,0 @@
-import asyncio
-import websockets
-
-async def consume_ws_latest_records():
-    uri = "ws://172.24.0.3:3333/ws_latest_records"
-
-    async with websockets.connect(uri) as websocket:
-        while True:
-            message = input("Enter a message to send: ")
-            await websocket.send(message)
-
-            response = await websocket.recv()
-            print(f"Received from server: {response}")
-
-if __name__ == "__main__":
-    asyncio.get_event_loop().run_until_complete(consume_ws_latest_records())
diff --git a/cpp/try/__os-build b/cpp/try/__os-build
deleted file mode 100644
index 025913d..0000000
--- a/cpp/try/__os-build
+++ /dev/null
@@ -1 +0,0 @@
-g++ -std=c++17 -o websocket-client-sync main.cpp myfunc.cpp -lboost_system -lboost_thread -lboost_coroutine -ljsoncpp
diff --git a/cpp/try/__os-run b/cpp/try/__os-run
deleted file mode 100644
index b500c13..0000000
--- a/cpp/try/__os-run
+++ /dev/null
@@ -1 +0,0 @@
-./websocket-client-sync ws://localhost:3333/ws
diff --git a/cpp/try/main.cpp b/cpp/try/main.cpp
deleted file mode 100644
index 9f7dea1..0000000
--- a/cpp/try/main.cpp
+++ /dev/null
@@ -1,155 +0,0 @@
-#include <boost/beast/core.hpp>
-#include <boost/beast/websocket.hpp>
-#include <boost/asio/connect.hpp>
-#include <boost/asio/ip/tcp.hpp>
-#include <cstdlib>
-#include <iostream>
-#include <string>
-#include <jsoncpp/json/json.h>
-#include <thread>
-#include <chrono>
-#include <regex>
-
-namespace beast = boost::beast;
-namespace websocket = beast::websocket;
-namespace net = boost::asio;
-using tcp = boost::asio::ip::tcp;
-
-struct Person {
-    std::string name;
-    int age;
-    long long timestamp;
-};
-
-Json::Value serializePerson(const Person& person) {
-    Json::Value jsonPerson;
-    jsonPerson["name"] = person.name;
-    jsonPerson["age"] = person.age;
-    jsonPerson["timestamp"] = static_cast<Json::Value::Int64>(person.timestamp);
-    return jsonPerson;
-}
-
-std::tuple<std::string, std::string, std::string> parseURI(const std::string& uri) {
-    std::regex uriRegex(R"(^ws://([^:/]+):(\d+)(/.+)$)");
-    std::smatch match;
-
-    if (std::regex_match(uri, match, uriRegex)) {
-        return std::make_tuple(match[1].str(), match[2].str(), match[3].str());
-    } else {
-        throw std::invalid_argument("Nieprawidłowe URI");
-    }
-}
-
-template <typename T>
-T getInput(const std::string& prompt) {
-    T value;
-    while (true) {
-        std::cout << prompt;
-        std::cin >> value;
-
-        if (std::cin.fail()) {
-            std::cin.clear();
-            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
-            std::cerr << "Błąd! Spróbuj ponownie." << std::endl;
-        } else {
-            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
-            break;
-        }
-    }
-
-    return value;
-}
-
-void iterateCharBuffer(const char* charBuffer, std::size_t bufferSize) {
-    for (std::size_t i = 0; i < bufferSize; ++i) {
-        std::cout << charBuffer[i];
-    }
-    std::cout << std::endl;
-
-    // Example: Call the function you want to apply to the char buffer
-}
-
-int main(int argc, char** argv) {
-    try {
-        if (argc != 2) {
-            std::cerr << "Sposób użycia: " << argv[0] << " <adres URI>\n";
-            return EXIT_FAILURE;
-        }
-
-        std::string uri = argv[1];
-        auto uriParts = parseURI(uri);
-        std::string host, port, endpoint;
-        std::tie(host, port, endpoint) = uriParts;
-
-        net::io_context io_context;
-
-        websocket::stream<tcp::socket> ws(io_context);
-        tcp::resolver resolver(io_context);
-        auto endpoints = resolver.resolve(host, port);
-        net::connect(ws.next_layer(), endpoints);
-
-        ws.handshake(host, endpoint);
-
-        while (true) {
-            std::cout << "Menu:\n";
-            std::cout << "1. Dodaj rekord\n";
-            std::cout << "2. Zwróć ostatnie rekordy\n";
-            std::cout << "3. Wyjście\n";
-
-            int choice = getInput<int>("Wybierz opcję: ");
-
-            if (choice == 1) {
-
-                std::string name = getInput<std::string>("Podaj imię: ");
-                int age = getInput<int>("Podaj wiek: ");
-
-                Person personToSend{name, age, std::chrono::duration_cast<std::chrono::milliseconds>(
-                    std::chrono::system_clock::now().time_since_epoch()).count()};
-
-                Json::Value jsonPerson = serializePerson(personToSend);
-
-                ws.write(net::buffer(Json::writeString(Json::StreamWriterBuilder(), jsonPerson)));
-
-            } else if (choice == 2) {
-
-                ws.write(net::buffer("get_latest_records"));
-
-                beast::flat_buffer buffer;
-                ws.read(buffer);
-
-                std::cout << "Otrzymano: " << beast::make_printable(buffer.data()) << std::endl;
-
-                const char* bufferData = boost::asio::buffer_cast<const char*>(buffer.data());
-                std::size_t bufferSize = boost::asio::buffer_size(buffer.data());
-
-                char* charBuffer = new char[bufferSize + 1];
-                std::memcpy(charBuffer, bufferData, bufferSize);
-                charBuffer[bufferSize] = '\0';
-
-                iterateCharBuffer(charBuffer, bufferSize);
-
-                delete[] charBuffer;
-
-                buffer.consume(buffer.size());
-
-            } else if (choice == 3) {
-
-                std::cout << "Zamykanie programu...\n";
-                break;
-
-            } else {
-
-                std::cout << "Nieprawidłowy wybór. Spróbuj ponownie.\n";
-                
-            }
-
-            std::this_thread::sleep_for(std::chrono::milliseconds(200));
-        }
-
-    } catch (std::exception const& e) {
-        std::cerr << "Błąd: " << e.what() << std::endl;
-        return EXIT_FAILURE;
-    }
-
-    return EXIT_SUCCESS;
-}
diff --git a/cpp/try/uri.cpp b/cpp/try/uri.cpp
deleted file mode 100644
index cff7149..0000000
--- a/cpp/try/uri.cpp
+++ /dev/null
@@ -1,53 +0,0 @@
-#include <iostream>
-#include <tuple>
-#include <regex>
-
-#include <boost/asio.hpp>
-#include <boost/beast.hpp>
-#include <jsoncpp/json/json.h>
-
-namespace beast = boost::beast;
-namespace websocket = beast::websocket;
-namespace net = boost::asio;
-using tcp = boost::asio::ip::tcp;
-
-std::tuple<std::string, std::string, std::string> parseURI(const std::string& uri) {
-    std::regex uriRegex(R"(^ws://([^:/]+):(\d+)(/.+)$)");
-    std::smatch match;
-
-    if (std::regex_match(uri, match, uriRegex)) {
-        return std::make_tuple(match[1].str(), match[2].str(), match[3].str());
-    } else {
-        throw std::invalid_argument("Nieprawidłowe URI");
-    }
-}
-
-int main() {
-    std::string uri = "ws://172.24.0.3:3333";
-    std::cout << "Dostarczone URI: " << uri << std::endl;
-
-    try {
-        auto uriParts = parseURI(uri);
-        std::string host, port, endpoint;
-        std::tie(host, port, endpoint) = uriParts;
-
-        net::io_context io_context;
-
-        // Utwórz obiekt WebSocket
-        websocket::stream<tcp::socket> ws(io_context);
-
-        // Połącz z serwerem WebSocket
-        tcp::resolver resolver(io_context);
-        auto endpoints = resolver.resolve(host, port);
-        net::connect(ws.next_layer(), endpoints);
-
-        // Wysyłanie danych na serwer WebSocket
-        ws.handshake(host, endpoint);
-
-    } catch (const std::exception& e) {
-        std::cerr << "Błąd: " << e.what() << std::endl;
-        return EXIT_FAILURE;
-    }
-
-    return EXIT_SUCCESS;
-}