/*funkcja sprawdza czy to nie koniec pliku*/
czyKoniecPliku(strumienPliku) := 
fposition(strumienPliku)>flength(strumienPliku)$

/*logarytm dwojkowy bo w maximie nie ma*/
log2(x):=log(x)/log(2)$


/*lispowa funkcja odczytywania znaku z pliku*/
:lisp (defun $read_char(strumienPliku)(read-char strumienPliku))

/*zmapowanie jej do maximy + wyrzucenie 3 znaków bo maxima dodaje*/
readChar(strumienPliku):=
substring(string(read_char(strumienPliku)),3)

/*lispowa funkcja sprawdzania czy istnieje dany plik*/
:lisp (defun $file_exists(nazwaPliku)(probe-file nazwaPliku))

/*znowu mapowanie do maximy*/
fileExists(nazwaPliku):=
if(file_exists(nazwaPliku) = false) then false else true$


/*funkcja generuje nazwe kolejnego pliku*/
nastepnyPlik(nazwaPliku):=
block([],
rozszerzenie:sreverse(substring(sreverse(nazwaPliku),1,5)),
prefixPliku:sreverse(substring(sreverse(nazwaPliku),9)),
licznikPliku:sreverse(substring(sreverse(nazwaPliku),5,9)),
licznikLiczba:parse_string(licznikPliku)+10000,
licznikLiczba:licznikLiczba+1,
licznikPliku:substring(string(licznikLiczba),2),
return (concat(prefixPliku,concat(licznikPliku,rozszerzenie)))
)$

/*wartosci ustawiane przy inicjowniu pamieci, ulatwiajace potem dzialanie na tej pamieci*/
wymiarX:0;
wymiarY:0;
iloscPamieci:0


/*funkcja testowa do sprawdzania pliku, w sumie nie istotna*/ 
sprawdzPlik(nazwa):=
block([],
licznik:0,
strumienPliku: openr(nazwa),
while(not czyKoniecPliku(strumienPliku)) do 
block([],
znak:readChar(strumienPliku),
if(znak=",") then block([],wymiarY:wymiarY+1,if(licznik>wymiarX) then wymiarX:licznik,iloscPamieci:iloscPamieci+licznik,licznik:0) else licznik:licznik+1
),
close(strumienPliku)
)$


/*inicjowanie pamieci zaczynajacej sie plikiem podanym w nazwie*/ 
/*format nazwy np c:\\dane\\pamiec0001.txt*/
inicjalizujPamiec(nazwaPliku):=
block([],
wymiarX:0,
wymiarY:0,
adresPliku:nazwaPliku,
sprawdzPlik(nazwaPliku),
while (fileExists(nastepnyPlik(nazwaPliku))) do 
block([],
nazwaPliku:nastepnyPlik(nazwaPliku),
sprawdzPlik(nazwaPliku)
)
)$


/*odczytywanie pamieci pod zadanym adresem*/ 
czytajPamiec(x,y):=
block([],
licznikX:0,
licznikY:0,
wynik:"X",
mamWynik:false,
staryAdres:adresPliku,
wymiarOK:false,
if(x<wymiarX and y<wymiarY) then wymiarOK:true,
while (fileExists(adresPliku) and (not mamWynik) and (wymiarOK)) do 
block([],
/*print(adresPliku),*/
strPliku: openr(adresPliku),
while ((not czyKoniecPliku(strPliku)) and (not mamWynik)) do  
block([],
znak:readChar(strPliku),
/*print(znak),*/
if(licznikX=x and licznikY=y and (not znak=",")) then block([],mamWynik:true,wynik:znak),
if(znak=",") then block([],licznikY:licznikY+1,licznikX:0) else licznikX:licznikX+1
),
close(strPliku),
adresPliku:nastepnyPlik(adresPliku)
),
adresPliku:staryAdres,
return (wynik)
)$


/*rysowanie struktury pliku, w sumie nie wazne*/ 
rysujPlik(nazwaPliku):=
block([],
strumienPliku: openr(nazwaPliku),
macierzL:matrix([]),
macierzC:matrix([]),
czyPusta:true,
czyPierwsza:true,
licznik:0,
while(not czyKoniecPliku(strumienPliku)) do 
block([],
znak:readChar(strumienPliku),
if (not znak=",") then block([],licznik:licznik+1,macierzL:addcol(macierzL,matrix([znak])))
else if(not licznik=0) then block([],
for i:licznik thru wymiarX-1 step 1 do macierzL:addcol(macierzL,matrix(["X"])),
licznik:0,
if(czyPierwsza) then block([],czyPierwsza:false,macierzC:macierzL) else macierzC:addrow(macierzC,macierzL),
macierzL:matrix([])),
czyPusta:true
),
close(strumienPliku),
return(macierzC)
)$


/*rysywanie jak wyglada pamiec*/ 
rysujPamiec(nazwaPliku):=
block([],
macierzWynik:matrix([]),
pierwszyRaz:true,
while (fileExists(nazwaPliku)) do 
block([],
if(pierwszyRaz) then block([],macierzWynik:rysujPlik(nazwaPliku),pierwszyRaz:false) else 
macierzWynik:addrow(macierzWynik,rysujPlik(nazwaPliku)),
nazwaPliku:nastepnyPlik(nazwaPliku)
),
return (macierzWynik)
)$


/*Rysowanie wzorca Nr1, czyli krzyzyka*/ 
znajdzWzorzecNr1 (liczba) :=
for j:0 thru wymiarY-3 step 1 do 
block([],
for i:0 thru wymiarX-2 step 1 do 
block([],
wartosc:czytajPamiec(i,j),
if(wartosc="X") then i:wymiarX else
if(czytajPamiec(i,j+1)=wartosc) then if(czytajPamiec(i,j+2)=wartosc) then if(czytajPamiec(i+1,j+1)=wartosc) then if(czytajPamiec(i-1,j+1)=wartosc) then print(i,j)
)
)$


/*obliczanie adresow wzorca ze wzorca zadanego macierza*/ 
dajAdresy(macierzWzorca):=
block([],
[ileWierszy,ileKolumn]:matrix_size(macierzWzorca),
wynik:[],
maxX:0,
maxY:0,
for j:1 thru ileWierszy step 1 do 
for i:1 thru ileKolumn step 1 do 
if(macierzWzorca[j][i]=l) then block([],wynik:append(wynik,[[i-1,j-1]]),
maxX:max(maxX,i),
maxY:max(maxY,j)
),
[korektaX,korektaY]:wynik[1],
for y:1 thru length(wynik) step 1 do wynik[y]:[wynik[y][1]-korektaX,wynik[y][2]-korektaY],
return (append(append([[korektaX,korektaY]],[[maxX-korektaX,maxY-korektaY]]),wynik))
)$


/*wyszukiwanie wzorca zadanego macierza*/ 
znajdzWzorzecNr2 (macierzWzorca) :=
block([],
listaAdresow:dajAdresy(macierzWzorca),
minX:listaAdresow[1][1],
minY:listaAdresow[1][2],
maxX:listaAdresow[2][1],
maxY:listaAdresow[2][2],
for j:minY thru wymiarY-maxY step 1 do 
block([],
for i:minX thru wymiarX-maxX step 1 do  
block([],
wartosc:czytajPamiec(i,j),
jestWynik:true,
if(wartosc="X") then block(i:wymiarX,jestWynik:false) else 
for y:4 thru length(listaAdresow) step 1 do 
if(not czytajPamiec(i+listaAdresow[y][1],j+listaAdresow[y][2])=wartosc) then block([],y:length(listaAdresow)+1,jestWynik:false),
if(jestWynik) then print(i,j)
)
)
)$

/*wyznaczanie kolejnosci pamieci przy zginaniu*/ 
zegnij(macierzAZ1,macierzAZ2):=
block(
[p,n]:matrix_size(macierzAZ1),
for i:n thru n/2+1 step -1 do macierzAZ1:submatrix(macierzAZ1,i),
for i:1 thru n/2 step 1 do macierzAZ2:submatrix(macierzAZ2,1),
return (addrow(reverse(transpose(reverse(transpose(macierzAZ2)))),macierzAZ1))
)$

/*zginanie pamieci na n czesci*/ 
zegnijPamiec(n):=
block(
ileZgiec:n,
logn:n,
wymiarZY:ceiling(wymiarY/ileZgiec),
macierzA1:matrix([]),
macierzA2:matrix([]),
macierzWynikowa:matrix([]),
for i:1 thru n do macierzA1:addcol(macierzA1,[i]),
for i:1 thru n do macierzA2:addcol(macierzA2,[i]),
macierzWynikowa:macierzA1,
if(logn=2) then logn:1,
for j:0 thru log2(logn) do macierzWynikowa:zegnij(macierzWynikowa,macierzWynikowa),
listaAdresowPoZgieciu:(transpose(reverse(macierzWynikowa))[1])
)$

/*czytanie ze zgietej pamieci*/ 
czytajPamiecZG(x,y,z):=
if(z<ileZgiec) then block(
ktoryBlok:listaAdresowPoZgieciu[z+1]-1,
wielkoscBloku:ceiling(wymiarY/ileZgiec),
if(y<wielkoscBloku) then block(if not evenp(ktoryBlok) then czytajPamiec(x,((ktoryBlok+1)*wielkoscBloku-y-1)) else 
czytajPamiec(x,((ktoryBlok)*wielkoscBloku+y))) else "X"
)$

/*skladanie pamieci*/ 
zlorz(n):=
block(
ileZlorzen:n,
wymiarZY:ceiling(wymiarY/ileZlorzen)
)$

/*czytanie zlorzonej pamieci*/ 
czytajPamiecZL(x,y,z):=
if(z<ileZlorzen) then block(
wielkoscBloku:ceiling(wymiarY/ileZlorzen),
if(y<wielkoscBloku) then block(
czytajPamiec(x,((z)*wielkoscBloku+y))) else false
)$


/*znajdowanie wzorca nr1 w zgietej pamieci*/ 
znajdzWzorzecNr1Z (liczba) :=
for f:0 thru ileZgiec-1 step 1 do 
block(
for j:0 thru wymiarZY-3 step 1 do 
block([],
for i:0 thru wymiarX-2 step 1 do 
block([],
wartosc:czytajPamiecZG(i,j,f),
if(wartosc="X") then i:wymiarX else
if(czytajPamiecZG(i,j+1,f)=wartosc) then if(czytajPamiecZG(i,j+2,f)=wartosc) then if(czytajPamiecZG(i+1,j+1,f)=wartosc) then if(czytajPamiecZG(i-1,j+1,f)=wartosc) then print(i,j,f)
))
)$


/*znajdowanie wzorca nr 1 w zlorzonej pamieci*/ 
znajdzWzorzecNr1ZL (liczba) :=
for f:0 thru ileZlorzen-1 step 1 do 
block(
for j:0 thru wymiarZY-3 step 1 do 
block([],
for i:0 thru wymiarX-2 step 1 do 
block([],
wartosc:czytajPamiecZL(i,j,f),
if(wartosc="X") then i:wymiarX else
if(czytajPamiecZL(i,j+1,f)=wartosc) then if(czytajPamiecZL(i,j+2,f)=wartosc) then if(czytajPamiecZL(i+1,j+1,f)=wartosc) then if(czytajPamiecZL(i-1,j+1,f)=wartosc) then print(i,j,f)
))
)$


/*znajdowanie wzoraca zadanego macierza w zgietej pamieci*/ 
znajdzWzorzecNr2Z (macierzWzorca) :=
block([],
listaAdresow:dajAdresy(macierzWzorca),
minX:listaAdresow[1][1],
minY:listaAdresow[1][2],
maxX:listaAdresow[2][1],
maxY:listaAdresow[2][2],
for f:0 thru ileZgiec-1 step 1 do 
block(
for j:minY thru wymiarZY-maxY step 1 do 
block([],
for i:minX thru wymiarX-maxX step 1 do  
block([],
wartosc:czytajPamiecZG(i,j,f),
jestWynik:true,
if(wartosc="X") then block(i:wymiarX,jestWynik:false) else 
for y:4 thru length(listaAdresow) step 1 do 
if(not czytajPamiecZG(i+listaAdresow[y][1],j+listaAdresow[y][2],f)=wartosc) then block([],y:length(listaAdresow)+1,jestWynik:false),
if(jestWynik) then print(i,j,f)
)
)
)
)$


/*znajdowanie wzoraca zadanego macierza w zlorzonej pamieci*/ 
znajdzWzorzecNr2ZL (macierzWzorca) :=
block([],
listaAdresow:dajAdresy(macierzWzorca),
minX:listaAdresow[1][1],
minY:listaAdresow[1][2],
maxX:listaAdresow[2][1],
maxY:listaAdresow[2][2],
for f:0 thru ileZlorzen-1 step 1 do 
block(
for j:minY thru wymiarZY-maxY step 1 do 
block([],
for i:minX thru wymiarX-maxX step 1 do  
block([],
wartosc:czytajPamiecZL(i,j,f),
jestWynik:true,
if(wartosc="X") then block(i:wymiarX,jestWynik:false) else 
for y:4 thru length(listaAdresow) step 1 do 
if(not czytajPamiecZL(i+listaAdresow[y][1],j+listaAdresow[y][2],f)=wartosc) then block([],y:length(listaAdresow)+1,jestWynik:false),
if(jestWynik) then print(i,j,f)
)
)
)
)$

/*znajdzWzorzecNr2ZL(matrix([x,l,x],[l,l,l],[x,l,x]))*/ 


/*obliczanie adresow wzorca dla wzorca 3D zadanego macierza*/ 
dajAdresy3D(macierzWzorca):=
block([],
[glebokosc,szerokosc]:matrix_size(macierzWzorca),
[ileWierszy,ileKolumn]:matrix_size(macierzWzorca[1][1]),
wynik:[],
maxX:0,
maxY:0,
maxZ:0,
for f:1 thru glebokosc step 1 do 
for j:1 thru ileWierszy step 1 do 
for i:1 thru ileKolumn step 1 do 
if(macierzWzorca[f][1][j][i]=l) then block([],wynik:append(wynik,[[i-1,j-1,f-1]]),
maxX:max(maxX,i),
maxY:max(maxY,j),
maxZ:max(maxZ,f)
),
[korektaX,korektaY,korektaZ]:wynik[1],
for y:1 thru length(wynik) step 1 do wynik[y]:[wynik[y][1]-korektaX,wynik[y][2]-korektaY,wynik[y][3]-korektaZ],
return (append(append([[korektaX,korektaY,korektaZ]],[[maxX-korektaX,maxY-korektaY,maxZ-korektaZ]]),wynik))
)$


/*znajdowanie wzorca 3D w zgietej pamieci*/ 
znajdzWzorzec3D (macierzWzorca) :=
block([],
listaAdresow3D:dajAdresy3D(macierzWzorca),
minX:listaAdresow3D[1][1],
minY:listaAdresow3D[1][2],
minZ:listaAdresow3D[1][3],
maxX:listaAdresow3D[2][1],
maxY:listaAdresow3D[2][2],
maxZ:listaAdresow3D[2][3],
for f:minZ thru ileZgiec-maxZ step 1 do 
block(
for j:minY thru wymiarZY-maxY step 1 do 
block([],
for i:minX thru wymiarX-maxX step 1 do  
block([],
wartosc:czytajPamiecZG(i,j,f),
jestWynik:true,
if(wartosc="X") then block(i:wymiarX,jestWynik:false) else 
for y:4 thru length(listaAdresow3D) step 1 do 
if(not czytajPamiecZG(i+listaAdresow3D[y][1],j+listaAdresow3D[y][2],f+listaAdresow3D[y][3])=wartosc) then block([],y:length(listaAdresow3D)+1,jestWynik:false),
if(jestWynik) then print(i,j,f)
)
)
)
)$

/*znajdzWzorzec3D(matrix([matrix([x,l],[x,x])],[matrix([l,x],[x,x])],[matrix([x,x],[x,x])]))*/



/*znajdowanie wzorca 3D w zlorzonej pamieci*/ 
znajdzWzorzec3DZL (macierzWzorca) :=
block([],
listaAdresow3D:dajAdresy3D(macierzWzorca),
minX:listaAdresow3D[1][1],
minY:listaAdresow3D[1][2],
minZ:listaAdresow3D[1][3],
maxX:listaAdresow3D[2][1],
maxY:listaAdresow3D[2][2],
maxZ:listaAdresow3D[2][3],
for f:minZ thru ileZlorzen-maxZ step 1 do 
block(
for j:minY thru wymiarZY-maxY step 1 do 
block([],
for i:minX thru wymiarX-maxX step 1 do  
block([],
wartosc:czytajPamiecZL(i,j,f),
jestWynik:true,
if(wartosc="X") then block(i:wymiarX,jestWynik:false) else 
for y:4 thru length(listaAdresow3D) step 1 do 
if(not czytajPamiecZL(i+listaAdresow3D[y][1],j+listaAdresow3D[y][2],f+listaAdresow3D[y][3])=wartosc) then 

block([],y:length(listaAdresow3D)+1,jestWynik:false),
if(jestWynik) then print(i,j,f)
)
)
)
)$


/*obliczanie wszystkich mozliwych parametrow szescianu dla danej pamieci o dlugosci n*/ 
dajParametry(n):=
block(
parametry:[],
for M:1 step 1 while (M<=n) do 
for N:1 step 1 while ((M*N)<=n) do 
for O:1 step 1 while ((M*N*O)<=n) do 
if((M*N*O)=n) then parametry:append(parametry,[[M,N,O]]),
return (parametry)
)$


/*odczytywanie pamieci ciaglej*/ 
czytajPamiecCiagla(x):=
block([],
licznikX:0,
wynik:"X",
mamWynik:false,
staryAdres:adresPliku,
wymiarOK:false,
if(x<iloscPamieci) then wymiarOK:true,
while (fileExists(adresPliku) and (not mamWynik) and (wymiarOK)) do 
block([],
/*print(adresPliku),*/
strPliku: openr(adresPliku),
while ((not czyKoniecPliku(strPliku)) and (not mamWynik)) do  
block([],
znak:readChar(strPliku),
/*print(znak),*/
if(licznikX=x and (not znak=",")) then block([],mamWynik:true,wynik:znak),
if(not znak=",") then licznikX:licznikX+1
),
close(strPliku),
adresPliku:nastepnyPlik(adresPliku)
),
adresPliku:staryAdres,
return (wynik)
)$

/*odczytywanie pamieci ciaglej z zadanego szescianu wymiarami M,N,O*/ 
czytajZSzescianu(x,y,z,M,N,O):=
if(x<M and y<N and z<O) then czytajPamiecCiagla(x+(M*y)+(z*(M*N))) else "X"$


/*wyszukiwanie wzorca 3D zadanego macierza w zadanym szecianie*/
znajdzWzorzec3DWSzescianie (macierzWzorca,M,N,O) :=
block([],
listaAdresow3D:dajAdresy3D(macierzWzorca),
minX:listaAdresow3D[1][1],
minY:listaAdresow3D[1][2],
minZ:listaAdresow3D[1][3],
maxX:listaAdresow3D[2][1],
maxY:listaAdresow3D[2][2],
maxZ:listaAdresow3D[2][3],
for f:minZ thru O-maxZ step 1 do 
block(
for j:minY thru N-maxY step 1 do 
block([],
for i:minX thru M-maxX step 1 do  
block([],
wartosc:czytajZSzescianu(i,j,f,M,N,O),
jestWynik:true,
if(wartosc="X") then block(i:wymiarX,jestWynik:false) else 
for y:4 thru length(listaAdresow3D) step 1 do 
if(not czytajZSzescianu(i+listaAdresow3D[y][1],j+listaAdresow3D[y][2],f+listaAdresow3D[y][3],M,N,O)=wartosc) then block([],y:length(listaAdresow3D)+1,jestWynik:false),
if(jestWynik) then print(i,j,f)
)
)
)
)$

/*wyszukiwanie wozrca 3d we wszystkich mozliwych szescianach dla naszej pamieci*/ 
przeszukajWszystkieSzesciany(macierzWzorca):=
block(
listaParametrow:dajParametry(iloscPamieci),
for i:1 thru length(listaParametrow) do 
block(
print("Dla(",listaParametrow[i][1],listaParametrow[i][2],listaParametrow[i][3],")"),
znajdzWzorzec3DWSzescianie(macierzWzorca,listaParametrow[i][1],listaParametrow[i][2],listaParametrow[i][3])
)
)$

/*rysowanie zgietej pamieci, nazwaPliku tylko poto by mozna bylo w maximie zdefiniowac f-cje*/ 
rysujPamiec3D(nazwaPliku):=
block([],
macierzWynik:matrix([]),
listaBloku:matrix([]),
macierzBloku:matrix([]),
pierwszePrzejscie:true,
for f:0 thru ileZgiec-1 do 
block(
for j:0 thru wymiarZY-1 do 
block(
for i:0 thru wymiarX-1 do 
listaBloku:addcol(listaBloku,matrix([czytajPamiecZG(i,j,f)])), 
if(matrix_size(macierzBloku)[2]=0)then macierzBloku:listaBloku else macierzBloku:addrow(macierzBloku,listaBloku),
listaBloku:matrix([])
),
macierzWynik:addcol(macierzWynik,matrix([macierzBloku])),
macierzBloku:matrix([])
),
return (macierzWynik)
)$


/*rysowanie zlorzonej pamieci 3D....*/ 
rysujPamiec3Dv2(nazwaPliku):=
block([],
macierzWynik:matrix([]),
listaBloku:matrix([]),
macierzBloku:matrix([]),
pierwszePrzejscie:true,
for f:0 thru ileZlorzen-1 do 
block(
for j:0 thru wymiarZY-1 do 
block(
for i:0 thru wymiarX-1 do 
listaBloku:addcol(listaBloku,matrix([czytajPamiecZL(i,j,f)])), 
if(matrix_size(macierzBloku)[2]=0)then macierzBloku:listaBloku else macierzBloku:addrow(macierzBloku,listaBloku),
listaBloku:matrix([])
),
macierzWynik:addcol(macierzWynik,matrix([macierzBloku])),
macierzBloku:matrix([])
),
return (macierzWynik)
)$


/*rysowanie ciaglej pamieci 3d dla zadanych wymiarow M,N,O*/ 
rysujPamiec3Dv3(M,N,O):=
block([],
macierzWynik:matrix([]),
listaBloku:matrix([]),
macierzBloku:matrix([]),
pierwszePrzejscie:true,
for f:0 thru O-1 do 
block(
for j:0 thru N-1 do 
block(
for i:0 thru M-1 do 
listaBloku:addcol(listaBloku,matrix([czytajZSzescianu(i,j,f,M,N,O)])), 
if(matrix_size(macierzBloku)[2]=0)then macierzBloku:listaBloku else macierzBloku:addrow(macierzBloku,listaBloku),
listaBloku:matrix([])
),
macierzWynik:addcol(macierzWynik,matrix([macierzBloku])),
macierzBloku:matrix([])
),
return (macierzWynik)
)$


/*zaznaczanie wzorca 3d danego macierza w zgietej pamieci, gdzie to lista [x,y,z]*/ 
/*zawierajaca adres gdzie jest wzorzec*/ 
zaznaczWzorzec3DZG (macierzWzorca,gdzie) :=
block([],
listaAdresow3D:dajAdresy3D(macierzWzorca),
macierzWyniku:rysujPamiec3D("x"),
for y:3 thru length(listaAdresow3D) step 1 do 
block( 
wartosc:macierzWyniku[1][gdzie[3]+listaAdresow3D[y][3]+1][gdzie[2]+listaAdresow3D[y][2]+1][gdzie[1]+listaAdresow3D[y][1]+1],
macierzWyniku[1][gdzie[3]+listaAdresow3D[y][3]+1][gdzie[2]+listaAdresow3D[y][2]+1][gdzie[1]+listaAdresow3D[y][1]+1]:concat("?",concat(wartosc,"?"))),
return (macierzWyniku)
)$

/*zaznaczWzorzec3DZG(matrix([matrix([x,l],[x,x])],[matrix([x,x],[l,l])],[matrix([x,x],[x,x])]),[2,1,0])*/

/*zaznaczanie wozrca 3d danego macierza w zlorzonej pamieci*/ 
zaznaczWzorzec3DZL (macierzWzorca,gdzie) :=
block([],
listaAdresow3D:dajAdresy3D(macierzWzorca),
macierzWyniku:rysujPamiec3Dv2("x"),
for y:3 thru length(listaAdresow3D) step 1 do 
block( 
wartosc:macierzWyniku[1][gdzie[3]+listaAdresow3D[y][3]+1][gdzie[2]+listaAdresow3D[y][2]+1][gdzie[1]+listaAdresow3D[y][1]+1],
macierzWyniku[1][gdzie[3]+listaAdresow3D[y][3]+1][gdzie[2]+listaAdresow3D[y][2]+1][gdzie[1]+listaAdresow3D[y][1]+1]:concat("?",concat(wartosc,"?"))),
return (macierzWyniku)
)$    

/*zaznaczWzorzec3DZL(matrix([matrix([x,l],[x,l])],[matrix([x,x],[x,l])],[matrix([x,x],[x,x])]),[1,1,0])*/

/*zaznaczanie wzorca 3d zadanego macierza w szescianie z pamieci ciaglej zadanego parametrami M,N,O*/ 
zaznaczWzorzec3DSzescian (macierzWzorca,gdzie,M,N,O) :=
block([],
listaAdresow3D:dajAdresy3D(macierzWzorca),
macierzWyniku:rysujPamiec3Dv3(M,N,O),
for y:3 thru length(listaAdresow3D) step 1 do 
block( 
wartosc:macierzWyniku[1][gdzie[3]+listaAdresow3D[y][3]+1][gdzie[2]+listaAdresow3D[y][2]+1][gdzie[1]+listaAdresow3D[y ][1]+1],
macierzWyniku[1][gdzie[3]+listaAdresow3D[y][3]+1][gdzie[2]+listaAdresow3D[y][2]+1][gdzie[1]+listaAdresow3D[y][1]+1]: concat("?",concat(wartosc,"?"))),
return (macierzWyniku)
)$

/*zaznaczWzorzec3DSzescian(matrix([matrix([x,l],[x,x])],[matrix([x,l],[x,l])],[matrix([x,x],[x,x])]),[2,0,1],4,4,4)*/