:-set_prolog_flag(allow_dot_in_atom,true).

:-style_check(-singleton).
grammar_no(1460749322).
:- op(550, xfy, '.').

:- style_check(-singleton).

obldest(neut, neut, neut).

obldest(pyt, pyt, neut).

obldest(pyt, neut, pyt).

obldest(pyt, pyt, pyt).

obldest(pz, pz, pyt).

obldest(pz, pz, neut).

obldest(wz(A, B), wz(A, B), neut).

obldest_iter(A, B, A) :-
	var(B), !.

obldest_iter(neut, neut, neut).

obldest_iter(neut, pyt, pyt).

obldest_iter(pyt, neut, pyt).

obldest_iter(pyt, pyt, pyt).

obldest_iter(wz(A, B), neut, wz(A, B)).

obldest_iter(pz, neut, pz).

obldest_iter(pz, pyt, pz).

obldest(A, [A]) :- !.

obldest(C, [A, B|E]) :-
	obldest_iter(A, B, D),
	obldest(C, [D|E]).

tylko_neut_pyt(neut).

tylko_neut_pyt(pyt).

oblzap_iter(bzap, bzap, bzap).

oblzap_iter(bzap, A, B) :-
	nonvar(A),
	member(A, [tk, tyle]),
	A=B, !.

oblzap_iter(A, bzap, B) :-
	nonvar(A),
	member(A, [tk, tyle]),
	A=B, !.

oblzap(A, [A]) :- !.

oblzap(C, [A, B|E]) :-
	oblzap_iter(A, B, D),
	oblzap(C, [D|E]).

oblneg(ani, nie(ani), nie(ani), nie(ani)) :- !.

oblneg(B, A, A, A) :-
	B\=ani.

sprawdz_neg(ani, nie(ani)) :- !.

sprawdz_neg(A, _) :-
	A\=ani.

sprawdz_neg_fzd(ani, []) :- !.

sprawdz_neg_fzd(ani, [nie(ani)|A]) :- !,
	sprawdz_neg_fzd(ani, A).

sprawdz_neg_fzd(A, _) :-
	A\=ani.

oblink(ni, ni, ni) :- !.

oblink(i(A, B), i(A, B), ni) :- !.

oblink(i(A, B), ni, i(A, B)).

oblink_iter(ni, ni, ni) :- !.

oblink_iter(ni, i(A, B), i(A, B)) :- !.

oblink_iter(i(A, B), ni, i(A, B)).

oblink(A, [A]) :- !.

oblink(C, [A, B|E]) :-
	oblink_iter(A, B, D),
	oblink(C, [D|E]).

zgodne_pk(p, 0).

zgodne_pk(bp, p).

zgodne_pk(0, 0).

zgodne_pk(0, p).

zgodne_pk(wp, bp).

zgodne_pk(wp, 0).

zgodne_pk(p, wb).

zgodne_pk(bp, db).

zgodne_pk(p, db).

zgodne_pk(0, db).

zgodne_pk(pw, wpw).

zgodne_pk(wkw, kw).

zgodne_pk(pw, bp).

zgodne_pk(pw, 0).

zgodne_pk(bp, kw).

zgodne_pk(0, kw).

sprawdz_pk_iter((A| C), (D| B), (A| B)) :-
	zgodne_pk(C, D).

oblpk(A, [A]) :- !.

oblpk(C, [A, B|E]) :-
	sprawdz_pk_iter(A, B, D),
	oblpk(C, [D|E]).

sprawdz_posiłk(bezpo, A, bezpo) :-
	var(A).

sprawdz_posiłk(bezpo, A, B) :-
	nonvar(A),
	(   A=agl(_)
	->  B=posiłk(A)
	;   B=ost(A)
	).

sprawdz_posiłk(ost(A), B, posiłk(A)) :-
	var(B).

sprawdz_posiłk(posiłk(A), B, posiłk(A)) :-
	var(B).

sprawdz_post_posiłk(pierw(A), B, A) :-
	var(B), !.

sprawdz_post_posiłk(bezpo, A, bezpo) :-
	var(A), !.

sprawdz_post_posiłk(bezpo, A, posiłk(A)) :-
	nonvar(A), !,
	(   A=by(_)
	;   A=bedzie(_, _)
	).

sprawdz_post_posiłk(posiłk(A), B, posiłk(A)) :-
	var(B).

oblposiłk(bezpo, A, A).

oblposiłk(pierw(A), B, C) :-
	oblposiłk(A, B, C).

oblposiłk(posiłk(agl(B)), os/A/prze/ozn/3/C, os/A/prze/ozn/B/C).

oblposiłk(posiłk(niech), os/nd/ter/ozn/A/B, os/nd/_/roz/A/B) :-
	member(A, [1, 3]).

oblposiłk(posiłk(niech), os/dk/przy/ozn/A/B, os/dk/_/roz/A/B) :-
	member(A, [1, 3]).

oblposiłk(posiłk(niech), os/nd/przy/ozn/A/B, os/nd/_/roz/A/B) :-
	member(A, [1, 3]).

oblposiłk(posiłk(by(C)), A/B/prze/ozn/3/D, A/B/ter/war/C/D) :-
	member(A/C, [os/_, bos/3]).

oblposiłk(posiłk(byłby(B, tak)), os/A/prze/ozn/3/C, os/A/prze/war/B/C).

oblposiłk(posiłk(bedzie(A, B)), os/nd/prze/ozn/3/tak, os/nd/przy/ozn/A/B).

oblposiłk(posiłk(bedzie(A, B)), bok/nd/_/_/_/tak, os/nd/przy/ozn/A/B).

zgodnyznakk(neut, neut).

zgodnyznakk(neut, pyt).

zgodnyznakk(pyt, pyt).

spójnik_obrzynotwórczy(A, B) :-
	member(A/B,
	       
	       [ szk/i,
		 szk/albo,
		 szk/bądź,
		 szk/lub,
		 szk/ani,
		 rc/natomiast,
		 rc/alei,
		 rc/a,
		 rc/czyli,
		 rc/względnie,
		 rc/tymczasem,
		 po/żeby,
		 po/że,
		 po/zanim,
		 po/ponieważ,
		 po/podczas,
		 po/jeśli,
		 po/gdyby,
		 po/gdy,
		 po/dopóki,
		 po/choćby,
		 po/chociaż,
		 po/aż,
		 pc/więc,
		 pc/bo,
		 pc/to
	       ]).

oblicz_dest_agl(agl(_), A, agl) :- !,
	A=neut.

oblicz_dest_agl(_, A, A).

zroblistę_iter(B, A, [A|B]).

najwyżej3(A, _, B) :-
	A<3,
	B is A+1.

najwyżej(A, _, B) :-
	A>0,
	B is A-1.

conajmniej1(_, _, 1).

jeden_na_listę([A|B], A, B).

dwa_na_listę([A, B|C], [A, B], C).

trzy_na_listę([A, B, C|D], [A, B, C], D).

sprawdź_wyróżnik_w_szeregu(B, A) :-
	A\=sp:sz:B,
	A\=sp:sz:wykrz,
	A\=bc(_).

sprawdź_wyróżniki_w_szeregu(A, B) :-
	sprawdź_wyróżniki_w_szeregu(A, B, nic).

sprawdź_wyróżniki_w_szeregu(_, [], _) :- !.

sprawdź_wyróżniki_w_szeregu(C, [B|D], A) :-
	sprawdź_czy_bok(A, B, E),
	sprawdź_wyróżnik_w_szeregu(C, B),
	sprawdź_wyróżniki_w_szeregu(C, D, E).

sprawdź_czy_bok(nic, bok, bok) :- !.

sprawdź_czy_bok(bok, bok, bok) :- !.

sprawdź_czy_bok(B, A, nbok) :-
	A\=bok,
	B\=bok.

dopuszczalna_koordynacja([advp, or, infp(dk), infp(nd), np(bier), np(cel), np(dop), np(mian), np(narz), sentp(aż), sentp(gdy), sentp(jak), sentp(jakoby), sentp(jeśli), sentp(kiedy), sentp(pz), sentp(że), sentp(żeby), sentp(żeby2), prepnp(dla, dop), prepnp(do, dop), prepnp(ku, cel), prepnp(na, bier), prepnp(na, miej), prepnp('na polu', dop), prepnp('na temat', dop), prepnp(nad, narz), prepnp(o, bier), prepnp(o, miej), prepnp(od, dop), prepnp(po, bier), prepnp(po, miej), prepnp('po stronie', dop), prepnp(pod, bier), prepnp('pod względem', dop), prepnp(przeciw, cel), prepnp(przed, narz), prepnp(przez, bier), prepnp(przy, miej), prepnp(u, dop), prepnp(w, bier), prepnp(w, miej), prepnp('w dziedzinie', dop), prepnp('w kwestii', dop), prepnp('w sprawie', dop), prepnp(według, dop), prepnp(wskutek, dop), prepnp(z, dop), prepnp(z, narz), prepnp('z powodu', dop), prepnp(za, bier), prepnp(za, narz), sentp(bier, gdy), sentp(bier, int), sentp(bier, jak), sentp(bier, jakoby), sentp(bier, jeśli), sentp(bier, kiedy), sentp(bier, że), sentp(bier, żeby), sentp(bier, żeby2), sentp(cel, jak), sentp(cel, jakoby), sentp(cel, pz), sentp(cel, że), sentp(cel, żeby), sentp(cel, żeby2), sentp(dop, aż), sentp(dop, gdy), sentp(dop, jak), sentp(dop, jakoby), sentp(dop, kiedy), sentp(dop, pz), sentp(dop, że), sentp(dop, żeby), sentp(dop, żeby2), sentp(mian, gdy), sentp(mian, int), sentp(mian, jak), sentp(mian, jakoby), sentp(mian, jeśli), sentp(mian, kiedy), sentp(mian, że), sentp(mian, żeby), sentp(mian, żeby2), sentp(narz, jak), sentp(narz, pz), sentp(narz, że), sentp(narz, żeby), sentp(dla, dop, pz), sentp(dla, dop, żeby), sentp(do, dop, jak), sentp(do, dop, pz), sentp(do, dop, że), sentp(do, dop, żeby), sentp(do, dop, żeby2), sentp(ku, cel, że), sentp(ku, cel, żeby), sentp(na, bier, aż), sentp(na, bier, gdy), sentp(na, bier, jak), sentp(na, bier, jakby), sentp(na, bier, kiedy), sentp(na, bier, pz), sentp(na, bier, że), sentp(na, bier, żeby), sentp(na, bier, żeby2), sentp(na, miej, jak), sentp(na, miej, pz), sentp(na, miej, że), sentp(na, miej, żeby), sentp(na, miej, żeby2), sentp(na, str, pz), sentp(na, str, że), sentp(nad, narz, jak), sentp(nad, narz, pz), sentp(nad, narz, że), sentp(nad, narz, żeby), sentp(o, bier, jakoby), sentp(o, bier, pz), sentp(o, bier, że), sentp(o, bier, żeby), sentp(o, bier, żeby2), sentp(o, miej, jak), sentp(o, miej, jakoby), sentp(o, miej, pz), sentp(o, miej, że), sentp(o, miej, żeby), sentp(o, miej, żeby2), sentp(od, dop, jakoby), sentp(od, dop, pz), sentp(od, dop, że), sentp(od, dop, żeby), sentp(po, miej, jak), sentp(po, miej, pz), sentp(po, miej, że), sentp(przeciw, cel, gdy), sentp(przeciw, cel, jak), sentp(przeciw, cel, jakoby), sentp(przeciw, cel, kiedy), sentp(przeciw, cel, pz), sentp(przeciw, cel, że), sentp(przeciw, cel, żeby), sentp(przed, narz, pz), sentp(przed, narz, że), sentp(przed, narz, żeby), sentp(przez, bier, pz), sentp(przez, bier, że), sentp(przy, miej, jak), sentp(przy, miej, pz), sentp(przy, miej, że), sentp(przy, miej, żeby), sentp(w, bier, jak), sentp(w, bier, pz), sentp(w, bier, że), sentp(w, bier, żeby), sentp(w, bier, żeby2), sentp(w, miej, jak), sentp(w, miej, pz), sentp(w, miej, że), sentp(w, miej, żeby), sentp(z, dop, jak), sentp(z, dop, pz), sentp(z, dop, że), sentp(z, dop, żeby), sentp(z, narz, jak), sentp(z, narz, jakby), sentp(z, narz, pz), sentp(z, narz, że), sentp(z, narz, żeby), sentp(z, narz, żeby2), sentp(za, bier, pz), sentp(za, bier, że), sentp(za, bier, żeby), sentp(za, narz, gdy), sentp(za, narz, jak), sentp(za, narz, kiedy), sentp(za, narz, pz), sentp(za, narz, rel), sentp(za, narz, że), sentp(za, narz, żeby), sentp(za, str, pz)]).

dopuszczalna_koordynacja([prepnp(wokół, dop), sentp(wokół, dop, pz), sentp(wokół, dop, że), sentp(wokół, dop, żeby)]).

dopuszczalna_koordynacja([prepnp(wobec, dop), sentp(wobec, dop, pz), sentp(wobec, dop, że)]).

dopuszczalna_koordynacja([prepnp(poza, bier), sentp(poza, bier, pz), sentp(poza, bier, że)]).

dopuszczalna_koordynacja([prepnp(pod, narz), sentp(pod, narz, że), sentp(pod, narz, żeby)]).

dopuszczalna_koordynacja([prepnp(koło, dop), sentp(koło, dop, żeby)]).

dopuszczalna_koordynacja([prepnp('co do', dop), sentp('co do', dop, jakoby), sentp('co do', dop, pz), sentp('co do', dop, że), sentp('co do', dop, żeby)]).

dopuszczalna_koordynacja([prepnp(bez, dop), sentp(bez, dop, że), sentp(bez, dop, żeby)]).

dopuszczalna_koordynacja([np(part), sentp(part, że)]).

dopuszczalna_koord_iter([B|D]/A, C, E/A) :-
	B\=C,
	member(C, A),
	(   member(C, D)
	*-> E=[B|D]
	;   E=[C, B|D]
	).

obl_neg_fwe(psu, A, A, A).

obl_neg_fwe(psw, A, A, A).

obl_neg_fwe(os, A, A, A).

obl_neg_fwe(bos, A, A, A).

obl_neg_fwe(bok, A, A, B) :-
	var(B), !,
	A=B.

obl_neg_fwe(bok, req(A), tak, A).

obl_neg_fwe(bok, nie(A), nie(A), nie(A)).

zgodne_iter(A, A, A) :- !.

zgodne_iter(_, _, mie).

neg_do_sąsiada(A, A, A) :- !.

neg_do_sąsiada(A, req(A), req(A)) :- !.

neg_do_sąsiada(req(A), A, req(A)) :- !.

neg_do_sąsiada(A/C, B, A/B) :- !,
	once((   B\=req(_)
	     ;   A\=req(_),
		 C\=req(_)
	     ;   A=B
	     ;   C=B
	     )).

neg_do_sąsiada(A, B, A/B) :-
	(   A\=req(_)
	;   B\=req(_)
	).

sprawdz_fpt_noa((bp| p)/A/ (p| bp)/A) :- !.

sprawdz_fpt_noa(B/C/D/A) :-
	oblpk(A, [B, C, D]).

sprawdz_kl_noa(co, A, dop) :-
	równe(A, mian.bier), !.

sprawdz_kl_noa(co, A, A) :-
	różne(A, mian.bier), !.

sprawdz_kl_noa(B, A, A) :-
	różne(B, co).

sprawdz_kl_nod(A/B) :-
	A\==os,
	B\=kto.

sprawdz_kl_nod_prehead(dopmod/A) :-
	A\=kto.

sprawdz_kl_nod_head(B, A) :-
	(   A\=os, !
	;   var(B)
	).

sprawdz_fzd_noz(A/B/C/D, wz(który, A/B), A/B/C/D) :-
	C\=co.

sprawdz_fzd_noz(A/B/C/D, wz(jaki, A/B), A/B/C/D) :-
	member(C, [rzecz, przym]).

sprawdz_fzd_noz(A/B/C/D, wz(E, przys), A/B/C/D) :-
	member(C, [rzecz, przym]),
	member(E, [gdzie, skąd, dokąd, kiedy, gdy]).

sprawdz_fzd_noz(A/B/C/D, wz(E, A/B), A/B/C/D) :-
	member(E, [kto, co]),
	member(C, [rzecz, przym, kto, co]).

sprawdz_fzd_noz(A/B/C/tk, D, A/B/C/tk) :-
	member(D, [jakby, że, żeby, wz(jaki, _)]).

sprawdz_fzd_noz(A/B/C/tyle, D, A/B/C/tyle) :-
	member(D, [ile, jakby, że, żeby, wz(jaki, _)]).

obldest_fno_iter(A, B, A) :-
	var(B), !.

obldest_fno_iter(neut, neut, neut).

obldest_fno_iter(neut, pyt, pyt).

obldest_fno_iter(pyt, neut, pyt).

obldest_fno_iter(pyt, pyt, pyt).

obldest_fno_iter(wz(A, B), wz(A, B), wz(A, B)).

obldest_fno_iter(pz, pz, pz).

oblparam_fno_koor(A, B/mno/C/egz/_/wym([], _, [[]]), D/_/E/F/pre, G/_/H/I/pre, J) :-
	member(A, [i, przec, ani, nietylko, tak, zarówno, alei]),
	egzorcyzuj_fno(B,
		       C,
		       
		       [ D/E/F,
			 G/H/I
		       | J
		       ]).

oblparam_fno_koor(E, A/B/C/D/pre/wym(_, _, bw), _/_/_/_/pre, A/B/C/D/pre, _) :-
	\+ member(E, [i, przec, ani, nietylko, tak, zarówno, alei]).

oblparam_fno_koor(_, A/B/C/D/post/wym(_, _, bw), A/B/C/D/post, _/_/_/_/pre, _).

egzorcyzuj_fno(r(_, nmo(_)), 3, []) :- !.

egzorcyzuj_fno(E, H, [D/G/A|B]) :-
	member(A, [rzecz, os, uzg, egz]),
	egzorcyzuj_fno(C, F, B),
	egzorcyzuj_rodz(C, D, E),
	egzorcyzuj_os(F, G, H).

egzorcyzuj_os(A, _, A) :-
	var(A), !.

egzorcyzuj_os(_, A, A) :-
	var(A), !.

egzorcyzuj_os(A, B, A) :-
	A<B, !.

egzorcyzuj_os(B, A, A) :-
	B>=A.

egzorcyzuj_rodz(r(mn(m(zy)), mo), _, r(mn(m(zy)), mo)) :- !.

egzorcyzuj_rodz(_, r(mn(m(zy)), mo), r(mn(m(zy)), mo)) :- !.

egzorcyzuj_rodz(_, _, r(_, nmo(_))).

obl_pmp(A, C, D) :-
	sort(A, B),
	rozdziel(B, C, D).

rozdziel([A/B], A, B) :- !.

rozdziel(A, B, C) :-
	rozdziel2(A, B, C).

rozdziel2([], [], []).

rozdziel2([A/B|C], [A|D], [B|E]) :-
	rozdziel2(C, D, E).

sprawdz_kl_nie_sz(A) :-
	var(A), !.

sprawdz_kl_nie_sz(A) :-
	A\=sz.

obl_kl_licz(t(1), _) :- !,
	false.

obl_kl_licz(pyt, pyt) :- !.

obl_kl_licz(neut, neut) :- !.

obl_kl_licz(t(_), neut).

troj_licz(t(s), t(d)).

troj_licz(t(s), t(n)).

troj_licz(t(s), t(j)).

troj_licz(t(s), t(1)).

troj_licz(t(d), t(j)).

troj_licz(t(d), t(1)).

same_cyfry(A) :-
	atom_codes(A, B),
	\+ ( member(C, B),
	     \+ ( C>=48,
		  C=<57
		)
	   ).

klasa_licz(ile, pyt) :- !.

klasa_licz(jeden, t(1)) :- !.

klasa_licz(dwa, t(j)) :- !.

klasa_licz(trzy, t(j)) :- !.

klasa_licz(cztery, t(j)) :- !.

klasa_licz(dziewięć, t(j)) :- !.

klasa_licz(pięć, t(j)) :- !.

klasa_licz(sześć, t(j)) :- !.

klasa_licz(siedem, t(j)) :- !.

klasa_licz(osiem, t(j)) :- !.

klasa_licz(kilka, t(j)) :- !.

klasa_licz(parę, t(j)) :- !.

klasa_licz(dziesięć, t(n)) :- !.

klasa_licz(czternaście, t(n)) :- !.

klasa_licz(dziewiętnaście, t(n)) :- !.

klasa_licz(jedenaście, t(n)) :- !.

klasa_licz(osiemnaście, t(n)) :- !.

klasa_licz(piętnaście, t(n)) :- !.

klasa_licz(siedemnaście, t(n)) :- !.

klasa_licz(szesnaście, t(n)) :- !.

klasa_licz(trzynaście, t(n)) :- !.

klasa_licz(dwanaście, t(n)) :- !.

klasa_licz(kilkanaście, t(n)) :- !.

klasa_licz(paręnaście, t(n)) :- !.

klasa_licz(dwadzieścia, t(d)) :- !.

klasa_licz(czterdzieści, t(d)) :- !.

klasa_licz(trzydzieści, t(d)) :- !.

klasa_licz(dziewięćdziesiąt, t(d)) :- !.

klasa_licz(osiemdziesiąt, t(d)) :- !.

klasa_licz(pięćdziesiąt, t(d)) :- !.

klasa_licz(siedemdziesiąt, t(d)) :- !.

klasa_licz(sześćdziesiąt, t(d)) :- !.

klasa_licz(kilkadziesiąt, t(d)) :- !.

klasa_licz(parędziesiąt, t(d)) :- !.

klasa_licz(sto, t(s)) :- !.

klasa_licz(dwieście, t(s)) :- !.

klasa_licz(czterysta, t(s)) :- !.

klasa_licz(trzysta, t(s)) :- !.

klasa_licz(dziewięćset, t(s)) :- !.

klasa_licz(pięćset, t(s)) :- !.

klasa_licz(sześćset, t(s)) :- !.

klasa_licz(siedemset, t(s)) :- !.

klasa_licz(osiemset, t(s)) :- !.

klasa_licz(kilkaset, t(s)) :- !.

klasa_licz(paręset, t(s)) :- !.

klasa_licz(dwoje, t(j)) :- !.

klasa_licz(troje, t(j)) :- !.

klasa_licz(czterdzieścioro, t(d)) :- !.

klasa_licz(czternaścioro, t(n)) :- !.

klasa_licz(czworo, t(j)) :- !.

klasa_licz(dwadzieścioro, t(d)) :- !.

klasa_licz(dwanaścioro, t(n)) :- !.

klasa_licz(dziesięcioro, t(n)) :- !.

klasa_licz(dziewięcioro, t(j)) :- !.

klasa_licz(dziewiętnaścioro, t(n)) :- !.

klasa_licz(dziewięćdziesięcioro, t(d)) :- !.

klasa_licz(jedenaścioro, t(n)) :- !.

klasa_licz(kilkadziesięcioro, t(d)) :- !.

klasa_licz(kilkanaścioro, t(n)) :- !.

klasa_licz(kilkoro, t(j)) :- !.

klasa_licz(kilkudziesięcioro, t(d)) :- !.

klasa_licz(osiemdziesięcioro, t(d)) :- !.

klasa_licz(osiemnaścioro, t(n)) :- !.

klasa_licz(ośmioro, t(j)) :- !.

klasa_licz(pięcioro, t(j)) :- !.

klasa_licz(piętnaścioro, t(n)) :- !.

klasa_licz(pięćdziesięcioro, t(d)) :- !.

klasa_licz(siedemdziesięcioro, t(d)) :- !.

klasa_licz(siedemnaścioro, t(n)) :- !.

klasa_licz(siedmioro, t(j)) :- !.

klasa_licz(szesnaścioro, t(n)) :- !.

klasa_licz(sześcioro, t(j)) :- !.

klasa_licz(sześćdziesięcioro, t(d)) :- !.

klasa_licz(trzydzieścioro, t(d)) :- !.

klasa_licz(trzynaścioro, t(n)) :- !.

klasa_licz(_, neut).

wypowiedzenie(_, _, _) :-
	fail.

zdanie(L, A, N, O, P, Q, R, S, T, U, E, V, F, na) :-
	optional(W,
		 [B, D/znakkonca(C, po)|G],
		 A,
		 B,
		 cudz(z, po),
		 { I=t
		 },
		 {}),
	goal(znakkonca(C, po), B, H, D),
	zgodnyznakk(E, C),
	oblpk(_, [ (p| pw), F, (kw| p)]),
	optional(G, J, H, K, cudz(z, po), {I=f}, {}),
	optional(J, [], K, M, nawias(z, _, po), {}, {}),
	register(wypowiedzenie,
		 L,
		 M,
		 w,
		 
		 [ N/zdanie(O, P, Q, R, S, T, U, E, V, F, na)
		 | W
		 ],
		 X),
	wypowiedzenie(L, M, X).

zdanie(C, D, E, F, G, H, I, J, K, L, A, M, B, na) :-
	zgodnyznakk(A, neut),
	oblpk(_, [ (p| pw), B, (kw| p)]),
	register(wypowiedzenie,
		 C,
		 D,
		 w9,
		 
		 [ E/zdanie(F, G, H, I, J, K, L, A, M, B, na)
		 ],
		 N),
	wypowiedzenie(C, D, N).

zdanie(U, C, W, B, L, M, N, O, P, Q, A, S, H, po) :-
	tylko_neut_pyt(A),
	B\=bc(_),
	goal(przec(I, po), C, D, X),
	goal(spójnik(rc, K, ni, na), D, E, Y),
	goal(zdanie(F,
		    A1,
		    B1,
		    C1,
		    D1,
		    E1,
		    F1,
		    G,
		    ni,
		    J,
		    po),
	     E,
	     V,
	     Z),
	F\=bc(_),
	obldest(R, [A, G]),
	oblpk(T, [H, I, J]),
	register(zdanie(sp:r:K,
			L,
			M,
			N,
			O,
			P,
			Q,
			R,
			S,
			T,
			H1),
		 U,
		 V,
		 r1,
		 
		 [ W/zdanie(B, L, M, N, O, P, Q, A, S, H, po),
		   C,
		   X/przec(I, po),
		   D,
		   Y/spójnik(rc, K, ni, na),
		   E,
		   Z/zdanie(F, A1, B1, C1, D1, E1, F1, G, ni, J, po)
		 ],
		 G1),
	zdanie(U,
	       V,
	       G1,
	       sp:r:K,
	       L,
	       M,
	       N,
	       O,
	       P,
	       Q,
	       R,
	       S,
	       T,
	       H1).

zdanie(R, B, T, A, I, J, K, L, M, N, neut, P, F, po) :-
	A\=bc(_),
	goal(przec(V, na), B, C, U),
	goal(zdanie(D,
		    X,
		    Y,
		    Z,
		    A1,
		    B1,
		    C1,
		    E,
		    i(r, H),
		    G,
		    po),
	     C,
	     S,
	     W),
	D\=bc(_),
	obldest(O, [neut, E]),
	oblpk(Q, [F, (p| wp), G]),
	register(zdanie(sp:r:H,
			I,
			J,
			K,
			L,
			M,
			N,
			O,
			P,
			Q,
			E1),
		 R,
		 S,
		 r2,
		 
		 [ T/zdanie(A, I, J, K, L, M, N, neut, P, F, po),
		   B,
		   U/przec(V, na),
		   C,
		   W/zdanie(D, X, Y, Z, A1, B1, C1, E, i(r, H), G, po)
		 ],
		 D1),
	zdanie(R,
	       S,
	       D1,
	       sp:r:H,
	       I,
	       J,
	       K,
	       L,
	       M,
	       N,
	       O,
	       P,
	       Q,
	       E1).

zdanie(Q1, B, S1, F1, H1, I1, J1, K1, L1, M1, A, O1, C1, po) :-
	tylko_neut_pyt(A),
	do_sequence_of(T1,
		       
		       [ C,
			 T/spójnik(szk, D, ni, na),
			 S,
			 B1/zdanie(J, U, V, W, X, Y, Z, A1, ni, I, po)
		       ],
		       B,
		       C,
		       [[spójnik(sz, D, ni, po), zdanie(G, _, _, _, _, _, _, F, ni, E, po), przec(H, po)]/ (trzy_na_listę(K, [ (0| 0), E, (p| wp)], O), obldest_iter(L, F, P), jeden_na_listę(M, G, Q), conajmniej1(N, _, R))/[D, H]/[D1, A, G1, 0]/[[ (0| 0), I], E1, [J], 1]/ ([]/[K, L, M, N])/ ([]/[O, P, Q, R])]/[]/[]),
	goal(spójnik(szk, D, ni, na), C, S, T),
	różne(D, [przec, czy]),
	goal(zdanie(J,
		    U,
		    V,
		    W,
		    X,
		    Y,
		    Z,
		    A1,
		    ni,
		    I,
		    po),
	     S,
	     R1,
	     B1),
	oblpk(P1, [C1|D1]),
	obldest_iter(E1, A1, N1),
	sprawdź_wyróżniki_w_szeregu(D, [F1|G1]),
	register(zdanie(sp:sz:D,
			H1,
			I1,
			J1,
			K1,
			L1,
			M1,
			N1,
			O1,
			P1,
			V1),
		 Q1,
		 R1,
		 s2,
		 
		 [ S1/zdanie(F1, H1, I1, J1, K1, L1, M1, A, O1, C1, po)
		 | T1
		 ],
		 U1),
	zdanie(Q1,
	       R1,
	       U1,
	       sp:sz:D,
	       H1,
	       I1,
	       J1,
	       K1,
	       L1,
	       M1,
	       N1,
	       O1,
	       P1,
	       V1).

zdanie(O1, B, Q1, D1, F1, G1, H1, I1, J1, K1, A, M1, A1, po) :-
	tylko_neut_pyt(A),
	do_sequence_of(R1,
		       
		       [ C,
			 Q/spójnik(szk, O, ni, na),
			 P,
			 Z/zdanie(H, S, T, U, V, W, X, Y, ni, G, po)
		       ],
		       B,
		       C,
		       [[spójnik(sz, przec, ni, po), zdanie(F, _, _, _, _, _, _, E, ni, D, po)]/ (dwa_na_listę(I, [ (p| wp), D], L), obldest_iter(J, E, M), jeden_na_listę(K, F, N))/[]/[B1, A, E1]/[[R, G], C1, [H]]/ ([]/[I, J, K])/ ([]/[L, M, N])]/[]/[]),
	goal(spójnik(szk, O, ni, na), C, P, Q),
	O\=czy,
	(   O=przec
	->  R= (p| wp)
	;   R= (db| 0)
	),
	goal(zdanie(H,
		    S,
		    T,
		    U,
		    V,
		    W,
		    X,
		    Y,
		    ni,
		    G,
		    po),
	     P,
	     P1,
	     Z),
	oblpk(N1, [A1|B1]),
	obldest_iter(C1, Y, L1),
	sprawdź_wyróżniki_w_szeregu(O, [D1|E1]),
	różne(sp:sz:przec, [D1|E1]),
	(   O\=przec
	;   H\=sp:sz:_
	;   H=sp:sz:i
	),
	register(zdanie(sp:sz:O,
			F1,
			G1,
			H1,
			I1,
			J1,
			K1,
			L1,
			M1,
			N1,
			T1),
		 O1,
		 P1,
		 s3,
		 
		 [ Q1/zdanie(D1, F1, G1, H1, I1, J1, K1, A, M1, A1, po)
		 | R1
		 ],
		 S1),
	zdanie(O1,
	       P1,
	       S1,
	       sp:sz:O,
	       F1,
	       G1,
	       H1,
	       I1,
	       J1,
	       K1,
	       L1,
	       M1,
	       N1,
	       T1).

zdanie(T, B, V, J, K, L, M, N, O, P, A, R, G, na) :-
	tylko_neut_pyt(A),
	goal(przec(H, po), B, C, W),
	goal(spójnik(pc, Y, ni, po), C, D, X),
	goal(zdanie(E,
		    A1,
		    B1,
		    C1,
		    D1,
		    E1,
		    F1,
		    F,
		    ni,
		    I,
		    po),
	     D,
	     U,
	     Z),
	E\=bc(_),
	obldest(Q, [A, F]),
	oblpk(S, [G, H, I]),
	register(zdanie(J,
			K,
			L,
			M,
			N,
			O,
			P,
			Q,
			R,
			S,
			H1),
		 T,
		 U,
		 p1,
		 
		 [ V/zdanie(J, K, L, M, N, O, P, A, R, G, na),
		   B,
		   W/przec(H, po),
		   C,
		   X/spójnik(pc, Y, ni, po),
		   D,
		   Z/zdanie(E, A1, B1, C1, D1, E1, F1, F, ni, I, po)
		 ],
		 G1),
	zdanie(T,
	       U,
	       G1,
	       J,
	       K,
	       L,
	       M,
	       N,
	       O,
	       P,
	       Q,
	       R,
	       S,
	       H1).

zdanie(Q, B, S, A, H, I, J, K, L, M, neut, O, F, na) :-
	A\=bc(_),
	goal(przec(U, po), B, C, T),
	goal(zdanie(D,
		    W,
		    X,
		    Y,
		    Z,
		    A1,
		    B1,
		    E,
		    i(p, C1),
		    G,
		    po),
	     C,
	     R,
	     V),
	D\=bc(_),
	obldest(N, [neut, E]),
	oblpk(P, [F, (p| wp), G]),
	register(zdanie(A,
			H,
			I,
			J,
			K,
			L,
			M,
			N,
			O,
			P,
			E1),
		 Q,
		 R,
		 p4,
		 
		 [ S/zdanie(A, H, I, J, K, L, M, neut, O, F, na),
		   B,
		   T/przec(U, po),
		   C,
		   V/zdanie(D, W, X, Y, Z, A1, B1, E, i(p, C1), G, po)
		 ],
		 D1),
	zdanie(Q,
	       R,
	       D1,
	       A,
	       H,
	       I,
	       J,
	       K,
	       L,
	       M,
	       N,
	       O,
	       P,
	       E1).

zdanie(I, B, K, A, L, M, N, O, P, Q, D, R, G, na) :-
	A\=bc(_),
	optional(S,
		 [C, F/pauza(po)],
		 B,
		 C,
		 znakkonca(E, po),
		 { zgodnyznakk(D, E)
		 },
		 {}),
	goal(pauza(po), C, J, F),
	oblpk(H, [ (wpw| wp), G, (p| wp)]),
	register(fw(or,
		    U,
		    V,
		    W,
		    X,
		    pre,
		    Y,
		    neut,
		    ni,
		    H,
		    Z),
		 I,
		 J,
		 wyor2,
		 
		 [ K/zdanie(A, L, M, N, O, P, Q, D, R, G, na)
		 | S
		 ],
		 T),
	fw(I,
	   J,
	   T,
	   or,
	   U,
	   V,
	   W,
	   X,
	   pre,
	   Y,
	   neut,
	   ni,
	   H,
	   Z).

zdanie(L, A, N, C, F, G, H, O, P, I, D, J, E, na) :-
	optional(Q,
		 [],
		 A,
		 M,
		 przec(B, po),
		 {},
		 { B= (p| bp)
		 }),
	C\=bc(_),
	równe(D, [wz(_, _), pz]),
	oblpk(K, [ (bp| p), E, B]),
	register(fzd(D,
		     nk,
		     F,
		     G,
		     H,
		     I,
		     J,
		     K,
		     S),
		 L,
		 M,
		 zd2,
		 
		 [ N/zdanie(C, F, G, H, O, P, I, D, J, E, na)
		 | Q
		 ],
		 R),
	fzd(L,
	    M,
	    R,
	    D,
	    nk,
	    F,
	    G,
	    H,
	    I,
	    J,
	    K,
	    S).

pauza(W, A, Y, po) :-
	optional(Z,
		 
		 [ B,
		   N/zdanie(D, E, F, G, H, I, J, K, L, M, na)
		 | O
		 ],
		 A,
		 B,
		 cudz(o, po),
		 { C=t
		 },
		 { C=f
		 }),
	goal(zdanie(D,
		    E,
		    F,
		    G,
		    H,
		    I,
		    J,
		    K,
		    L,
		    M,
		    na),
	     B,
	     P,
	     N),
	optional(O,
		 [Q, T/znakkonca(S, po)|U],
		 P,
		 Q,
		 cudz(z, po),
		 { C=t,
		   R=t
		 },
		 { R=f
		 }),
	goal(znakkonca(S, po), Q, V, T),
	optional(U, [], V, X, cudz(z, po), {R=f}, {}),
	zgodnyznakk(K, S),
	oblpk(_, [ (p| pw), M, (kw| p)]),
	register(wypowiedzenie,
		 W,
		 X,
		 w2,
		 [Y/pauza(po)|Z],
		 A1),
	wypowiedzenie(W, X, A1).

pauza(A1, A, C1, po) :-
	optional(D1,
		 
		 [ B,
		   G/spójnik(D, E, ni, na),
		   F,
		   R/zdanie(H, I, J, K, L, M, N, O, P, Q, po)
		 | S
		 ],
		 A,
		 B,
		 cudz(o, po),
		 { C=t
		 },
		 { C=f
		 }),
	goal(spójnik(D, E, ni, na), B, F, G),
	spójnik_obrzynotwórczy(D, E),
	goal(zdanie(H,
		    I,
		    J,
		    K,
		    L,
		    M,
		    N,
		    O,
		    P,
		    Q,
		    po),
	     F,
	     T,
	     R),
	optional(S,
		 [U, X/znakkonca(W, po)|Y],
		 T,
		 U,
		 cudz(z, po),
		 { C=t,
		   V=t
		 },
		 { V=f
		 }),
	goal(znakkonca(W, po), U, Z, X),
	optional(Y,
		 [],
		 Z,
		 B1,
		 cudz(z, po),
		 { C=t,
		   V=f
		 },
		 { (   C=f
		   ;   V=t
		   )
		 }),
	zgodnyznakk(O, W),
	oblpk(_, [ (p| pw), Q, (kw| p)]),
	register(wypowiedzenie,
		 A1,
		 B1,
		 w6,
		 [C1/pauza(po)|D1],
		 E1),
	wypowiedzenie(A1, B1, E1).

cudz(K, A, M, o, po) :-
	goal(zdanie(O,
		    P,
		    Q,
		    R,
		    S,
		    T,
		    U,
		    I,
		    V,
		    J,
		    na),
	     A,
	     B,
	     N),
	optional(W,
		 [C, F/znakkonca(E, po)|G],
		 B,
		 C,
		 cudz(z, po),
		 { D=t
		 },
		 { D=f
		 }),
	goal(znakkonca(E, po), C, H, F),
	optional(G, [], H, L, cudz(z, po), {D=f}, {}),
	zgodnyznakk(I, E),
	oblpk(_, [ (p| pw), J, (kw| p)]),
	register(wypowiedzenie,
		 K,
		 L,
		 w3,
		 
		 [ M/cudz(o, po),
		   A,
		   N/zdanie(O, P, Q, R, S, T, U, I, V, J, na)
		 | W
		 ],
		 X),
	wypowiedzenie(K, L, X).

cudz(N, A, P, o, po) :-
	goal(zdanie(R,
		    S,
		    T,
		    U,
		    V,
		    W,
		    X,
		    D,
		    Y,
		    L,
		    na),
	     A,
	     B,
	     Q),
	optional(Z,
		 [C, F/cudz(z, po)|G],
		 B,
		 C,
		 znakkonca(E, po),
		 { zgodnyznakk(D, E)
		 },
		 {}),
	goal(cudz(z, po), C, H, F),
	optional(G,
		 [],
		 H,
		 O,
		 pauza(po),
		 { I=pre,
		   J=wpw,
		   K=wp
		 },
		 { (   I=pre,
		       J=wpw,
		       K=0
		   ;   I=post,
		       J=0,
		       K=wkw
		   )
		 }),
	oblpk(M, [ (J| wp), L, (p| K)]),
	register(fw(or,
		    B1,
		    C1,
		    D1,
		    E1,
		    I,
		    F1,
		    neut,
		    ni,
		    M,
		    G1),
		 N,
		 O,
		 wyor1,
		 
		 [ P/cudz(o, po),
		   A,
		   Q/zdanie(R, S, T, U, V, W, X, D, Y, L, na)
		 | Z
		 ],
		 A1),
	fw(N,
	   O,
	   A1,
	   or,
	   B1,
	   C1,
	   D1,
	   E1,
	   I,
	   F1,
	   neut,
	   ni,
	   M,
	   G1).

cudz(O, A, Q, o, po) :-
	goal(fwe(D,
		 E,
		 F,
		 G,
		 H,
		 I,
		 B,
		 K,
		 L,
		 M,
		 N,
		 na),
	     A,
	     C,
	     R),
	wymagania_oznacz_czyste(B, J),
	goal(cudz(z, po), C, P, S),
	register(fwe(D,
		     E,
		     F,
		     G,
		     H,
		     I,
		     J,
		     K,
		     L,
		     M,
		     N,
		     U),
		 O,
		 P,
		 wec1,
		 
		 [ Q/cudz(o, po),
		   A,
		   R/fwe(D, E, F, G, H, I, B, K, L, M, N, na),
		   C,
		   S/cudz(z, po)
		 ],
		 T),
	fwe(O,
	    P,
	    T,
	    D,
	    E,
	    F,
	    G,
	    H,
	    I,
	    J,
	    K,
	    L,
	    M,
	    N,
	    U).

cudz(P, A, R, o, po) :-
	goal(fno(D,
		 E/F,
		 G,
		 B,
		 I,
		 J,
		 K,
		 L,
		 M,
		 N,
		 O,
		 na),
	     A,
	     C,
	     S),
	wymagania_odemknij(B, H),
	goal(cudz(z, po), C, Q, T),
	register(fno(D,
		     E/F,
		     G,
		     H,
		     I,
		     J,
		     K,
		     L,
		     M,
		     N,
		     O,
		     V),
		 P,
		 Q,
		 noc1,
		 
		 [ R/cudz(o, po),
		   A,
		   S/fno(D, E/F, G, B, I, J, K, L, M, N, O, na),
		   C,
		   T/cudz(z, po)
		 ],
		 U),
	fno(P,
	    Q,
	    U,
	    D,
	    E/F,
	    G,
	    H,
	    I,
	    J,
	    K,
	    L,
	    M,
	    N,
	    O,
	    V).

cudz(K, A, M, o, po) :-
	goal(fpm(C,
		 D,
		 E,
		 F,
		 G,
		 H,
		 I,
		 J,
		 na),
	     A,
	     B,
	     N),
	goal(cudz(z, po), B, L, O),
	register(fpm(C,
		     D,
		     E,
		     F,
		     G,
		     H,
		     I,
		     J,
		     Q),
		 K,
		 L,
		 pmc1,
		 
		 [ M/cudz(o, po),
		   A,
		   N/fpm(C, D, E, F, G, H, I, J, na),
		   B,
		   O/cudz(z, po)
		 ],
		 P),
	fpm(K,
	    L,
	    P,
	    C,
	    D,
	    E,
	    F,
	    G,
	    H,
	    I,
	    J,
	    Q).

cudz(K, A, M, o, po) :-
	goal(fpmpt(C,
		   D,
		   E,
		   F,
		   G,
		   H,
		   I,
		   J,
		   na),
	     A,
	     B,
	     N),
	goal(cudz(z, po), B, L, O),
	register(fpmpt(C,
		       D,
		       E,
		       F,
		       G,
		       H,
		       I,
		       J,
		       Q),
		 K,
		 L,
		 pmc2,
		 
		 [ M/cudz(o, po),
		   A,
		   N/fpmpt(C, D, E, F, G, H, I, J, na),
		   B,
		   O/cudz(z, po)
		 ],
		 P),
	fpmpt(K,
	      L,
	      P,
	      C,
	      D,
	      E,
	      F,
	      G,
	      H,
	      I,
	      J,
	      Q).

cudz(O, A, Q, o, po) :-
	goal(fpt(D,
		 E/F,
		 G,
		 B,
		 I,
		 J,
		 K,
		 L,
		 M,
		 N,
		 na),
	     A,
	     C,
	     R),
	wymagania_odemknij(B, H),
	goal(cudz(z, po), C, P, S),
	register(fpt(D,
		     E/F,
		     G,
		     H,
		     I,
		     J,
		     K,
		     L,
		     M,
		     N,
		     U),
		 O,
		 P,
		 ptc1,
		 
		 [ Q/cudz(o, po),
		   A,
		   R/fpt(D, E/F, G, B, I, J, K, L, M, N, na),
		   C,
		   S/cudz(z, po)
		 ],
		 T),
	fpt(O,
	    P,
	    T,
	    D,
	    E/F,
	    G,
	    H,
	    I,
	    J,
	    K,
	    L,
	    M,
	    N,
	    U).

cudz(I, A, K, o, po) :-
	goal(fps(C, D, E, F, G, H, na),
	     A,
	     B,
	     L),
	goal(cudz(z, po), B, J, M),
	register(fps(C, D, E, F, G, H, O),
		 I,
		 J,
		 psc2,
		 
		 [ K/cudz(o, po),
		   A,
		   L/fps(C, D, E, F, G, H, na),
		   B,
		   M/cudz(z, po)
		 ],
		 N),
	fps(I,
	    J,
	    N,
	    C,
	    D,
	    E,
	    F,
	    G,
	    H,
	    O).

nawias(L, A, N, o, D, po) :-
	goal(zdanie(P,
		    Q,
		    R,
		    S,
		    T,
		    U,
		    V,
		    J,
		    W,
		    K,
		    na),
	     A,
	     B,
	     O),
	optional(X,
		 [C, G/znakkonca(F, po)|H],
		 B,
		 C,
		 nawias(z, D, po),
		 { E=t
		 },
		 { E=f
		 }),
	goal(znakkonca(F, po), C, I, G),
	optional(H,
		 [],
		 I,
		 M,
		 nawias(z, D, po),
		 { E=f
		 },
		 {}),
	zgodnyznakk(J, F),
	oblpk(_, [ (p| pw), K, (kw| p)]),
	register(wypowiedzenie,
		 L,
		 M,
		 w4,
		 
		 [ N/nawias(o, D, po),
		   A,
		   O/zdanie(P, Q, R, S, T, U, V, J, W, K, na)
		 | X
		 ],
		 Y),
	wypowiedzenie(L, M, Y).

nawias(F, A, H, o, B, po) :-
	goal(zdanie(J,
		    K,
		    L,
		    M,
		    N,
		    O,
		    P,
		    D,
		    Q,
		    E,
		    na),
	     A,
	     C,
	     I),
	goal(nawias(z, B, po), C, G, R),
	zgodnyznakk(D, neut),
	oblpk(_, [ (p| pw), E, (kw| p)]),
	register(wypowiedzenie,
		 F,
		 G,
		 w8,
		 
		 [ H/nawias(o, B, po),
		   A,
		   I/zdanie(J, K, L, M, N, O, P, D, Q, E, na),
		   C,
		   R/nawias(z, B, po)
		 ],
		 S),
	wypowiedzenie(F, G, S).

nawias(F, A, H, o, D, po) :-
	goal(terminal(morf('.', J, interp)), A, B, I),
	goal(terminal(morf('.', L, interp)), B, C, K),
	goal(terminal(morf('.', N, interp)), C, E, M),
	goal(nawias(z, D, po), E, G, O),
	register(fl(Q,
		    R,
		    S,
		    T,
		    U,
		    V,
		    W,
		    (0| 0),
		    X),
		 F,
		 G,
		 lu30,
		 
		 [ H/nawias(o, D, po),
		   A,
		   I/terminal(morf('.', J, interp)),
		   B,
		   K/terminal(morf('.', L, interp)),
		   C,
		   M/terminal(morf('.', N, interp)),
		   E,
		   O/nawias(z, D, po)
		 ],
		 P),
	fl(F,
	   G,
	   P,
	   Q,
	   R,
	   S,
	   T,
	   U,
	   V,
	   W,
	   (0| 0),
	   X).

nawias(D, A, F, o, B, po) :-
	goal(terminal(morf('…', H, interp)), A, C, G),
	goal(nawias(z, B, po), C, E, I),
	register(fl(K,
		    L,
		    M,
		    N,
		    O,
		    P,
		    Q,
		    (0| 0),
		    R),
		 D,
		 E,
		 lu31,
		 
		 [ F/nawias(o, B, po),
		   A,
		   G/terminal(morf('…', H, interp)),
		   C,
		   I/nawias(z, B, po)
		 ],
		 J),
	fl(D,
	   E,
	   J,
	   K,
	   L,
	   M,
	   N,
	   O,
	   P,
	   Q,
	   (0| 0),
	   R).

spójnik(H, C, J, A, B, ni, na) :-
	spójnik_obrzynotwórczy(A, B),
	goal(zdanie(L,
		    M,
		    N,
		    O,
		    P,
		    Q,
		    R,
		    E,
		    S,
		    G,
		    po),
	     C,
	     D,
	     K),
	goal(znakkonca(F, po), D, I, T),
	zgodnyznakk(E, F),
	oblpk(_, [ (p| pw), G, (kw| p)]),
	register(wypowiedzenie,
		 H,
		 I,
		 w5,
		 
		 [ J/spójnik(A, B, ni, na),
		   C,
		   K/zdanie(L, M, N, O, P, Q, R, E, S, G, po),
		   D,
		   T/znakkonca(F, po)
		 ],
		 U),
	wypowiedzenie(H, I, U).

spójnik(V, A, X, rl, E, T, na) :-
	goal(zdanie(C,
		    M,
		    N,
		    O,
		    P,
		    Q,
		    R,
		    B,
		    ni,
		    J,
		    po),
	     A,
	     D,
	     Y),
	tylko_neut_pyt(B),
	C\=bc(_),
	goal(przec(K, po), D, F, Z),
	goal(spójnik(rp, E, ni, po), F, G, A1),
	goal(zdanie(H,
		    C1,
		    D1,
		    E1,
		    F1,
		    G1,
		    H1,
		    I,
		    ni,
		    L,
		    po),
	     G,
	     W,
	     B1),
	H\=bc(_),
	obldest(S, [B, I]),
	oblpk(U, [J, K, L]),
	register(zdanie(sp:r:E,
			M,
			N,
			O,
			P,
			Q,
			R,
			S,
			T,
			U,
			J1),
		 V,
		 W,
		 r3,
		 
		 [ X/spójnik(rl, E, T, na),
		   A,
		   Y/zdanie(C, M, N, O, P, Q, R, B, ni, J, po),
		   D,
		   Z/przec(K, po),
		   F,
		   A1/spójnik(rp, E, ni, po),
		   G,
		   B1/zdanie(H, C1, D1, E1, F1, G1, H1, I, ni, L, po)
		 ],
		 I1),
	zdanie(V,
	       W,
	       I1,
	       sp:r:E,
	       M,
	       N,
	       O,
	       P,
	       Q,
	       R,
	       S,
	       T,
	       U,
	       J1).

spójnik(S1, B, U1, sz, A, ni, na) :-
	\+ member(A, [przec, lub]),
	goal(zdanie(H1,
		    J1,
		    K1,
		    L1,
		    M1,
		    N1,
		    O1,
		    C,
		    Q1,
		    E1,
		    po),
	     B,
	     D,
	     V1),
	tylko_neut_pyt(C),
	do_sequence_of(W1,
		       
		       [ E,
			 T/przec(J, po),
			 S,
			 V/spójnik(szk, A, ni, po),
			 U,
			 D1/zdanie(L, W, X, Y, Z, A1, B1, C1, ni, K, po)
		       ],
		       D,
		       E,
		       [[przec(F, po), spójnik(sz, A, ni, po), zdanie(I, _, _, _, _, _, _, H, ni, G, po)]/ (trzy_na_listę(M, [F, (0| 0), G], P), obldest_iter(N, H, Q), jeden_na_listę(O, I, R))/[A]/[F1, C, I1]/[[J, (0| 0), K], G1, [L]]/ ([]/[M, N, O])/ ([]/[P, Q, R])]/[]/[]),
	goal(przec(J, po), E, S, T),
	goal(spójnik(szk, A, ni, po), S, U, V),
	A\=czy,
	goal(zdanie(L,
		    W,
		    X,
		    Y,
		    Z,
		    A1,
		    B1,
		    C1,
		    ni,
		    K,
		    po),
	     U,
	     T1,
	     D1),
	oblpk(R1, [ (0| 0), E1|F1]),
	obldest_iter(G1, C1, P1),
	sprawdź_wyróżniki_w_szeregu(A, [H1|I1]),
	register(zdanie(sp:sz:A,
			J1,
			K1,
			L1,
			M1,
			N1,
			O1,
			P1,
			Q1,
			R1,
			Y1),
		 S1,
		 T1,
		 s1,
		 
		 [ U1/spójnik(sz, A, ni, na),
		   B,
		   V1/zdanie(H1, J1, K1, L1, M1, N1, O1, C, Q1, E1, po)
		 | W1
		 ],
		 X1),
	zdanie(S1,
	       T1,
	       X1,
	       sp:sz:A,
	       J1,
	       K1,
	       L1,
	       M1,
	       N1,
	       O1,
	       P1,
	       Q1,
	       R1,
	       Y1).

spójnik(P, A, R, pl, D, ni, po) :-
	goal(zdanie(C,
		    H,
		    I,
		    J,
		    K,
		    L,
		    M,
		    B,
		    ni,
		    F,
		    na),
	     A,
	     E,
	     S),
	tylko_neut_pyt(B),
	C\=bc(_),
	goal(fzd(D,
		 nk,
		 U,
		 V,
		 W,
		 X,
		 N,
		 G,
		 po),
	     E,
	     Q,
	     T),
	oblpk(O, [ (0| 0), F, G]),
	register(zdanie(C,
			H,
			I,
			J,
			K,
			L,
			M,
			B,
			N,
			O,
			Z),
		 P,
		 Q,
		 p3,
		 
		 [ R/spójnik(pl, D, ni, po),
		   A,
		   S/zdanie(C, H, I, J, K, L, M, B, ni, F, na),
		   E,
		   T/fzd(D, nk, U, V, W, X, N, G, po)
		 ],
		 Y),
	zdanie(P,
	       Q,
	       Y,
	       C,
	       H,
	       I,
	       J,
	       K,
	       L,
	       M,
	       B,
	       N,
	       O,
	       Z).

spójnik(I1, B, K1, sz, A, ni, na) :-
	\+ member(A, [przec, lub]),
	goal(fw(C,
		E,
		F,
		G,
		H,
		I,
		J,
		K,
		L,
		D1,
		po),
	     B,
	     M,
	     L1),
	dopuszczalna_koordynacja(D),
	member(C, D),
	do_sequence_of(M1,
		       
		       [ N,
			 Y/przec(R, po),
			 X,
			 A1/spójnik(szk, A, ni, na),
			 Z,
			 C1/fw(B1, E, F, G, H, I, J, K, L, S, po)
		       ],
		       M,
		       N,
		       [[przec(O, po), spójnik(sz, A, ni, na), fw(Q, E, F, G, H, I, J, K, L, P, po)]/ (trzy_na_listę(T, [O, (0| 0), P], V), dopuszczalna_koord_iter(U, Q, W))/[A, E, F, G, H, I, J, K, L]/[E1, [C]/D]/[[R, (0| 0), S], F1]/ ([]/[T, U])/ ([]/[V, W])]/[]/[]),
	goal(przec(R, po), N, X, Y),
	goal(spójnik(szk, A, ni, na), X, Z, A1),
	sprawdz_neg(A, J),
	goal(fw(B1,
		E,
		F,
		G,
		H,
		I,
		J,
		K,
		L,
		S,
		po),
	     Z,
	     J1,
	     C1),
	oblpk(H1, [ (0| wp), D1|E1]),
	dopuszczalna_koord_iter(F1, B1, G1/_),
	register(fw(G1,
		    E,
		    F,
		    G,
		    H,
		    I,
		    J,
		    K,
		    L,
		    H1,
		    O1),
		 I1,
		 J1,
		 wys1,
		 
		 [ K1/spójnik(sz, A, ni, na),
		   B,
		   L1/fw(C, E, F, G, H, I, J, K, L, D1, po)
		 | M1
		 ],
		 N1),
	fw(I1,
	   J1,
	   N1,
	   G1,
	   E,
	   F,
	   G,
	   H,
	   I,
	   J,
	   K,
	   L,
	   H1,
	   O1).

spójnik(G1, A, I1, rl, D, E1, na) :-
	goal(fwe(F,
		 W,
		 X,
		 G,
		 M/O,
		 Q,
		 U,
		 S,
		 B,
		 ni,
		 J,
		 po),
	     A,
	     C,
	     J1),
	tylko_neut_pyt(B),
	goal(przec(K, po), C, E, K1),
	goal(spójnik(rp, D, ni, po), E, H, L1),
	goal(fwe(F,
		 N1,
		 O1,
		 G,
		 N/P,
		 R,
		 V,
		 T,
		 I,
		 ni,
		 L,
		 po),
	     H,
	     H1,
	     M1),
	obldest(D1, [B, I]),
	oblpk(F1, [J, K, L]),
	zgodne_iter(M, N, Y),
	zgodne_iter(O, P, Z),
	zgodne_iter(Q, R, A1),
	neg_do_sąsiada(S, T, C1),
	oblwym_koord(B1, r3:D, [U, V]),
	register(fwe(F,
		     W,
		     X,
		     G,
		     Y/Z,
		     A1,
		     B1,
		     C1,
		     D1,
		     E1,
		     F1,
		     Q1),
		 G1,
		 H1,
		 wer3,
		 
		 [ I1/spójnik(rl, D, E1, na),
		   A,
		   J1/fwe(F, W, X, G, M/O, Q, U, S, B, ni, J, po),
		   C,
		   K1/przec(K, po),
		   E,
		   L1/spójnik(rp, D, ni, po),
		   H,
		   M1/fwe(F, N1, O1, G, N/P, R, V, T, I, ni, L, po)
		 ],
		 P1),
	fwe(G1,
	    H1,
	    P1,
	    F,
	    W,
	    X,
	    G,
	    Y/Z,
	    A1,
	    B1,
	    C1,
	    D1,
	    E1,
	    F1,
	    Q1).

spójnik(P2, B, R2, sz, A, ni, na) :-
	\+ member(A, [przec, lub]),
	goal(fwe(D,
		 F2,
		 G2,
		 E,
		 P/Q,
		 R,
		 D2,
		 S,
		 C,
		 N2,
		 W1,
		 po),
	     B,
	     F,
	     S2),
	tylko_neut_pyt(C),
	do_sequence_of(T2,
		       
		       [ G,
			 L1/przec(T, po),
			 K1,
			 N1/spójnik(szk, A, ni, po),
			 M1,
			 V1/fwe(D, O1, P1, E, Q1/R1, S1, V, T1, U1, ni, U, po)
		       ],
		       F,
		       G,
		       [[przec(H, po), spójnik(sz, A, ni, po), fwe(D, _, _, E, L/M, N, K, O, J, ni, I, po)]/ (trzy_na_listę(W, [H, (0| 0), I], D1), obldest_iter(X, J, E1), jeden_na_listę(Y, K, F1), zgodne_iter(Z, L, G1), zgodne_iter(A1, M, H1), zgodne_iter(B1, N, I1), neg_do_sąsiada(C1, O, J1))/[A, D, E]/[X1, C, E2, P, Q, R, S]/[[T, (0| 0), U], Y1, [V], Z1, A2, B2, C2]/ ([]/[W, X, Y, Z, A1, B1, C1])/ ([]/[D1, E1, F1, G1, H1, I1, J1])]/[]/[]),
	goal(przec(T, po), G, K1, L1),
	goal(spójnik(szk, A, ni, po), K1, M1, N1),
	A\=czy,
	goal(fwe(D,
		 O1,
		 P1,
		 E,
		 Q1/R1,
		 S1,
		 V,
		 T1,
		 U1,
		 ni,
		 U,
		 po),
	     M1,
	     Q2,
	     V1),
	oblpk(O2, [ (0| 0), W1|X1]),
	obldest_iter(Y1, U1, M2),
	zgodne_iter(Z1, Q1, H2),
	zgodne_iter(A2, R1, I2),
	zgodne_iter(B2, S1, J2),
	neg_do_sąsiada(C2, T1, L2),
	oblwym_koord(K2, sz1:A, [D2|E2]),
	register(fwe(D,
		     F2,
		     G2,
		     E,
		     H2/I2,
		     J2,
		     K2,
		     L2,
		     M2,
		     N2,
		     O2,
		     V2),
		 P2,
		 Q2,
		 wes1,
		 
		 [ R2/spójnik(sz, A, ni, na),
		   B,
		   S2/fwe(D, F2, G2, E, P/Q, R, D2, S, C, N2, W1, po)
		 | T2
		 ],
		 U2),
	fwe(P2,
	    Q2,
	    U2,
	    D,
	    F2,
	    G2,
	    E,
	    H2/I2,
	    J2,
	    K2,
	    L2,
	    M2,
	    N2,
	    O2,
	    V2).

spójnik(G1, A, I1, rl, D, E1, na) :-
	goal(fno(F,
		 N/O,
		 P,
		 wym([], K1, L1),
		 Q,
		 G,
		 R,
		 H,
		 B,
		 ni,
		 K,
		 po),
	     A,
	     C,
	     J1),
	tylko_neut_pyt(B),
	goal(przec(L, po), C, E, M1),
	goal(spójnik(rp, D, ni, po), E, I, N1),
	goal(fno(F,
		 S/T,
		 U,
		 wym([], P1, Q1),
		 V,
		 G,
		 W,
		 H,
		 J,
		 ni,
		 M,
		 po),
	     I,
	     H1,
	     O1),
	obldest_fno_iter(B, J, D1),
	oblpk(F1, [K, L, M]),
	oblparam_fno_koor(D,
			  X/Y/Z/B1/C1/A1,
			  N/O/P/Q/R,
			  S/T/U/V/W,
			  []),
	register(fno(F,
		     X/Y,
		     Z,
		     A1,
		     B1,
		     G,
		     C1,
		     H,
		     D1,
		     E1,
		     F1,
		     S1),
		 G1,
		 H1,
		 nor2,
		 
		 [ I1/spójnik(rl, D, E1, na),
		   A,
		   J1/fno(F, N/O, P, wym([], K1, L1), Q, G, R, H, B, ni, K, po),
		   C,
		   M1/przec(L, po),
		   E,
		   N1/spójnik(rp, D, ni, po),
		   I,
		   O1/fno(F, S/T, U, wym([], P1, Q1), V, G, W, H, J, ni, M, po)
		 ],
		 R1),
	fno(G1,
	    H1,
	    R1,
	    F,
	    X/Y,
	    Z,
	    A1,
	    B1,
	    G,
	    C1,
	    H,
	    D1,
	    E1,
	    F1,
	    S1).

spójnik(B2, B, D2, sz, A, ni, na) :-
	\+ member(A, [przec, lub]),
	goal(fno(D,
		 M1/N1,
		 O1,
		 wym([], F2, G2),
		 P1,
		 E,
		 Q1,
		 F,
		 C,
		 Z1,
		 J1,
		 po),
	     B,
	     G,
	     E2),
	tylko_neut_pyt(C),
	do_sequence_of(H2,
		       
		       [ H,
			 X/przec(O, po),
			 W,
			 Z/spójnik(szk, A, ni, na),
			 Y,
			 I1/fno(D, A1/B1, C1, wym([], D1, E1), F1, E, G1, F, H1, ni, P, po)
		       ],
		       G,
		       H,
		       [[przec(I, po), spójnik(sz, A, ni, na), fno(D, L/_, M, wym([], _, _), N, E, pre, F, K, ni, J, po)]/ (trzy_na_listę(Q, [I, (0| 0), J], T), obldest_fno_iter(R, K, U), zroblistę_iter(S, L/M/N, V))/[A, D, E, F]/[K1, C, []]/[[O, (0| 0), P], L1, R1]/ ([]/[Q, R, S])/ ([]/[T, U, V])]/[]/[]),
	goal(przec(O, po), H, W, X),
	goal(spójnik(szk, A, ni, na), W, Y, Z),
	sprawdz_neg(A, F),
	goal(fno(D,
		 A1/B1,
		 C1,
		 wym([], D1, E1),
		 F1,
		 E,
		 G1,
		 F,
		 H1,
		 ni,
		 P,
		 po),
	     Y,
	     C2,
	     I1),
	oblpk(A2, [J1|K1]),
	obldest_fno_iter(L1, H1, Y1),
	oblparam_fno_koor(A,
			  S1/T1/U1/W1/X1/V1,
			  M1/N1/O1/P1/Q1,
			  A1/B1/C1/F1/G1,
			  R1),
	register(fno(D,
		     S1/T1,
		     U1,
		     V1,
		     W1,
		     E,
		     X1,
		     F,
		     Y1,
		     Z1,
		     A2,
		     J2),
		 B2,
		 C2,
		 nos1,
		 
		 [ D2/spójnik(sz, A, ni, na),
		   B,
		   E2/fno(D, M1/N1, O1, wym([], F2, G2), P1, E, Q1, F, C, Z1, J1, po)
		 | H2
		 ],
		 I2),
	fno(B2,
	    C2,
	    I2,
	    D,
	    S1/T1,
	    U1,
	    V1,
	    W1,
	    E,
	    X1,
	    F,
	    Y1,
	    Z1,
	    A2,
	    J2).

spójnik(V, B, X, rl, E, A, na) :-
	goal(fpm(N,
		 O,
		 Z,
		 G,
		 H,
		 C,
		 A,
		 K,
		 po),
	     B,
	     D,
	     Y),
	tylko_neut_pyt(C),
	goal(przec(L, po), D, F, A1),
	goal(spójnik(rp, E, ni, po), F, I, B1),
	goal(fpm(P,
		 Q,
		 D1,
		 G,
		 H,
		 J,
		 ni,
		 M,
		 po),
	     I,
	     W,
	     C1),
	obldest_fno_iter(C, J, T),
	oblpk(U, [K, L, M]),
	obl_pmp([N/O, P/Q], R, S),
	register(fpm(R,
		     S,
		     r,
		     G,
		     H,
		     T,
		     A,
		     U,
		     F1),
		 V,
		 W,
		 pmr2,
		 
		 [ X/spójnik(rl, E, A, na),
		   B,
		   Y/fpm(N, O, Z, G, H, C, A, K, po),
		   D,
		   A1/przec(L, po),
		   F,
		   B1/spójnik(rp, E, ni, po),
		   I,
		   C1/fpm(P, Q, D1, G, H, J, ni, M, po)
		 ],
		 E1),
	fpm(V,
	    W,
	    E1,
	    R,
	    S,
	    r,
	    G,
	    H,
	    T,
	    A,
	    U,
	    F1).

spójnik(Q1, B, S1, sz, A, ni, po) :-
	\+ member(A, [przec, lub]),
	goal(fpm(O,
		 P,
		 D,
		 E,
		 F,
		 C,
		 O1,
		 H1,
		 po),
	     B,
	     G,
	     T1),
	tylko_neut_pyt(C),
	sprawdz_kl_nie_sz(D),
	do_sequence_of(U1,
		       
		       [ H,
			 Z/przec(Q, po),
			 Y,
			 B1/spójnik(szk, A, ni, na),
			 A1,
			 G1/fpm(C1, D1, E1, E, F, F1, ni, R, po)
		       ],
		       G,
		       H,
		       [[przec(J, po), spójnik(sz, A, ni, po), fpm(M, N, I, E, F, L, ni, K, po)]/ (sprawdz_kl_nie_sz(I), trzy_na_listę(S, [J, (0| 0), K], V), obldest_fno_iter(T, L, W), zroblistę_iter(U, M/N, X))/[A, E, F]/[I1, C, [O/P]]/[[Q, (0| 0), R], J1, K1]/ ([]/[S, T, U])/ ([]/[V, W, X])]/[]/[]),
	goal(przec(Q, po), H, Y, Z),
	goal(spójnik(szk, A, ni, na), Y, A1, B1),
	sprawdz_neg(A, F),
	goal(fpm(C1,
		 D1,
		 E1,
		 E,
		 F,
		 F1,
		 ni,
		 R,
		 po),
	     A1,
	     R1,
	     G1),
	sprawdz_kl_nie_sz(E1),
	oblpk(P1, [H1|I1]),
	obldest_fno_iter(J1, F1, N1),
	obl_pmp([C1/D1|K1], L1, M1),
	register(fpm(L1,
		     M1,
		     sz,
		     E,
		     F,
		     N1,
		     O1,
		     P1,
		     W1),
		 Q1,
		 R1,
		 pms1,
		 
		 [ S1/spójnik(sz, A, ni, po),
		   B,
		   T1/fpm(O, P, D, E, F, C, O1, H1, po)
		 | U1
		 ],
		 V1),
	fpm(Q1,
	    R1,
	    V1,
	    L1,
	    M1,
	    sz,
	    E,
	    F,
	    N1,
	    O1,
	    P1,
	    W1).

spójnik(T, B, V, rl, E, A, na) :-
	goal(fpt(G,
		 H/I,
		 Q,
		 wym([], X, Y),
		 Z,
		 J,
		 K,
		 C,
		 A,
		 N,
		 po),
	     B,
	     D,
	     W),
	tylko_neut_pyt(C),
	goal(przec(O, po), D, F, A1),
	goal(spójnik(rp, E, ni, po), F, L, B1),
	goal(fpt(G,
		 H/I,
		 D1,
		 wym([], E1, F1),
		 G1,
		 J,
		 K,
		 M,
		 ni,
		 P,
		 po),
	     L,
	     U,
	     C1),
	obldest_fno_iter(C, M, R),
	oblpk(S, [N, O, P]),
	register(fpt(G,
		     H/I,
		     Q,
		     wym([], I1, [[]]),
		     J1,
		     J,
		     K,
		     R,
		     A,
		     S,
		     K1),
		 T,
		 U,
		 ptr2,
		 
		 [ V/spójnik(rl, E, A, na),
		   B,
		   W/fpt(G, H/I, Q, wym([], X, Y), Z, J, K, C, A, N, po),
		   D,
		   A1/przec(O, po),
		   F,
		   B1/spójnik(rp, E, ni, po),
		   L,
		   C1/fpt(G, H/I, D1, wym([], E1, F1), G1, J, K, M, ni, P, po)
		 ],
		 H1),
	fpt(T,
	    U,
	    H1,
	    G,
	    H/I,
	    Q,
	    wym([], I1, [[]]),
	    J1,
	    J,
	    K,
	    R,
	    A,
	    S,
	    K1).

spójnik(M, A, O, po, E, K, na) :-
	goal(zdanie(D,
		    G,
		    H,
		    I,
		    Q,
		    R,
		    J,
		    neut,
		    ni,
		    F,
		    po),
	     A,
	     B,
	     P),
	optional(S,
		 [],
		 B,
		 N,
		 przec(C, po),
		 {},
		 { C= (p| bp)
		 }),
	D\=bc(_),
	member(E,
	       [aż, chociaż, czy, dopóki, gdy, jak, jeśli, podczas, ponieważ, zanim, że]),
	oblpk(L, [ (bp| p), F, C]),
	(   D=bok
	*-> member(E, [gdy, jeśli])
	;   true
	),
	register(fzd(E,
		     nk,
		     G,
		     H,
		     I,
		     J,
		     K,
		     L,
		     U),
		 M,
		 N,
		 zds1o,
		 
		 [ O/spójnik(po, E, K, na),
		   A,
		   P/zdanie(D, G, H, I, Q, R, J, neut, ni, F, po)
		 | S
		 ],
		 T),
	fzd(M,
	    N,
	    T,
	    E,
	    nk,
	    G,
	    H,
	    I,
	    J,
	    K,
	    L,
	    U).

spójnik(O, A, Q, po, G, M, na) :-
	goal(zdanie(B,
		    I,
		    J,
		    K,
		    S,
		    C,
		    L,
		    D,
		    ni,
		    H,
		    po),
	     A,
	     E,
	     R),
	(   B=os
	*-> member(C/D, [3/neut, _/agl])
	;   B\=bc(_)
	),
	optional(T,
		 [],
		 E,
		 P,
		 przec(F, po),
		 {},
		 { F= (p| bp)
		 }),
	member(G, [choćby, gdyby, jakby, jakoby, żeby]),
	oblpk(N, [ (bp| p), H, F]),
	register(fzd(G,
		     nk,
		     I,
		     J,
		     K,
		     L,
		     M,
		     N,
		     V),
		 O,
		 P,
		 zds2o,
		 
		 [ Q/spójnik(po, G, M, na),
		   A,
		   R/zdanie(B, I, J, K, S, C, L, D, ni, H, po)
		 | T
		 ],
		 U),
	fzd(O,
	    P,
	    U,
	    G,
	    nk,
	    I,
	    J,
	    K,
	    L,
	    M,
	    N,
	    V).

spójnik(O, B, Q, rl, E, A, na) :-
	goal(fzd(C,
		 G,
		 J,
		 K,
		 L,
		 M,
		 A,
		 S,
		 po),
	     B,
	     D,
	     R),
	C\=wz(_, _),
	goal(przec(U, po), D, F, T),
	goal(spójnik(rp, E, ni, po), F, H, V),
	goal(fzd(C,
		 G,
		 X,
		 Y,
		 Z,
		 A1,
		 ni,
		 I,
		 po),
	     H,
	     P,
	     W),
	oblpk(N, [_, (p| wp), I]),
	register(fzd(C,
		     G,
		     J,
		     K,
		     L,
		     M,
		     A,
		     N,
		     C1),
		 O,
		 P,
		 zdr2,
		 
		 [ Q/spójnik(rl, E, A, na),
		   B,
		   R/fzd(C, G, J, K, L, M, A, S, po),
		   D,
		   T/przec(U, po),
		   F,
		   V/spójnik(rp, E, ni, po),
		   H,
		   W/fzd(C, G, X, Y, Z, A1, ni, I, po)
		 ],
		 B1),
	fzd(O,
	    P,
	    B1,
	    C,
	    G,
	    J,
	    K,
	    L,
	    M,
	    A,
	    N,
	    C1).

spójnik(H1, B, J1, sz, A, ni, po) :-
	\+ member(A, [przec, lub]),
	goal(fzd(C,
		 D,
		 C1,
		 D1,
		 E1,
		 J,
		 F1,
		 A1,
		 po),
	     B,
	     E,
	     K1),
	C\=wz(_, _),
	do_sequence_of(L1,
		       
		       [ F,
			 R/przec(K, po),
			 Q,
			 T/spójnik(szk, A, ni, na),
			 S,
			 Z/fzd(C, D, W, X, Y, U, ni, L, po)
		       ],
		       E,
		       F,
		       [[przec(G, po), spójnik(sz, A, ni, po), fzd(C, D, _, _, _, I, ni, H, po)]/ (trzy_na_listę(M, [G, (0| wp), H], O), zroblistę_iter(N, I, P))/[A, C, D]/[B1, [J]]/[[K, (0| wp), L], V]/ ([]/[M, N])/ ([]/[O, P])]/[]/[]),
	goal(przec(K, po), F, Q, R),
	goal(spójnik(szk, A, ni, na), Q, S, T),
	sprawdz_neg_fzd(A, [U|V]),
	goal(fzd(C,
		 D,
		 W,
		 X,
		 Y,
		 U,
		 ni,
		 L,
		 po),
	     S,
	     I1,
	     Z),
	oblpk(G1, [ (0| wp), A1|B1]),
	register(fzd(C,
		     D,
		     C1,
		     D1,
		     E1,
		     J,
		     F1,
		     G1,
		     N1),
		 H1,
		 I1,
		 zdsz1,
		 
		 [ J1/spójnik(sz, A, ni, po),
		   B,
		   K1/fzd(C, D, C1, D1, E1, J, F1, A1, po)
		 | L1
		 ],
		 M1),
	fzd(H1,
	    I1,
	    M1,
	    C,
	    D,
	    C1,
	    D1,
	    E1,
	    J,
	    F1,
	    G1,
	    N1).

spójnik(F, A, H, B, C, ni, na) :-
	goal(spójnik(i(D, E), J, ni, po),
	     A,
	     G,
	     I),
	register(spójnik(B, C, i(D, E), L),
		 F,
		 G,
		 si,
		 
		 [ H/spójnik(B, C, ni, na),
		   A,
		   I/spójnik(i(D, E), J, ni, po)
		 ],
		 K),
	spójnik(F,
		G,
		K,
		B,
		C,
		i(D, E),
		L).

spójnik(H, A, J, rl, C, ni, na) :-
	goal(przyimek(L, E, po), A, B, K),
	goal(przec(N, po), B, D, M),
	goal(spójnik(rp, C, ni, po), D, F, O),
	goal(przyimek(G, E, po), F, I, P),
	register(przyimek(G, E, R),
		 H,
		 I,
		 pimr2,
		 
		 [ J/spójnik(rl, C, ni, na),
		   A,
		   K/przyimek(L, E, po),
		   B,
		   M/przec(N, po),
		   D,
		   O/spójnik(rp, C, ni, po),
		   F,
		   P/przyimek(G, E, po)
		 ],
		 Q),
	przyimek(H, I, Q, G, E, R).

fno(E, B, G, mian, H/I, J, A, K, L, M, N, neut, ni, O, po) :-
	wymagania_zamknij(A),
	goal(terminal(morf(C, Q, interp)), B, D, P),
	member(C, [:, -, '–', '—']),
	goal(wypowiedzenie, D, F, R),
	register(wypowiedzenie,
		 E,
		 F,
		 w7,
		 
		 [ G/fno(mian, H/I, J, A, K, L, M, N, neut, ni, O, po),
		   B,
		   P/terminal(morf(C, Q, interp)),
		   D,
		   R/wypowiedzenie
		 ],
		 S),
	wypowiedzenie(E, F, S).

fno(H, I, J, mian, A, B, wym([], K, L), M, N, C, D, E, F, G, na) :-
	register(fw(subj(np(mian)),
		    P,
		    Q,
		    A,
		    B,
		    C,
		    D,
		    E,
		    F,
		    G,
		    R),
		 H,
		 I,
		 wy3,
		 
		 [ J/fno(mian, A, B, wym([], K, L), M, N, C, D, E, F, G, na)
		 ],
		 O),
	fw(H,
	   I,
	   O,
	   subj(np(mian)),
	   P,
	   Q,
	   A,
	   B,
	   C,
	   D,
	   E,
	   F,
	   G,
	   R).

fno(E, F, G, dop, H, I, wym([], J, K), L, M, pre, nie(A), B, C, D, na) :-
	register(fw(np(bier),
		    O,
		    P,
		    Q,
		    R,
		    S,
		    nie(A),
		    B,
		    C,
		    D,
		    T),
		 E,
		 F,
		 wy4,
		 
		 [ G/fno(dop, H, I, wym([], J, K), L, M, pre, nie(A), B, C, D, na)
		 ],
		 N),
	fw(E,
	   F,
	   N,
	   np(bier),
	   O,
	   P,
	   Q,
	   R,
	   S,
	   nie(A),
	   B,
	   C,
	   D,
	   T).

fno(D, E, F, bier, G, H, wym([], I, J), K, L, pre, tak, A, B, C, na) :-
	register(fw(np(bier),
		    N,
		    O,
		    P,
		    Q,
		    R,
		    tak,
		    A,
		    B,
		    C,
		    S),
		 D,
		 E,
		 wy5,
		 
		 [ F/fno(bier, G, H, wym([], I, J), K, L, pre, tak, A, B, C, na)
		 ],
		 M),
	fw(D,
	   E,
	   M,
	   np(bier),
	   N,
	   O,
	   P,
	   Q,
	   R,
	   tak,
	   A,
	   B,
	   C,
	   S).

fno(E, F, G, dop, H, I, wym([], J, K), L, M, pre, A, B, C, D, na) :-
	register(fw(np(part),
		    O,
		    P,
		    Q,
		    R,
		    S,
		    A,
		    B,
		    C,
		    D,
		    T),
		 E,
		 F,
		 wy4p,
		 
		 [ G/fno(dop, H, I, wym([], J, K), L, M, pre, A, B, C, D, na)
		 ],
		 N),
	fw(E,
	   F,
	   N,
	   np(part),
	   O,
	   P,
	   Q,
	   R,
	   S,
	   A,
	   B,
	   C,
	   D,
	   T).

fno(D, E, F, bier, G, H, wym([], I, J), K, L, pre, tak, A, B, C, na) :-
	register(fw(np(part),
		    N,
		    O,
		    P,
		    Q,
		    R,
		    tak,
		    A,
		    B,
		    C,
		    S),
		 D,
		 E,
		 wy5p,
		 
		 [ F/fno(bier, G, H, wym([], I, J), K, L, pre, tak, A, B, C, na)
		 ],
		 M),
	fw(D,
	   E,
	   M,
	   np(part),
	   N,
	   O,
	   P,
	   Q,
	   R,
	   tak,
	   A,
	   B,
	   C,
	   S).

fno(F, G, H, A, I, J, wym([], K, L), M, N, pre, B, C, D, E, na) :-
	różne(A, [bier, miej]),
	register(fw(np(A),
		    P,
		    Q,
		    R,
		    S,
		    T,
		    B,
		    C,
		    D,
		    E,
		    U),
		 F,
		 G,
		 wy6,
		 
		 [ H/fno(A, I, J, wym([], K, L), M, N, pre, B, C, D, E, na)
		 ],
		 O),
	fw(F,
	   G,
	   O,
	   np(A),
	   P,
	   Q,
	   R,
	   S,
	   T,
	   B,
	   C,
	   D,
	   E,
	   U).

fno(J, C, L, A, M, N, wym([], O, P), B, Q, pre, G, H, I, D, na) :-
	równe(A, [cel, bier, narz]),
	B\=przym,
	optional(R,
		 [],
		 C,
		 K,
		 przec(E, po),
		 { oblpk(F, [ (bp| p), D, E])
		 },
		 { F=D
		 }),
	register(fl(T,
		    U,
		    V,
		    W,
		    G,
		    H,
		    I,
		    F,
		    X),
		 J,
		 K,
		 lu2,
		 
		 [ L/fno(A, M, N, wym([], O, P), B, Q, pre, G, H, I, D, na)
		 | R
		 ],
		 S),
	fl(J,
	   K,
	   S,
	   T,
	   U,
	   V,
	   W,
	   G,
	   H,
	   I,
	   F,
	   X).

fno(I, C, K, A, G, L, wym([], M, N), B, O, pre, P, neut, ni, F, na) :-
	member(A, [wol, mian]),
	B\=przym,
	optional(Q,
		 [],
		 C,
		 J,
		 przec(D, po),
		 {},
		 { D= (p| bp)
		 }),
	(   A=wol
	*-> E=bp
	;   E=wpw
	),
	oblpk(H, [ (E| p), F, D]),
	register(fl(S,
		    T,
		    G,
		    2,
		    U,
		    neut,
		    ni,
		    H,
		    V),
		 I,
		 J,
		 lu12o,
		 
		 [ K/fno(A, G, L, wym([], M, N), B, O, pre, P, neut, ni, F, na)
		 | Q
		 ],
		 R),
	fl(I,
	   J,
	   R,
	   S,
	   T,
	   G,
	   2,
	   U,
	   neut,
	   ni,
	   H,
	   V).

fno(I, C, K, A, L, M, wym([], N, O), B, P, pre, Q, neut, ni, F, na) :-
	równe(G, [1, 3]),
	member(A, [wol, mian]),
	B\=przym,
	optional(R,
		 [],
		 C,
		 J,
		 przec(D, po),
		 {},
		 { D= (p| bp)
		 }),
	(   A=wol
	*-> E=bp
	;   E=wpw
	),
	oblpk(H, [ (E| p), F, D]),
	register(fl(T,
		    U,
		    V,
		    G,
		    W,
		    neut,
		    ni,
		    H,
		    X),
		 I,
		 J,
		 lu13o,
		 
		 [ K/fno(A, L, M, wym([], N, O), B, P, pre, Q, neut, ni, F, na)
		 | R
		 ],
		 S),
	fl(I,
	   J,
	   S,
	   T,
	   U,
	   V,
	   G,
	   W,
	   neut,
	   ni,
	   H,
	   X).

fno(Z1, D, B2, C, G/H, U1, A, B, O1, V1, I, P1, Q1, R1, na) :-
	A=wym(_, _, [_|_]),
	sprawdz_kl_noa(B, C, F),
	do_sequence_of(C2,
		       [],
		       D,
		       A2,
		       [[optional(przec(E, po), {}, {E= (bp| p)}), fpt(F, G/H, _, wym([], _, _), _, K, I, L, M, N, po), optional(przec(J, po), {}, {J= (p| bp)})]/ (oblzap_iter(P, K, U), obldest_iter(Q, L, V), oblink_iter(R, M, W), sprawdz_pk_iter(S, O, X), conajmniej1(T, Z, Y), sprawdz_fpt_noa(E/N/J/O))/[F, G, H, I]/[]/[]/ ([P, Q, R, S, T]/[])/ ([U, V, W, X, Y]/[]), fpm(_, _, _, K, I, L, M, O, po)/ (oblzap_iter(P, K, U), obldest_iter(Q, L, V), oblink_iter(R, M, W), sprawdz_pk_iter(S, O, X), conajmniej1(T, Z, Y))/[I]/[]/[]/ ([P, Q, R, S, T]/[])/ ([U, V, W, X, Y]/[]), fno(dop, _, 3, wym([], _, _), A1, K, pre, I, L, M, O, po)/ (oblzap_iter(P, K, U), obldest_iter(Q, L, V), oblink_iter(R, M, W), sprawdz_pk_iter(S, O, X), conajmniej1(T, Z, Y), sprawdz_kl_nod(B/A1))/[I]/[]/[]/ ([P, Q, R, S, T]/[])/ ([U, V, W, X, Y]/[]), fzd(B1, nk, C1, D1, E1, _, ni, O, po)/ (oblzap_iter(P, K, U), obldest_iter(Q, L, V), oblink_iter(R, M, W), sprawdz_pk_iter(S, O, X), conajmniej1(T, Z, Y), sprawdz_fzd_noz(F1, B1, G1))/[C1, D1, E1]/[G/H/B/S1]/[_]/ ([P, Q, R, S, T]/[F1])/ ([U, V, W, X, Y]/[G1]), fw(H1, I1, J1, K1, L1, post, I, L, ni, O, po)/ (oblzap_iter(P, K, U), obldest_iter(Q, L, V), oblink_iter(R, M, W), sprawdz_pk_iter(S, O, X), conajmniej1(T, Z, Y), oblwym_iter(M1, H1, N1))/[I1, J1, K1, L1, I]/[A]/[T1]/ ([P, Q, R, S, T]/[M1])/ ([U, V, W, X, Y]/[N1]), modpart(fno, I, L, ni, O, po)/ (oblzap_iter(P, K, U), obldest_iter(Q, L, V), oblink_iter(R, M, W), sprawdz_pk_iter(S, O, X), conajmniej1(T, Z, Y))/[I]/[]/[]/ ([P, Q, R, S, T]/[])/ ([U, V, W, X, Y]/[])]/[O1, P1, Q1, R1, 0]/[S1, W1, X1, Y1, 1]),
	wymagania_zamknij_nieuważnie(T1),
	register(fno(C,
		     G/H,
		     U1,
		     wym(E2, F2, bw),
		     B,
		     S1,
		     V1,
		     I,
		     W1,
		     X1,
		     Y1,
		     G2),
		 Z1,
		 A2,
		 noa1,
		 
		 [ B2/fno(C, G/H, U1, A, B, O1, V1, I, P1, Q1, R1, na)
		 | C2
		 ],
		 D2),
	fno(Z1,
	    A2,
	    D2,
	    C,
	    G/H,
	    U1,
	    wym(E2, F2, bw),
	    B,
	    S1,
	    V1,
	    I,
	    W1,
	    X1,
	    Y1,
	    G2).

fno(M3, B, O3, dop, P3, 3, wym([], Q3, R3), S3, D1, pre, A, E1, F1, G1, po) :-
	do_sequence_of(T3,
		       
		       [ C,
			 Q1/fno(H1, E/F, I1, J1, K1, L1, M1, A, N1, O1, P1, na)
		       | X1
		       ],
		       B,
		       C,
		       [[optional(przec(D, po), {}, {D= (bp| p)}), fpt(M, E/F, _, wym([], _, _), _, H, A, I, J, K, po), optional(przec(G, po), {}, {G= (p| bp)})]/ (oblzap_iter(N, H, R), obldest_iter(O, I, S), oblink_iter(P, J, T), sprawdz_pk_iter(Q, L, U), sprawdz_fpt_noa(D/K/G/L))/[M, E, F, A]/[]/[]/ ([N, O, P, Q]/[])/ ([R, S, T, U]/[]), fpm(_, _, _, H, A, I, J, L, po)/ (oblzap_iter(N, H, R), obldest_iter(O, I, S), oblink_iter(P, J, T), sprawdz_pk_iter(Q, L, U))/[A]/[]/[]/ ([N, O, P, Q]/[])/ ([R, S, T, U]/[]), fno(dop, _, 3, wym([], _, _), V, H, pre, A, I, J, L, po)/ (oblzap_iter(N, H, R), obldest_iter(O, I, S), oblink_iter(P, J, T), sprawdz_pk_iter(Q, L, U), sprawdz_kl_nod_prehead(R1/V))/[A]/[]/[]/ ([N, O, P, Q]/[])/ ([R, S, T, U]/[]), fw(W, X, Y, Z, A1, post, A, I, ni, L, po)/ (oblzap_iter(N, H, R), obldest_iter(O, I, S), oblink_iter(P, J, T), sprawdz_pk_iter(Q, L, U), zroblistę_iter(B1, W, C1))/[X, Y, Z, A1, A]/[[]]/[W1]/ ([N, O, P, Q]/[B1])/ ([R, S, T, U]/[C1]), modpart(fno, A, I, ni, L, po)/ (oblzap_iter(N, H, R), obldest_iter(O, I, S), oblink_iter(P, J, T), sprawdz_pk_iter(Q, L, U))/[A]/[]/[]/ ([N, O, P, Q]/[])/ ([R, S, T, U]/[])]/[D1, E1, F1, G1]/[S1, T1, U1, V1]),
	goal(fno(H1,
		 E/F,
		 I1,
		 J1,
		 K1,
		 L1,
		 M1,
		 A,
		 N1,
		 O1,
		 P1,
		 na),
	     C,
	     Y1,
	     Q1),
	J1=wym(_, _, [_|_]),
	sprawdz_kl_noa(K1, H1, M),
	sprawdz_kl_nod_head(R1, K1),
	oblzap_iter(S1, L1, D3),
	obldest_iter(T1, N1, E3),
	oblink_iter(U1, O1, F3),
	sprawdz_pk_iter(V1, P1, G3),
	wyjmijl(W1, J1, A3),
	do_sequence_of(X1,
		       [],
		       Y1,
		       N3,
		       [[optional(przec(Z1, po), {}, {Z1= (bp| p)}), fpt(M, E/F, _, wym([], _, _), _, B2, A, C2, D2, E2, po), optional(przec(A2, po), {}, {A2= (p| bp)})]/ (oblzap_iter(G2, B2, K2), obldest_iter(H2, C2, L2), oblink_iter(I2, D2, M2), sprawdz_pk_iter(J2, F2, N2), sprawdz_fpt_noa(Z1/E2/A2/F2))/[M, E, F, A]/[]/[]/ ([G2, H2, I2, J2]/[])/ ([K2, L2, M2, N2]/[]), fpm(_, _, _, B2, A, C2, D2, F2, po)/ (oblzap_iter(G2, B2, K2), obldest_iter(H2, C2, L2), oblink_iter(I2, D2, M2), sprawdz_pk_iter(J2, F2, N2))/[A]/[]/[]/ ([G2, H2, I2, J2]/[])/ ([K2, L2, M2, N2]/[]), fno(dop, _, 3, wym([], _, _), O2, B2, pre, A, C2, D2, F2, po)/ (oblzap_iter(G2, B2, K2), obldest_iter(H2, C2, L2), oblink_iter(I2, D2, M2), sprawdz_pk_iter(J2, F2, N2), sprawdz_kl_nod(K1/O2))/[A]/[]/[]/ ([G2, H2, I2, J2]/[])/ ([K2, L2, M2, N2]/[]), fzd(P2, nk, Q2, R2, S2, _, ni, F2, po)/ (oblzap_iter(G2, B2, K2), obldest_iter(H2, C2, L2), oblink_iter(I2, D2, M2), sprawdz_pk_iter(J2, F2, N2), sprawdz_fzd_noz(T2, P2, U2))/[Q2, R2, S2]/[E/F/K1/H3]/[_]/ ([G2, H2, I2, J2]/[T2])/ ([K2, L2, M2, N2]/[U2]), fw(V2, W2, X2, Y2, Z2, post, A, C2, ni, F2, po)/ (oblzap_iter(G2, B2, K2), obldest_iter(H2, C2, L2), oblink_iter(I2, D2, M2), sprawdz_pk_iter(J2, F2, N2), oblwym_iter(B3, V2, C3))/[W2, X2, Y2, Z2, A]/[A3]/[I3]/ ([G2, H2, I2, J2]/[B3])/ ([K2, L2, M2, N2]/[C3]), modpart(fno, A, C2, ni, F2, po)/ (oblzap_iter(G2, B2, K2), obldest_iter(H2, C2, L2), oblink_iter(I2, D2, M2), sprawdz_pk_iter(J2, F2, N2))/[A]/[]/[]/ ([G2, H2, I2, J2]/[])/ ([K2, L2, M2, N2]/[])]/[D3, E3, F3, G3]/[H3, J3, K3, L3]),
	wymagania_zamknij_nieuważnie(I3),
	register(fno(H1,
		     E/F,
		     I1,
		     wym(V3, W3, bw),
		     K1,
		     H3,
		     M1,
		     A,
		     J3,
		     K3,
		     L3,
		     X3),
		 M3,
		 N3,
		 nod2,
		 
		 [ O3/fno(dop, P3, 3, wym([], Q3, R3), S3, D1, pre, A, E1, F1, G1, po)
		 | T3
		 ],
		 U3),
	fno(M3,
	    N3,
	    U3,
	    H1,
	    E/F,
	    I1,
	    wym(V3, W3, bw),
	    K1,
	    H3,
	    M1,
	    A,
	    J3,
	    K3,
	    L3,
	    X3).

fno(Q, D, S, G, J, K, wym([], T, A), B, L, M, C, N, O, H, na) :-
	A\=[apo],
	B\=przym,
	goal(fno(E,
		 V,
		 3,
		 wym([], W, X),
		 F,
		 Y,
		 pre,
		 C,
		 neut,
		 ni,
		 I,
		 po),
	     D,
	     R,
	     U),
	E\=dop,
	F\=przym,
	(   E=G
	*-> true
	;   E=mian
	),
	oblpk(P, [H, I]),
	register(fno(G,
		     J,
		     K,
		     wym(A1, B1, [apo]),
		     B,
		     L,
		     M,
		     C,
		     N,
		     O,
		     P,
		     C1),
		 Q,
		 R,
		 noap,
		 
		 [ S/fno(G, J, K, wym([], T, A), B, L, M, C, N, O, H, na),
		   D,
		   U/fno(E, V, 3, wym([], W, X), F, Y, pre, C, neut, ni, I, po)
		 ],
		 Z),
	fno(Q,
	    R,
	    Z,
	    G,
	    J,
	    K,
	    wym(A1, B1, [apo]),
	    B,
	    L,
	    M,
	    C,
	    N,
	    O,
	    P,
	    C1).

fno(S, B, U, C, L, M, wym([], V, W), A, N, O, D, P, Q, I, na) :-
	A\=przym,
	goal(przec(J, po), B, E, X),
	goal(fno(C,
		 Z,
		 3,
		 wym([], A1, B1),
		 F,
		 C1,
		 pre,
		 D,
		 neut,
		 ni,
		 K,
		 po),
	     E,
	     G,
	     Y),
	F\=przym,
	optional(D1,
		 [],
		 G,
		 T,
		 przec(H, po),
		 {},
		 { H= (p| bp)
		 }),
	oblpk(R, [I, J, K, H]),
	register(fno(C,
		     L,
		     M,
		     wym(F1, G1, [apo]),
		     A,
		     N,
		     O,
		     D,
		     P,
		     Q,
		     R,
		     H1),
		 S,
		 T,
		 noapp,
		 
		 [ U/fno(C, L, M, wym([], V, W), A, N, O, D, P, Q, I, na),
		   B,
		   X/przec(J, po),
		   E,
		   Y/fno(C, Z, 3, wym([], A1, B1), F, C1, pre, D, neut, ni, K, po)
		 | D1
		 ],
		 E1),
	fno(S,
	    T,
	    E1,
	    C,
	    L,
	    M,
	    wym(F1, G1, [apo]),
	    A,
	    N,
	    O,
	    D,
	    P,
	    Q,
	    R,
	    H1).

fno(R, B, T, C, K, L, wym([], U, V), A, M, N, D, O, P, I, na) :-
	A\=przym,
	goal(nawias(o, G, po), B, E, W),
	goal(fno(C,
		 Y,
		 3,
		 wym([], Z, A1),
		 F,
		 B1,
		 pre,
		 D,
		 neut,
		 ni,
		 J,
		 po),
	     E,
	     H,
	     X),
	F\=przym,
	goal(nawias(z, G, po), H, S, C1),
	oblpk(Q, [I, (0| wp), J, (p| 0)]),
	register(fno(C,
		     K,
		     L,
		     wym(E1, F1, [apo]),
		     A,
		     M,
		     N,
		     D,
		     O,
		     P,
		     Q,
		     G1),
		 R,
		 S,
		 noapn,
		 
		 [ T/fno(C, K, L, wym([], U, V), A, M, N, D, O, P, I, na),
		   B,
		   W/nawias(o, G, po),
		   E,
		   X/fno(C, Y, 3, wym([], Z, A1), F, B1, pre, D, neut, ni, J, po),
		   H,
		   C1/nawias(z, G, po)
		 ],
		 D1),
	fno(R,
	    S,
	    D1,
	    C,
	    K,
	    L,
	    wym(E1, F1, [apo]),
	    A,
	    M,
	    N,
	    D,
	    O,
	    P,
	    Q,
	    G1).

fno(U, D, W, A, B/C, N, O, E, J, pre, Q, F, H, L, po) :-
	goal(flicz(A,
		   B/C,
		   uzg,
		   K,
		   G,
		   I,
		   M,
		   na),
	     D,
	     V,
	     X),
	różne(E, uzg.nuzg.egz),
	obldest(R, F, G),
	oblink(S, H, I),
	oblzap(P, [J, K]),
	oblpk(T, [L, M]),
	register(fno(A,
		     B/C,
		     N,
		     O,
		     uzg,
		     P,
		     Z,
		     Q,
		     R,
		     S,
		     T,
		     A1),
		 U,
		 V,
		 nol5,
		 
		 [ W/fno(A, B/C, N, O, E, J, pre, Q, F, H, L, po),
		   D,
		   X/flicz(A, B/C, uzg, K, G, I, M, na)
		 ],
		 Y),
	fno(U,
	    V,
	    Y,
	    A,
	    B/C,
	    N,
	    O,
	    uzg,
	    P,
	    Z,
	    Q,
	    R,
	    S,
	    T,
	    A1).

fno(U, C, W, dop, A/B, N, O, E, J, pre, Q, F, H, L, po) :-
	goal(flicz(D,
		   A/B,
		   nuzg,
		   K,
		   G,
		   I,
		   M,
		   na),
	     C,
	     V,
	     X),
	różne(D, mian),
	różne(E, uzg.nuzg.egz),
	obldest(R, F, G),
	oblink(S, H, I),
	oblzap(P, [J, K]),
	oblpk(T, [L, M]),
	register(fno(D,
		     A/B,
		     N,
		     O,
		     nuzg,
		     P,
		     Z,
		     Q,
		     R,
		     S,
		     T,
		     A1),
		 U,
		 V,
		 nol7,
		 
		 [ W/fno(dop, A/B, N, O, E, J, pre, Q, F, H, L, po),
		   C,
		   X/flicz(D, A/B, nuzg, K, G, I, M, na)
		 ],
		 Y),
	fno(U,
	    V,
	    Y,
	    D,
	    A/B,
	    N,
	    O,
	    nuzg,
	    P,
	    Z,
	    Q,
	    R,
	    S,
	    T,
	    A1).

fno(S, C, U, dop, A/B, V, M, D, I, pre, O, E, G, K, po) :-
	goal(flicz(mian,
		   A/B,
		   nuzg,
		   J,
		   F,
		   H,
		   L,
		   na),
	     C,
	     T,
	     W),
	różne(D, uzg.nuzg.egz),
	obldest(P, E, F),
	oblink(Q, G, H),
	oblzap(N, [I, J]),
	oblpk(R, [K, L]),
	register(fno(mian,
		     r(mn(n), nmo(np(n)))/poj,
		     3,
		     M,
		     nuzg,
		     N,
		     Y,
		     O,
		     P,
		     Q,
		     R,
		     Z),
		 S,
		 T,
		 nol9,
		 
		 [ U/fno(dop, A/B, V, M, D, I, pre, O, E, G, K, po),
		   C,
		   W/flicz(mian, A/B, nuzg, J, F, H, L, na)
		 ],
		 X),
	fno(S,
	    T,
	    X,
	    mian,
	    r(mn(n), nmo(np(n)))/poj,
	    3,
	    M,
	    nuzg,
	    N,
	    Y,
	    O,
	    P,
	    Q,
	    R,
	    Z).

fno(F1, A, H1, C, M/N, O, wym([], I1, J1), P, D, Q, E, G, D1, I, po) :-
	goal(przec(J, po), A, B, K1),
	goal(spójnik(rc, L, ni, na), B, F, L1),
	goal(fno(C,
		 R/S,
		 T,
		 wym([], N1, O1),
		 U,
		 D,
		 V,
		 E,
		 H,
		 ni,
		 K,
		 po),
	     F,
	     G1,
	     M1),
	obldest_fno_iter(G, H, C1),
	oblpk(E1, [I, J, K]),
	oblparam_fno_koor(L,
			  W/X/Y/A1/B1/Z,
			  M/N/O/P/Q,
			  R/S/T/U/V,
			  []),
	register(fno(C,
		     W/X,
		     Y,
		     Z,
		     A1,
		     D,
		     B1,
		     E,
		     C1,
		     D1,
		     E1,
		     Q1),
		 F1,
		 G1,
		 nor1,
		 
		 [ H1/fno(C, M/N, O, wym([], I1, J1), P, D, Q, E, G, D1, I, po),
		   A,
		   K1/przec(J, po),
		   B,
		   L1/spójnik(rc, L, ni, na),
		   F,
		   M1/fno(C, R/S, T, wym([], N1, O1), U, D, V, E, H, ni, K, po)
		 ],
		 P1),
	fno(F1,
	    G1,
	    P1,
	    C,
	    W/X,
	    Y,
	    Z,
	    A1,
	    D,
	    B1,
	    E,
	    C1,
	    D1,
	    E1,
	    Q1).

fno(X, B, Z, E, O/P, Q, R, S, F, T, G, A, V, K, na) :-
	tylko_neut_pyt(A),
	goal(przec(L, po), B, C, A1),
	goal(spójnik(rc, D, ni, po), C, H, B1),
	member(D, [czyli, więc, mianowicie, raczej]),
	goal(fno(E,
		 D1/E1,
		 F1,
		 wym([], G1, H1),
		 I1,
		 F,
		 J1,
		 G,
		 J,
		 ni,
		 M,
		 po),
	     H,
	     I,
	     C1),
	goal(przec(N, po), I, Y, K1),
	obldest_fno_iter(A, J, U),
	oblpk(W, [K, L, M, N]),
	register(fno(E,
		     O/P,
		     Q,
		     R,
		     S,
		     F,
		     T,
		     G,
		     U,
		     V,
		     W,
		     M1),
		 X,
		 Y,
		 nor3,
		 
		 [ Z/fno(E, O/P, Q, R, S, F, T, G, A, V, K, na),
		   B,
		   A1/przec(L, po),
		   C,
		   B1/spójnik(rc, D, ni, po),
		   H,
		   C1/fno(E, D1/E1, F1, wym([], G1, H1), I1, F, J1, G, J, ni, M, po),
		   I,
		   K1/przec(N, po)
		 ],
		 L1),
	fno(X,
	    Y,
	    L1,
	    E,
	    O/P,
	    Q,
	    R,
	    S,
	    F,
	    T,
	    G,
	    U,
	    V,
	    W,
	    M1).

fno(Z1, D, B2, A, K1/L1, M1, wym([], C2, D2), N1, B, O1, C, M, X1, H1, po) :-
	do_sequence_of(E2,
		       
		       [ E,
			 X/spójnik(szk, F, ni, na),
			 W,
			 G1/fno(A, Y/Z, A1, wym([], B1, C1), D1, B, E1, C, F1, ni, N, po)
		       ],
		       D,
		       E,
		       [[spójnik(sz, F, ni, na), fno(A, I/_, J, wym([], _, _), K, B, pre, C, H, ni, G, po), przec(L, po)]/ (trzy_na_listę(O, [ (0| 0), G, (p| wp)], S), obldest_fno_iter(P, H, T), zroblistę_iter(Q, I/J/K, U), conajmniej1(R, _, V))/[F, A, B, C, L]/[I1, M, [], 0]/[[ (0| 0), N], J1, P1, 1]/ ([]/[O, P, Q, R])/ ([]/[S, T, U, V])]/[]/[]),
	goal(spójnik(szk, F, ni, na), E, W, X),
	F\=przec,
	sprawdz_neg(F, C),
	goal(fno(A,
		 Y/Z,
		 A1,
		 wym([], B1, C1),
		 D1,
		 B,
		 E1,
		 C,
		 F1,
		 ni,
		 N,
		 po),
	     W,
	     A2,
	     G1),
	oblpk(Y1, [H1|I1]),
	obldest_fno_iter(J1, F1, W1),
	oblparam_fno_koor(F,
			  Q1/R1/S1/U1/V1/T1,
			  K1/L1/M1/N1/O1,
			  Y/Z/A1/D1/E1,
			  P1),
	register(fno(A,
		     Q1/R1,
		     S1,
		     T1,
		     U1,
		     B,
		     V1,
		     C,
		     W1,
		     X1,
		     Y1,
		     G2),
		 Z1,
		 A2,
		 nos2,
		 
		 [ B2/fno(A, K1/L1, M1, wym([], C2, D2), N1, B, O1, C, M, X1, H1, po)
		 | E2
		 ],
		 F2),
	fno(Z1,
	    A2,
	    F2,
	    A,
	    Q1/R1,
	    S1,
	    T1,
	    U1,
	    B,
	    V1,
	    C,
	    W1,
	    X1,
	    Y1,
	    G2).

fno(X1, D, Z1, A, I1/J1, K1, wym([], A2, B2), L1, B, M1, C, K, V1, F1, po) :-
	do_sequence_of(C2,
		       
		       [ E,
			 U/spójnik(szk, S, ni, na),
			 T,
			 E1/fno(A, W/X, Y, wym([], Z, A1), B1, B, C1, C, D1, ni, L, po)
		       ],
		       D,
		       E,
		       [[spójnik(sz, przec, ni, po), fno(A, H/_, I, wym([], _, _), J, B, pre, C, G, ni, F, po)]/ (dwa_na_listę(M, [ (p| wp), F], P), obldest_fno_iter(N, G, Q), zroblistę_iter(O, H/I/J, R))/[A, B, C]/[G1, K, []]/[[V, L], H1, N1]/ ([]/[M, N, O])/ ([]/[P, Q, R])]/[]/[]),
	goal(spójnik(szk, S, ni, na), E, T, U),
	(   S=przec
	->  V= (p| wp)
	;   V= (0| 0)
	),
	sprawdz_neg(S, C),
	goal(fno(A,
		 W/X,
		 Y,
		 wym([], Z, A1),
		 B1,
		 B,
		 C1,
		 C,
		 D1,
		 ni,
		 L,
		 po),
	     T,
	     Y1,
	     E1),
	oblpk(W1, [F1|G1]),
	obldest_fno_iter(H1, D1, U1),
	oblparam_fno_koor(S,
			  O1/P1/Q1/S1/T1/R1,
			  I1/J1/K1/L1/M1,
			  W/X/Y/B1/C1,
			  N1),
	register(fno(A,
		     O1/P1,
		     Q1,
		     R1,
		     S1,
		     B,
		     T1,
		     C,
		     U1,
		     V1,
		     W1,
		     E2),
		 X1,
		 Y1,
		 nos3,
		 
		 [ Z1/fno(A, I1/J1, K1, wym([], A2, B2), L1, B, M1, C, K, V1, F1, po)
		 | C2
		 ],
		 D2),
	fno(X1,
	    Y1,
	    D2,
	    A,
	    O1/P1,
	    Q1,
	    R1,
	    S1,
	    B,
	    T1,
	    C,
	    U1,
	    V1,
	    W1,
	    E2).

fno(K, B, M, A, N/O, P, wym([], Q, R), E, F, pre, G, H, I, D, po) :-
	goal(przyimek(C, A, na), B, L, S),
	równe(C, naprzeciwko.temu),
	oblpk(J, [D, (p| 0)]),
	register(fpm(C,
		     A,
		     E,
		     F,
		     G,
		     H,
		     I,
		     J,
		     U),
		 K,
		 L,
		 pm2,
		 
		 [ M/fno(A, N/O, P, wym([], Q, R), E, F, pre, G, H, I, D, po),
		   B,
		   S/przyimek(C, A, na)
		 ],
		 T),
	fpm(K,
	    L,
	    T,
	    C,
	    A,
	    E,
	    F,
	    G,
	    H,
	    I,
	    J,
	    U).

ff(S1, A, U1, F1, G1, H1, I1, B, J1, K, K1, B1, C1, D1, na) :-
	do_sequence_of(V1,
		       [],
		       A,
		       T1,
		       [fw(F, G, H, B, I, post, J, C, D, E, po)/ (obldest_iter(L, C, R), oblink_iter(M, D, S), sprawdz_pk_iter(N, E, T), conajmniej1(O, X, U), sprawdz_post_posiłk(P, Y, V), oblwym_iter(Q, F, W))/[G, H, B, I, J]/[K]/[L1]/ ([L, M, N, O, P]/[Q])/ ([R, S, T, U, V]/[W]), fl(G, H, B, I, J, C, D, E, po)/ (obldest_iter(L, C, R), oblink_iter(M, D, S), sprawdz_pk_iter(N, E, T), conajmniej1(O, X, U), sprawdz_post_posiłk(P, Y, V), najwyżej3(Z, _, A1))/[G, H, B, I, J]/[0]/[_]/ ([L, M, N, O, P]/[Z])/ ([R, S, T, U, V]/[A1]), posiłk(Y, B, C, D, E, po)/ (obldest_iter(L, C, R), oblink_iter(M, D, S), sprawdz_pk_iter(N, E, T), conajmniej1(O, X, U), sprawdz_post_posiłk(P, Y, V))/[B]/[]/[]/ ([L, M, N, O, P]/[])/ ([R, S, T, U, V]/[])]/[B1, C1, D1, 0, pierw(bezpo)]/[P1, Q1, R1, N1, E1]),
	oblposiłk(E1,
		  F1/G1/H1/I1/J1/K1,
		  M1/G/H/O1/I/J),
	wymagania_zamknij(L1),
	wyklucz_podmiot_bezokolicznika(M1, K),
	(   wymagania_skoordynowane(K)
	*-> N1=1
	;   true
	),
	register(zdanie(M1,
			G,
			H,
			O1,
			B,
			I,
			J,
			P1,
			Q1,
			R1,
			X1),
		 S1,
		 T1,
		 ze1,
		 
		 [ U1/ff(F1, G1, H1, I1, B, J1, K, K1, B1, C1, D1, na)
		 | V1
		 ],
		 W1),
	zdanie(S1,
	       T1,
	       W1,
	       M1,
	       G,
	       H,
	       O1,
	       B,
	       I,
	       J,
	       P1,
	       Q1,
	       R1,
	       X1).

fw(X2, B, Z2, L, D, E, A, F, pre, G, Z, A1, B1, po) :-
	do_sequence_of(A3,
		       
		       [ C,
			 M1/ff(C1, D1, E1, F1, A, G1, H1, I1, J1, K1, L1, na)
		       | R1
		       ],
		       B,
		       C,
		       [fw(K, D, E, A, F, pre, G, H, I, J, po)/ (obldest_iter(M, H, R), oblink_iter(N, I, S), sprawdz_pk_iter(O, J, T), sprawdz_posiłk(P, W, U), zroblistę_iter(Q, K, V))/[D, E, A, F, G]/[[L]]/[Q1]/ ([M, N, O, P]/[Q])/ ([R, S, T, U]/[V]), fl(D, E, A, F, G, H, I, J, po)/ (obldest_iter(M, H, R), oblink_iter(N, I, S), sprawdz_pk_iter(O, J, T), sprawdz_posiłk(P, W, U), najwyżej3(X, _, Y))/[D, E, A, F, G]/[0]/[J2]/ ([M, N, O, P]/[X])/ ([R, S, T, U]/[Y]), posiłk(W, A, H, I, J, po)/ (obldest_iter(M, H, R), oblink_iter(N, I, S), sprawdz_pk_iter(O, J, T), sprawdz_posiłk(P, W, U))/[A]/[]/[]/ ([M, N, O, P]/[])/ ([R, S, T, U]/[])]/[Z, A1, B1, bezpo]/[N1, O1, P1, P2]),
	goal(ff(C1,
		D1,
		E1,
		F1,
		A,
		G1,
		H1,
		I1,
		J1,
		K1,
		L1,
		na),
	     C,
	     S1,
	     M1),
	obldest_iter(N1, J1, M2),
	oblink_iter(O1, K1, N2),
	sprawdz_pk_iter(P1, L1, O2),
	wyjmijl(Q1, H1, X1),
	do_sequence_of(R1,
		       [],
		       S1,
		       Y2,
		       [fw(W1, D, E, A, F, post, G, T1, U1, V1, po)/ (obldest_iter(Y1, T1, D2), oblink_iter(Z1, U1, E2), sprawdz_pk_iter(A2, V1, F2), sprawdz_post_posiłk(B2, I2, G2), oblwym_iter(C2, W1, H2))/[D, E, A, F, G]/[X1]/[R2]/ ([Y1, Z1, A2, B2]/[C2])/ ([D2, E2, F2, G2]/[H2]), fl(D, E, A, F, G, T1, U1, V1, po)/ (obldest_iter(Y1, T1, D2), oblink_iter(Z1, U1, E2), sprawdz_pk_iter(A2, V1, F2), sprawdz_post_posiłk(B2, I2, G2), najwyżej3(K2, _, L2))/[D, E, A, F, G]/[J2]/[_]/ ([Y1, Z1, A2, B2]/[K2])/ ([D2, E2, F2, G2]/[L2]), posiłk(I2, A, T1, U1, V1, po)/ (obldest_iter(Y1, T1, D2), oblink_iter(Z1, U1, E2), sprawdz_pk_iter(A2, V1, F2), sprawdz_post_posiłk(B2, I2, G2))/[A]/[]/[]/ ([Y1, Z1, A2, B2]/[])/ ([D2, E2, F2, G2]/[])]/[M2, N2, O2, pierw(P2)]/[U2, V2, W2, Q2]),
	oblposiłk(Q2,
		  C1/D1/E1/F1/G1/I1,
		  S2/D/E/T2/F/G),
	wymagania_zamknij(R2),
	wyklucz_podmiot_bezokolicznika(S2, H1),
	register(zdanie(S2,
			D,
			E,
			T2,
			A,
			F,
			G,
			U2,
			V2,
			W2,
			C3),
		 X2,
		 Y2,
		 ze2,
		 
		 [ Z2/fw(L, D, E, A, F, pre, G, Z, A1, B1, po)
		 | A3
		 ],
		 B3),
	zdanie(X2,
	       Y2,
	       B3,
	       S2,
	       D,
	       E,
	       T2,
	       A,
	       F,
	       G,
	       U2,
	       V2,
	       W2,
	       C3).

fw(G1, C, I1, B, D, E, F, G, pre, H, Z, A1, B1, po) :-
	rekcja_zdanioidowa(A),
	oblwym_iter(A, B, M),
	do_sequence_of(J1,
		       [],
		       C,
		       H1,
		       [fw(L, D, E, F, G, post, H, I, J, K, po)/ (obldest_iter(N, I, S), oblink_iter(O, J, T), sprawdz_pk_iter(P, K, U), oblwym_iter(Q, L, V), najwyżej(R, _, W))/[D, E, F, G, H]/[M, 2]/[C1, _]/ ([N, O, P]/[Q, R])/ ([S, T, U]/[V, W]), fl(D, E, F, G, H, I, J, K, po)/ (obldest_iter(N, I, S), oblink_iter(O, J, T), sprawdz_pk_iter(P, K, U), najwyżej3(X, _, Y))/[D, E, F, G, H]/[0]/[_]/ ([N, O, P]/[X])/ ([S, T, U]/[Y])]/[Z, A1, B1]/[D1, E1, F1]),
	wymagania_zamknij(C1),
	register(zdanie(bc(A),
			D,
			E,
			L1,
			F,
			G,
			H,
			D1,
			E1,
			F1,
			M1),
		 G1,
		 H1,
		 bc1,
		 
		 [ I1/fw(B, D, E, F, G, pre, H, Z, A1, B1, po)
		 | J1
		 ],
		 K1),
	zdanie(G1,
	       H1,
	       K1,
	       bc(A),
	       D,
	       E,
	       L1,
	       F,
	       G,
	       H,
	       D1,
	       E1,
	       F1,
	       M1).

fw(E1, K, G1, A, C, D, E, F, G, H, I, J, Z, po) :-
	dopuszczalna_koordynacja(B),
	member(A, B),
	do_sequence_of(H1,
		       
		       [ L,
			 V/spójnik(szk, T, ni, na),
			 U,
			 Y/fw(X, C, D, E, F, G, H, I, J, O, po)
		       ],
		       K,
		       L,
		       [[spójnik(sz, przec, ni, po), fw(N, C, D, E, F, G, H, I, J, M, po)]/ (dwa_na_listę(P, [ (p| wp), M], R), dopuszczalna_koord_iter(Q, N, S))/[C, D, E, F, G, H, I, J]/[A1, [A]/B]/[[W, O], B1]/ ([]/[P, Q])/ ([]/[R, S])]/[]/[]),
	goal(spójnik(szk, T, ni, na), L, U, V),
	(   T=przec
	->  W= (p| wp)
	;   W= (db| wp)
	),
	sprawdz_neg(T, H),
	goal(fw(X,
		C,
		D,
		E,
		F,
		G,
		H,
		I,
		J,
		O,
		po),
	     U,
	     F1,
	     Y),
	oblpk(D1, [Z|A1]),
	dopuszczalna_koord_iter(B1, X, C1/_),
	register(fw(C1,
		    C,
		    D,
		    E,
		    F,
		    G,
		    H,
		    I,
		    J,
		    D1,
		    J1),
		 E1,
		 F1,
		 wys3,
		 
		 [ G1/fw(A, C, D, E, F, G, H, I, J, Z, po)
		 | H1
		 ],
		 I1),
	fw(E1,
	   F1,
	   I1,
	   C1,
	   C,
	   D,
	   E,
	   F,
	   G,
	   H,
	   I,
	   J,
	   D1,
	   J1).

fw(D2, E, F2, K, A, B, C, D, pre, G, T, B2, U, po) :-
	do_sequence_of(G2,
		       
		       [ F,
			 B1/fwe(V, A, B, W, C, D, X, Y, Z, ni, A1, na)
		       | G1
		       ],
		       E,
		       F,
		       [fw(J, A, B, C, D, pre, G, H, ni, I, po)/ (obldest_iter(L, H, O), sprawdz_pk_iter(M, I, P), zroblistę_iter(N, J, Q))/[A, B, C, D, G]/[[K]]/[F1]/ ([L, M]/[N])/ ([O, P]/[Q]), fl(A, B, C, D, G, H, ni, I, po)/ (obldest_iter(L, H, O), sprawdz_pk_iter(M, I, P), najwyżej3(R, _, S))/[A, B, C, D, G]/[0]/[S1]/ ([L, M]/[R])/ ([O, P]/[S])]/[T, U]/[D1, E1]),
	goal(fwe(V,
		 A,
		 B,
		 W,
		 C,
		 D,
		 X,
		 Y,
		 Z,
		 ni,
		 A1,
		 na),
	     F,
	     H1,
	     B1),
	wymagania_czyste(_, X),
	(   member(V, [bok, psu, psw])
	*-> wykluczpodmiot(X, C1)
	;   C1=X
	),
	obldest_iter(D1, Z, V1),
	sprawdz_pk_iter(E1, A1, W1),
	wyjmijl(F1, C1, L1),
	do_sequence_of(G1,
		       [],
		       H1,
		       E2,
		       [fw(K1, A, B, C, D, post, G, I1, ni, J1, po)/ (obldest_iter(M1, I1, P1), sprawdz_pk_iter(N1, J1, Q1), oblwym_iter(O1, K1, R1))/[A, B, C, D, G]/[L1]/[X1]/ ([M1, N1]/[O1])/ ([P1, Q1]/[R1]), fl(A, B, C, D, G, I1, ni, J1, po)/ (obldest_iter(M1, I1, P1), sprawdz_pk_iter(N1, J1, Q1), najwyżej3(T1, _, U1))/[A, B, C, D, G]/[S1]/[_]/ ([M1, N1]/[T1])/ ([P1, Q1]/[U1])]/[V1, W1]/[A2, C2]),
	wymagania_oznacz_użyte(X1, Y1),
	obl_neg_fwe(V, Z1, Y, G),
	register(fwe(V,
		     A,
		     B,
		     W,
		     C,
		     D,
		     Y1,
		     Z1,
		     A2,
		     B2,
		     C2,
		     I2),
		 D2,
		 E2,
		 wew2,
		 
		 [ F2/fw(K, A, B, C, D, pre, G, T, B2, U, po)
		 | G2
		 ],
		 H2),
	fwe(D2,
	    E2,
	    H2,
	    V,
	    A,
	    B,
	    W,
	    C,
	    D,
	    Y1,
	    Z1,
	    A2,
	    B2,
	    C2,
	    I2).

fw(M3, B, O3, B1, P3, Q3, R3, S3, pre, A, E1, F1, G1, po) :-
	do_sequence_of(T3,
		       
		       [ C,
			 Q1/fno(H1, E/F, I1, J1, K1, L1, M1, A, N1, O1, P1, na)
		       | X1
		       ],
		       B,
		       C,
		       [[optional(przec(D, po), {}, {D= (bp| p)}), fpt(M, E/F, _, wym([], _, _), _, H, A, I, J, K, po), optional(przec(G, po), {}, {G= (p| bp)})]/ (oblzap_iter(N, H, R), obldest_iter(O, I, S), oblink_iter(P, J, T), sprawdz_pk_iter(Q, L, U), sprawdz_fpt_noa(D/K/G/L))/[M, E, F, A]/[]/[]/ ([N, O, P, Q]/[])/ ([R, S, T, U]/[]), fpm(_, _, _, H, A, I, J, L, po)/ (oblzap_iter(N, H, R), obldest_iter(O, I, S), oblink_iter(P, J, T), sprawdz_pk_iter(Q, L, U))/[A]/[]/[]/ ([N, O, P, Q]/[])/ ([R, S, T, U]/[]), fno(dop, _, 3, wym([], _, _), V, H, pre, A, I, J, L, po)/ (oblzap_iter(N, H, R), obldest_iter(O, I, S), oblink_iter(P, J, T), sprawdz_pk_iter(Q, L, U), sprawdz_kl_nod_prehead(R1/V))/[A]/[]/[]/ ([N, O, P, Q]/[])/ ([R, S, T, U]/[]), fw(W, X, Y, Z, A1, post, A, I, ni, L, po)/ (oblzap_iter(N, H, R), obldest_iter(O, I, S), oblink_iter(P, J, T), sprawdz_pk_iter(Q, L, U), zroblistę_iter(C1, W, D1))/[X, Y, Z, A1, A]/[[B1]]/[W1]/ ([N, O, P, Q]/[C1])/ ([R, S, T, U]/[D1]), modpart(fno, A, I, ni, L, po)/ (oblzap_iter(N, H, R), obldest_iter(O, I, S), oblink_iter(P, J, T), sprawdz_pk_iter(Q, L, U))/[A]/[]/[]/ ([N, O, P, Q]/[])/ ([R, S, T, U]/[])]/[bzap, E1, F1, G1]/[S1, T1, U1, V1]),
	goal(fno(H1,
		 E/F,
		 I1,
		 J1,
		 K1,
		 L1,
		 M1,
		 A,
		 N1,
		 O1,
		 P1,
		 na),
	     C,
	     Y1,
	     Q1),
	J1=wym(_, _, [_|_]),
	sprawdz_kl_noa(K1, H1, M),
	sprawdz_kl_nod_head(R1, K1),
	oblzap_iter(S1, L1, D3),
	obldest_iter(T1, N1, E3),
	oblink_iter(U1, O1, F3),
	sprawdz_pk_iter(V1, P1, G3),
	wyjmijl(W1, J1, A3),
	do_sequence_of(X1,
		       [],
		       Y1,
		       N3,
		       [[optional(przec(Z1, po), {}, {Z1= (bp| p)}), fpt(M, E/F, _, wym([], _, _), _, B2, A, C2, D2, E2, po), optional(przec(A2, po), {}, {A2= (p| bp)})]/ (oblzap_iter(G2, B2, K2), obldest_iter(H2, C2, L2), oblink_iter(I2, D2, M2), sprawdz_pk_iter(J2, F2, N2), sprawdz_fpt_noa(Z1/E2/A2/F2))/[M, E, F, A]/[]/[]/ ([G2, H2, I2, J2]/[])/ ([K2, L2, M2, N2]/[]), fpm(_, _, _, B2, A, C2, D2, F2, po)/ (oblzap_iter(G2, B2, K2), obldest_iter(H2, C2, L2), oblink_iter(I2, D2, M2), sprawdz_pk_iter(J2, F2, N2))/[A]/[]/[]/ ([G2, H2, I2, J2]/[])/ ([K2, L2, M2, N2]/[]), fno(dop, _, 3, wym([], _, _), O2, B2, pre, A, C2, D2, F2, po)/ (oblzap_iter(G2, B2, K2), obldest_iter(H2, C2, L2), oblink_iter(I2, D2, M2), sprawdz_pk_iter(J2, F2, N2), sprawdz_kl_nod(K1/O2))/[A]/[]/[]/ ([G2, H2, I2, J2]/[])/ ([K2, L2, M2, N2]/[]), fzd(P2, nk, Q2, R2, S2, _, ni, F2, po)/ (oblzap_iter(G2, B2, K2), obldest_iter(H2, C2, L2), oblink_iter(I2, D2, M2), sprawdz_pk_iter(J2, F2, N2), sprawdz_fzd_noz(T2, P2, U2))/[Q2, R2, S2]/[E/F/K1/H3]/[_]/ ([G2, H2, I2, J2]/[T2])/ ([K2, L2, M2, N2]/[U2]), fw(V2, W2, X2, Y2, Z2, post, A, C2, ni, F2, po)/ (oblzap_iter(G2, B2, K2), obldest_iter(H2, C2, L2), oblink_iter(I2, D2, M2), sprawdz_pk_iter(J2, F2, N2), oblwym_iter(B3, V2, C3))/[W2, X2, Y2, Z2, A]/[A3]/[I3]/ ([G2, H2, I2, J2]/[B3])/ ([K2, L2, M2, N2]/[C3]), modpart(fno, A, C2, ni, F2, po)/ (oblzap_iter(G2, B2, K2), obldest_iter(H2, C2, L2), oblink_iter(I2, D2, M2), sprawdz_pk_iter(J2, F2, N2))/[A]/[]/[]/ ([G2, H2, I2, J2]/[])/ ([K2, L2, M2, N2]/[])]/[D3, E3, F3, G3]/[H3, J3, K3, L3]),
	wymagania_zamknij_nieuważnie(I3),
	register(fno(H1,
		     E/F,
		     I1,
		     wym(V3, W3, bw),
		     K1,
		     H3,
		     M1,
		     A,
		     J3,
		     K3,
		     L3,
		     X3),
		 M3,
		 N3,
		 now2,
		 
		 [ O3/fw(B1, P3, Q3, R3, S3, pre, A, E1, F1, G1, po)
		 | T3
		 ],
		 U3),
	fno(M3,
	    N3,
	    U3,
	    H1,
	    E/F,
	    I1,
	    wym(V3, W3, bw),
	    K1,
	    H3,
	    M1,
	    A,
	    J3,
	    K3,
	    L3,
	    X3).

fw(U2, A, W2, T, X2, Y2, Z2, A3, post, tak, Z, A1, B1, po) :-
	do_sequence_of(B3,
		       
		       [ B,
			 J1/fpt(X, Y, C1, D1, E1, F1, W, G1, H1, I1, na)
		       | P1
		       ],
		       A,
		       B,
		       [fps(_, _, _, C, D, E, po)/ (oblzap_iter(F, N, J), obldest_iter(G, C, K), oblink_iter(H, D, L), sprawdz_pk_iter(I, E, M))/[]/[]/[]/ ([F, G, H, I]/[])/ ([J, K, L, M]/[]), fpm(_, _, _, N, _, C, D, E, po)/ (oblzap_iter(F, N, J), obldest_iter(G, C, K), oblink_iter(H, D, L), sprawdz_pk_iter(I, E, M))/[]/[]/[]/ ([F, G, H, I]/[])/ ([J, K, L, M]/[]), fw(O, P, Q, R, S, post, tak, C, D, E, po)/ (oblzap_iter(F, N, J), obldest_iter(G, C, K), oblink_iter(H, D, L), sprawdz_pk_iter(I, E, M), zroblistę_iter(U, O, V))/[P, Q, R, S]/[[T]]/[O1]/ ([F, G, H, I]/[U])/ ([J, K, L, M]/[V]), modpart(fpt, W, C, D, E, po)/ (oblzap_iter(F, N, J), obldest_iter(G, C, K), oblink_iter(H, D, L), sprawdz_pk_iter(I, E, M))/[W]/[]/[]/ ([F, G, H, I]/[])/ ([J, K, L, M]/[]), modjaki(X, Y, N, C, D, E, po)/ (oblzap_iter(F, N, J), obldest_iter(G, C, K), oblink_iter(H, D, L), sprawdz_pk_iter(I, E, M))/[X, Y]/[]/[]/ ([F, G, H, I]/[])/ ([J, K, L, M]/[])]/[_, Z, A1, B1]/[K1, L1, M1, N1]),
	goal(fpt(X,
		 Y,
		 C1,
		 D1,
		 E1,
		 F1,
		 W,
		 G1,
		 H1,
		 I1,
		 na),
	     B,
	     Q1,
	     J1),
	D1=wym(_, _, [_|_]),
	oblzap_iter(K1, F1, L2),
	obldest_iter(L1, G1, M2),
	oblink_iter(M1, H1, N2),
	sprawdz_pk_iter(N1, I1, O2),
	wyjmijl(O1, D1, I2),
	do_sequence_of(P1,
		       [],
		       Q1,
		       V2,
		       [fps(_, _, _, R1, S1, T1, po)/ (oblzap_iter(U1, C2, Y1), obldest_iter(V1, R1, Z1), oblink_iter(W1, S1, A2), sprawdz_pk_iter(X1, T1, B2))/[]/[]/[]/ ([U1, V1, W1, X1]/[])/ ([Y1, Z1, A2, B2]/[]), fpm(_, _, _, C2, _, R1, S1, T1, po)/ (oblzap_iter(U1, C2, Y1), obldest_iter(V1, R1, Z1), oblink_iter(W1, S1, A2), sprawdz_pk_iter(X1, T1, B2))/[]/[]/[]/ ([U1, V1, W1, X1]/[])/ ([Y1, Z1, A2, B2]/[]), fw(D2, E2, F2, G2, H2, post, tak, R1, S1, T1, po)/ (oblzap_iter(U1, C2, Y1), obldest_iter(V1, R1, Z1), oblink_iter(W1, S1, A2), sprawdz_pk_iter(X1, T1, B2), oblwym_iter(J2, D2, K2))/[E2, F2, G2, H2]/[I2]/[P2]/ ([U1, V1, W1, X1]/[J2])/ ([Y1, Z1, A2, B2]/[K2]), modpart(fpt, W, R1, S1, T1, po)/ (oblzap_iter(U1, C2, Y1), obldest_iter(V1, R1, Z1), oblink_iter(W1, S1, A2), sprawdz_pk_iter(X1, T1, B2))/[W]/[]/[]/ ([U1, V1, W1, X1]/[])/ ([Y1, Z1, A2, B2]/[]), modjaki(X, Y, C2, R1, S1, T1, po)/ (oblzap_iter(U1, C2, Y1), obldest_iter(V1, R1, Z1), oblink_iter(W1, S1, A2), sprawdz_pk_iter(X1, T1, B2))/[X, Y]/[]/[]/ ([U1, V1, W1, X1]/[])/ ([Y1, Z1, A2, B2]/[])]/[L2, M2, N2, O2]/[Q2, R2, S2, T2]),
	wymagania_zamknij(P2),
	register(fpt(X,
		     Y,
		     C1,
		     wym(D3, E3, bw),
		     E1,
		     Q2,
		     W,
		     R2,
		     S2,
		     T2,
		     F3),
		 U2,
		 V2,
		 ptw2,
		 
		 [ W2/fw(T, X2, Y2, Z2, A3, post, tak, Z, A1, B1, po)
		 | B3
		 ],
		 C3),
	fpt(U2,
	    V2,
	    C3,
	    X,
	    Y,
	    C1,
	    wym(D3, E3, bw),
	    E1,
	    Q2,
	    W,
	    R2,
	    S2,
	    T2,
	    F3).

fl(W2, B, Y2, D, E, A, F, G, Y, Z, A1, po) :-
	do_sequence_of(Z2,
		       
		       [ C,
			 L1/ff(B1, C1, D1, E1, A, F1, G1, H1, I1, J1, K1, na)
		       | Q1
		       ],
		       B,
		       C,
		       [fw(K, D, E, A, F, pre, G, H, I, J, po)/ (obldest_iter(L, H, Q), oblink_iter(M, I, R), sprawdz_pk_iter(N, J, S), sprawdz_posiłk(O, V, T), zroblistę_iter(P, K, U))/[D, E, A, F, G]/[[]]/[P1]/ ([L, M, N, O]/[P])/ ([Q, R, S, T]/[U]), fl(D, E, A, F, G, H, I, J, po)/ (obldest_iter(L, H, Q), oblink_iter(M, I, R), sprawdz_pk_iter(N, J, S), sprawdz_posiłk(O, V, T), najwyżej3(W, _, X))/[D, E, A, F, G]/[0]/[I2]/ ([L, M, N, O]/[W])/ ([Q, R, S, T]/[X]), posiłk(V, A, H, I, J, po)/ (obldest_iter(L, H, Q), oblink_iter(M, I, R), sprawdz_pk_iter(N, J, S), sprawdz_posiłk(O, V, T))/[A]/[]/[]/ ([L, M, N, O]/[])/ ([Q, R, S, T]/[])]/[Y, Z, A1, bezpo]/[M1, N1, O1, O2]),
	goal(ff(B1,
		C1,
		D1,
		E1,
		A,
		F1,
		G1,
		H1,
		I1,
		J1,
		K1,
		na),
	     C,
	     R1,
	     L1),
	obldest_iter(M1, I1, L2),
	oblink_iter(N1, J1, M2),
	sprawdz_pk_iter(O1, K1, N2),
	wyjmijl(P1, G1, W1),
	do_sequence_of(Q1,
		       [],
		       R1,
		       X2,
		       [fw(V1, D, E, A, F, post, G, S1, T1, U1, po)/ (obldest_iter(X1, S1, C2), oblink_iter(Y1, T1, D2), sprawdz_pk_iter(Z1, U1, E2), sprawdz_post_posiłk(A2, H2, F2), oblwym_iter(B2, V1, G2))/[D, E, A, F, G]/[W1]/[Q2]/ ([X1, Y1, Z1, A2]/[B2])/ ([C2, D2, E2, F2]/[G2]), fl(D, E, A, F, G, S1, T1, U1, po)/ (obldest_iter(X1, S1, C2), oblink_iter(Y1, T1, D2), sprawdz_pk_iter(Z1, U1, E2), sprawdz_post_posiłk(A2, H2, F2), najwyżej3(J2, _, K2))/[D, E, A, F, G]/[I2]/[_]/ ([X1, Y1, Z1, A2]/[J2])/ ([C2, D2, E2, F2]/[K2]), posiłk(H2, A, S1, T1, U1, po)/ (obldest_iter(X1, S1, C2), oblink_iter(Y1, T1, D2), sprawdz_pk_iter(Z1, U1, E2), sprawdz_post_posiłk(A2, H2, F2))/[A]/[]/[]/ ([X1, Y1, Z1, A2]/[])/ ([C2, D2, E2, F2]/[])]/[L2, M2, N2, pierw(O2)]/[T2, U2, V2, P2]),
	oblposiłk(P2,
		  B1/C1/D1/E1/F1/H1,
		  R2/D/E/S2/F/G),
	wymagania_zamknij(Q2),
	wyklucz_podmiot_bezokolicznika(R2, G1),
	register(zdanie(R2,
			D,
			E,
			S2,
			A,
			F,
			G,
			T2,
			U2,
			V2,
			B3),
		 W2,
		 X2,
		 ze3,
		 
		 [ Y2/fl(D, E, A, F, G, Y, Z, A1, po)
		 | Z2
		 ],
		 A3),
	zdanie(W2,
	       X2,
	       A3,
	       R2,
	       D,
	       E,
	       S2,
	       A,
	       F,
	       G,
	       T2,
	       U2,
	       V2,
	       B3).

fl(E1, A, G1, B, C, D, E, F, X, Y, Z, po) :-
	rekcja_zdanioidowa(K),
	do_sequence_of(H1,
		       [],
		       A,
		       F1,
		       [fw(J, B, C, D, E, post, F, G, H, I, po)/ (obldest_iter(L, G, Q), oblink_iter(M, H, R), sprawdz_pk_iter(N, I, S), oblwym_iter(O, J, T), najwyżej(P, _, U))/[B, C, D, E, F]/[K, 3]/[A1, _]/ ([L, M, N]/[O, P])/ ([Q, R, S]/[T, U]), fl(B, C, D, E, F, G, H, I, po)/ (obldest_iter(L, G, Q), oblink_iter(M, H, R), sprawdz_pk_iter(N, I, S), najwyżej(V, _, W))/[B, C, D, E, F]/[2]/[_]/ ([L, M, N]/[V])/ ([Q, R, S]/[W])]/[X, Y, Z]/[B1, C1, D1]),
	wymagania_zamknij(A1),
	register(zdanie(bc(K),
			B,
			C,
			J1,
			D,
			E,
			F,
			B1,
			C1,
			D1,
			K1),
		 E1,
		 F1,
		 bc2,
		 
		 [ G1/fl(B, C, D, E, F, X, Y, Z, po)
		 | H1
		 ],
		 I1),
	zdanie(E1,
	       F1,
	       I1,
	       bc(K),
	       B,
	       C,
	       J1,
	       D,
	       E,
	       F,
	       B1,
	       C1,
	       D1,
	       K1).

fl(C2, E, E2, A, B, C, D, G, S, A2, T, po) :-
	do_sequence_of(F2,
		       
		       [ F,
			 A1/fwe(U, A, B, V, C, D, W, X, Y, ni, Z, na)
		       | F1
		       ],
		       E,
		       F,
		       [fw(J, A, B, C, D, pre, G, H, ni, I, po)/ (obldest_iter(K, H, N), sprawdz_pk_iter(L, I, O), zroblistę_iter(M, J, P))/[A, B, C, D, G]/[[]]/[E1]/ ([K, L]/[M])/ ([N, O]/[P]), fl(A, B, C, D, G, H, ni, I, po)/ (obldest_iter(K, H, N), sprawdz_pk_iter(L, I, O), najwyżej3(Q, _, R))/[A, B, C, D, G]/[0]/[R1]/ ([K, L]/[Q])/ ([N, O]/[R])]/[S, T]/[C1, D1]),
	goal(fwe(U,
		 A,
		 B,
		 V,
		 C,
		 D,
		 W,
		 X,
		 Y,
		 ni,
		 Z,
		 na),
	     F,
	     G1,
	     A1),
	wymagania_czyste(_, W),
	(   member(U, [bok, psu, psw])
	*-> wykluczpodmiot(W, B1)
	;   B1=W
	),
	obldest_iter(C1, Y, U1),
	sprawdz_pk_iter(D1, Z, V1),
	wyjmijl(E1, B1, K1),
	do_sequence_of(F1,
		       [],
		       G1,
		       D2,
		       [fw(J1, A, B, C, D, post, G, H1, ni, I1, po)/ (obldest_iter(L1, H1, O1), sprawdz_pk_iter(M1, I1, P1), oblwym_iter(N1, J1, Q1))/[A, B, C, D, G]/[K1]/[W1]/ ([L1, M1]/[N1])/ ([O1, P1]/[Q1]), fl(A, B, C, D, G, H1, ni, I1, po)/ (obldest_iter(L1, H1, O1), sprawdz_pk_iter(M1, I1, P1), najwyżej3(S1, _, T1))/[A, B, C, D, G]/[R1]/[_]/ ([L1, M1]/[S1])/ ([O1, P1]/[T1])]/[U1, V1]/[Z1, B2]),
	wymagania_oznacz_użyte(W1, X1),
	obl_neg_fwe(U, Y1, X, G),
	register(fwe(U,
		     A,
		     B,
		     V,
		     C,
		     D,
		     X1,
		     Y1,
		     Z1,
		     A2,
		     B2,
		     H2),
		 C2,
		 D2,
		 wew3,
		 
		 [ E2/fl(A, B, C, D, G, S, A2, T, po)
		 | F2
		 ],
		 G2),
	fwe(C2,
	    D2,
	    G2,
	    U,
	    A,
	    B,
	    V,
	    C,
	    D,
	    X1,
	    Y1,
	    Z1,
	    A2,
	    B2,
	    H2).

posiłk(V2, C, X2, A, B, Z, A1, B1, po) :-
	sprawdz_posiłk(bezpo, A, C1),
	do_sequence_of(Y2,
		       
		       [ D,
			 N1/ff(D1, E1, F1, G1, B, H1, I1, J1, K1, L1, M1, na)
		       | T1
		       ],
		       C,
		       D,
		       [fw(H, I, J, B, K, pre, L, E, F, G, po)/ (obldest_iter(M, E, R), oblink_iter(N, F, S), sprawdz_pk_iter(O, G, T), sprawdz_posiłk(P, W, U), zroblistę_iter(Q, H, V))/[I, J, B, K, L]/[[]]/[S1]/ ([M, N, O, P]/[Q])/ ([R, S, T, U]/[V]), fl(I, J, B, K, L, E, F, G, po)/ (obldest_iter(M, E, R), oblink_iter(N, F, S), sprawdz_pk_iter(O, G, T), sprawdz_posiłk(P, W, U), najwyżej3(X, _, Y))/[I, J, B, K, L]/[0]/[I2]/ ([M, N, O, P]/[X])/ ([R, S, T, U]/[Y])]/[Z, A1, B1, C1]/[P1, Q1, R1, O1]),
	goal(ff(D1,
		E1,
		F1,
		G1,
		B,
		H1,
		I1,
		J1,
		K1,
		L1,
		M1,
		na),
	     D,
	     U1,
	     N1),
	oblposiłk(O1,
		  D1/E1/F1/G1/H1/J1,
		  P2/I/J/R2/K/L),
	obldest_iter(P1, K1, L2),
	oblink_iter(Q1, L1, M2),
	sprawdz_pk_iter(R1, M1, N2),
	wyjmijl(S1, I1, Z1),
	do_sequence_of(T1,
		       [],
		       U1,
		       W2,
		       [fw(Y1, I, J, B, K, post, L, V1, W1, X1, po)/ (obldest_iter(A2, V1, E2), oblink_iter(B2, W1, F2), sprawdz_pk_iter(C2, X1, G2), oblwym_iter(D2, Y1, H2))/[I, J, B, K, L]/[Z1]/[O2]/ ([A2, B2, C2]/[D2])/ ([E2, F2, G2]/[H2]), fl(I, J, B, K, L, V1, W1, X1, po)/ (obldest_iter(A2, V1, E2), oblink_iter(B2, W1, F2), sprawdz_pk_iter(C2, X1, G2), najwyżej3(J2, _, K2))/[I, J, B, K, L]/[I2]/[_]/ ([A2, B2, C2]/[J2])/ ([E2, F2, G2]/[K2])]/[L2, M2, N2]/[Q2, T2, U2]),
	wymagania_zamknij(O2),
	wyklucz_podmiot_bezokolicznika(P2, I1),
	oblicz_dest_agl(A, Q2, S2),
	register(zdanie(P2,
			I,
			J,
			R2,
			B,
			K,
			L,
			S2,
			T2,
			U2,
			A3),
		 V2,
		 W2,
		 ze4,
		 
		 [ X2/posiłk(A, B, Z, A1, B1, po)
		 | Y2
		 ],
		 Z2),
	zdanie(V2,
	       W2,
	       Z2,
	       P2,
	       I,
	       J,
	       R2,
	       B,
	       K,
	       L,
	       S2,
	       T2,
	       U2,
	       A3).

fzd(R, A, T, B, nk, U, V, W, X, P, G, po) :-
	goal(przec(H, po), A, C, Y),
	goal(spójnik(pp, B, ni, po), C, D, Z),
	goal(zdanie(F,
		    J,
		    K,
		    L,
		    M,
		    N,
		    O,
		    E,
		    ni,
		    I,
		    na),
	     D,
	     S,
	     A1),
	tylko_neut_pyt(E),
	F\=bc(_),
	oblpk(Q, [G, H, I]),
	register(zdanie(F,
			J,
			K,
			L,
			M,
			N,
			O,
			E,
			P,
			Q,
			C1),
		 R,
		 S,
		 p2,
		 
		 [ T/fzd(B, nk, U, V, W, X, P, G, po),
		   A,
		   Y/przec(H, po),
		   C,
		   Z/spójnik(pp, B, ni, po),
		   D,
		   A1/zdanie(F, J, K, L, M, N, O, E, ni, I, na)
		 ],
		 B1),
	zdanie(R,
	       S,
	       B1,
	       F,
	       J,
	       K,
	       L,
	       M,
	       N,
	       O,
	       E,
	       P,
	       Q,
	       C1).

fzd(E, F, G, A, nk, H, B, I, J, C, D, na) :-
	member(A,
	       [aż, czy, gdy, jak, jakby, jakoby, jeśli, mie1, mie2, mie3, pz, że, żeby]),
	(   A=aż
	*-> B=przy
	;   true
	),
	register(fw(sentp(A),
		    L,
		    M,
		    N,
		    O,
		    P,
		    Q,
		    neut,
		    C,
		    D,
		    R),
		 E,
		 F,
		 wyz1,
		 
		 [ G/fzd(A, nk, H, B, I, J, C, D, na)
		 ],
		 K),
	fw(E,
	   F,
	   K,
	   sentp(A),
	   L,
	   M,
	   N,
	   O,
	   P,
	   Q,
	   neut,
	   C,
	   D,
	   R).

fzd(D, E, F, A, nk, G, H, I, J, B, C, na) :-
	member(A, [gdy, jak, jakby, jakoby, jeśli, pz, że, żeby]),
	register(fw(subj(sentp(A)),
		    L,
		    M,
		    r(mn(n), nmo(np(n)))/poj,
		    3,
		    N,
		    O,
		    neut,
		    B,
		    C,
		    P),
		 D,
		 E,
		 wyz1s,
		 
		 [ F/fzd(A, nk, G, H, I, J, B, C, na)
		 ],
		 K),
	fw(D,
	   E,
	   K,
	   subj(sentp(A)),
	   L,
	   M,
	   r(mn(n), nmo(np(n)))/poj,
	   3,
	   N,
	   O,
	   neut,
	   B,
	   C,
	   P).

fzd(F, G, H, A, B, I, C, J, K, D, E, na) :-
	member(A,
	       [aż, czy, gdy, jak, jakby, jakoby, jeśli, mie1, mie2, mie3, pz, że, żeby]),
	\+ member(B, [bier, nk, _/_]),
	(   A=aż
	*-> C=przy
	;   true
	),
	register(fw(sentp(B, A),
		    M,
		    N,
		    O,
		    P,
		    Q,
		    R,
		    neut,
		    D,
		    E,
		    S),
		 F,
		 G,
		 wyz2,
		 
		 [ H/fzd(A, B, I, C, J, K, D, E, na)
		 ],
		 L),
	fw(F,
	   G,
	   L,
	   sentp(B, A),
	   M,
	   N,
	   O,
	   P,
	   Q,
	   R,
	   neut,
	   D,
	   E,
	   S).

fzd(E, F, G, A, mian, H, B, I, J, C, D, na) :-
	member(A,
	       [aż, czy, gdy, jak, jakby, jakoby, jeśli, mie1, mie2, mie3, pz, że, żeby]),
	(   A=aż
	*-> B=przy
	;   true
	),
	register(fw(subj(sentp(mian, A)),
		    L,
		    M,
		    r(mn(n), nmo(np(n)))/poj,
		    3,
		    N,
		    O,
		    neut,
		    C,
		    D,
		    P),
		 E,
		 F,
		 wyz2s,
		 
		 [ G/fzd(A, mian, H, B, I, J, C, D, na)
		 ],
		 K),
	fw(E,
	   F,
	   K,
	   subj(sentp(mian, A)),
	   L,
	   M,
	   r(mn(n), nmo(np(n)))/poj,
	   3,
	   N,
	   O,
	   neut,
	   C,
	   D,
	   P).

fzd(E, F, G, A, dop, H, B, I, J, C, D, na) :-
	member(A,
	       [aż, czy, gdy, jak, jakby, jakoby, jeśli, mie1, mie2, mie3, pz, że, żeby]),
	(   A=aż
	*-> B=przy
	;   true
	),
	register(fw(sentp(bier, A),
		    L,
		    M,
		    N,
		    O,
		    P,
		    nie(Q),
		    neut,
		    C,
		    D,
		    R),
		 E,
		 F,
		 wyz3,
		 
		 [ G/fzd(A, dop, H, B, I, J, C, D, na)
		 ],
		 K),
	fw(E,
	   F,
	   K,
	   sentp(bier, A),
	   L,
	   M,
	   N,
	   O,
	   P,
	   nie(Q),
	   neut,
	   C,
	   D,
	   R).

fzd(E, F, G, A, bier, H, B, I, J, C, D, na) :-
	member(A, [aż, czy, jak, jakby, jakoby, mie1, mie2, mie3, pz, że, żeby]),
	(   A=aż
	*-> B=przy
	;   true
	),
	register(fw(sentp(bier, A),
		    L,
		    M,
		    N,
		    O,
		    P,
		    tak,
		    neut,
		    C,
		    D,
		    Q),
		 E,
		 F,
		 wyz4,
		 
		 [ G/fzd(A, bier, H, B, I, J, C, D, na)
		 ],
		 K),
	fw(E,
	   F,
	   K,
	   sentp(bier, A),
	   L,
	   M,
	   N,
	   O,
	   P,
	   tak,
	   neut,
	   C,
	   D,
	   Q).

fzd(G, H, I, A, C/D, J, B, K, L, E, F, na) :-
	member(A, [aż, czy, jak, jakby, jakoby, mie1, mie2, mie3, pz, że, żeby]),
	(   A=aż
	*-> B=przy
	;   true
	),
	register(fw(sentp(C, D, A),
		    N,
		    O,
		    P,
		    Q,
		    R,
		    S,
		    neut,
		    E,
		    F,
		    T),
		 G,
		 H,
		 wyz5,
		 
		 [ I/fzd(A, C/D, J, B, K, L, E, F, na)
		 ],
		 M),
	fw(G,
	   H,
	   M,
	   sentp(C, D, A),
	   N,
	   O,
	   P,
	   Q,
	   R,
	   S,
	   neut,
	   E,
	   F,
	   T).

fzd(C, D, E, dopóki, nk, F, G, H, I, A, B, na) :-
	register(fl(nd,
		    K,
		    L,
		    M,
		    tak,
		    neut,
		    A,
		    B,
		    N),
		 C,
		 D,
		 luz1,
		 
		 [ E/fzd(dopóki, nk, F, G, H, I, A, B, na)
		 ],
		 J),
	fl(C,
	   D,
	   J,
	   nd,
	   K,
	   L,
	   M,
	   tak,
	   neut,
	   A,
	   B,
	   N).

fzd(C, D, E, dopóki, nk, F, G, H, I, A, B, na) :-
	register(fl(K,
		    L,
		    M,
		    N,
		    nie(nie),
		    neut,
		    A,
		    B,
		    O),
		 C,
		 D,
		 luz2,
		 
		 [ E/fzd(dopóki, nk, F, G, H, I, A, B, na)
		 ],
		 J),
	fl(C,
	   D,
	   J,
	   K,
	   L,
	   M,
	   N,
	   nie(nie),
	   neut,
	   A,
	   B,
	   O).

fzd(D, E, F, A, nk, G, H, I, J, B, C, na) :-
	member(A, [choćby, gdyby]),
	register(fl(L,
		    M,
		    N,
		    O,
		    P,
		    neut,
		    B,
		    C,
		    Q),
		 D,
		 E,
		 luz3,
		 
		 [ F/fzd(A, nk, G, H, I, J, B, C, na)
		 ],
		 K),
	fl(D,
	   E,
	   K,
	   L,
	   M,
	   N,
	   O,
	   P,
	   neut,
	   B,
	   C,
	   Q).

fzd(E, F, G, B, nk, H, I, A, J, C, D, na) :-
	nonvar(A),
	member(B,
	       
	       [ aż,
		 gdy,
		 zanim,
		 bo,
		 wz(co, _),
		 chociaż,
		 czy,
		 jak,
		 jakby,
		 jeśli,
		 podczas,
		 ponieważ
	       ]),
	register(fl(L,
		    M,
		    N,
		    O,
		    P,
		    neut,
		    C,
		    D,
		    Q),
		 E,
		 F,
		 luz9,
		 
		 [ G/fzd(B, nk, H, I, A, J, C, D, na)
		 ],
		 K),
	fl(E,
	   F,
	   K,
	   L,
	   M,
	   N,
	   O,
	   P,
	   neut,
	   C,
	   D,
	   Q).

fzd(E, F, G, A, B, H, I, J, K, C, D, na) :-
	member(A, [żeby]),
	member(B, [nk, po/bier]),
	register(fl(M,
		    N,
		    O,
		    P,
		    Q,
		    neut,
		    C,
		    D,
		    R),
		 E,
		 F,
		 luz10,
		 
		 [ G/fzd(A, B, H, I, J, K, C, D, na)
		 ],
		 L),
	fl(E,
	   F,
	   L,
	   M,
	   N,
	   O,
	   P,
	   Q,
	   neut,
	   C,
	   D,
	   R).

fzd(C, D, E, wz(F, przys), nk, G, H, I, J, A, B, na) :-
	register(fl(L,
		    M,
		    N,
		    O,
		    P,
		    neut,
		    A,
		    B,
		    Q),
		 C,
		 D,
		 luz11,
		 
		 [ E/fzd(wz(F, przys), nk, G, H, I, J, A, B, na)
		 ],
		 K),
	fl(C,
	   D,
	   K,
	   L,
	   M,
	   N,
	   O,
	   P,
	   neut,
	   A,
	   B,
	   Q).

fzd(N, A, P, C, D, H, I, J, K, L, F, po) :-
	goal(przec(R, po), A, B, Q),
	goal(spójnik(rc, T, ni, na), B, E, S),
	goal(fzd(C,
		 D,
		 V,
		 W,
		 X,
		 Y,
		 ni,
		 G,
		 po),
	     E,
	     O,
	     U),
	oblpk(M, [F, (p| wp), G]),
	register(fzd(C,
		     D,
		     H,
		     I,
		     J,
		     K,
		     L,
		     M,
		     A1),
		 N,
		 O,
		 zdr1,
		 
		 [ P/fzd(C, D, H, I, J, K, L, F, po),
		   A,
		   Q/przec(R, po),
		   B,
		   S/spójnik(rc, T, ni, na),
		   E,
		   U/fzd(C, D, V, W, X, Y, ni, G, po)
		 ],
		 Z),
	fzd(N,
	    O,
	    Z,
	    C,
	    D,
	    H,
	    I,
	    J,
	    K,
	    L,
	    M,
	    A1).

fzd(H1, C, J1, A, B, C1, D1, E1, I, F1, B1, po) :-
	do_sequence_of(K1,
		       
		       [ D,
			 R/spójnik(szk, E, ni, na),
			 Q,
			 X/fzd(A, B, U, V, W, S, ni, J, po)
		       ],
		       C,
		       D,
		       [[spójnik(sz, E, ni, po), fzd(A, B, _, _, _, G, ni, F, po), przec(H, po)]/ (trzy_na_listę(K, [ (p| wp), F, (p| 0)], N), zroblistę_iter(L, G, O), conajmniej1(M, _, P))/[E, A, B, H]/[Y, [I], 0]/[[ (0| wp), J], T, 1]/ ([]/[K, L, M])/ ([]/[N, O, P])]/[]/[]),
	goal(spójnik(szk, E, ni, na), D, Q, R),
	E\=przec,
	sprawdz_neg_fzd(E, [S|T]),
	goal(fzd(A,
		 B,
		 U,
		 V,
		 W,
		 S,
		 ni,
		 J,
		 po),
	     Q,
	     I1,
	     X),
	(   B=nk
	->  Z=Y
	;   Y=[ (p| wp)|A1],
	    Z=[ (wb| wp)|A1]
	),
	oblpk(G1, [B1|Z]),
	register(fzd(A,
		     B,
		     C1,
		     D1,
		     E1,
		     I,
		     F1,
		     G1,
		     M1),
		 H1,
		 I1,
		 zdsz2,
		 
		 [ J1/fzd(A, B, C1, D1, E1, I, F1, B1, po)
		 | K1
		 ],
		 L1),
	fzd(H1,
	    I1,
	    L1,
	    A,
	    B,
	    C1,
	    D1,
	    E1,
	    I,
	    F1,
	    G1,
	    M1).

fzd(D1, D, F1, C, A, Y, Z, A1, H, B1, W, po) :-
	(   A=nk
	->  B=p
	;   B=wb
	),
	do_sequence_of(G1,
		       
		       [ E,
			 P/spójnik(szk, N, ni, na),
			 O,
			 V/fzd(C, A, S, T, U, Q, ni, I, po)
		       ],
		       D,
		       E,
		       [[spójnik(sz, przec, ni, po), fzd(C, A, _, _, _, G, ni, F, po)]/ (dwa_na_listę(J, [ (p| wp), F], L), zroblistę_iter(K, G, M))/[C, A]/[X, [H]]/[[ (B| wp), I], R]/ ([]/[J, K])/ ([]/[L, M])]/[]/[]),
	goal(spójnik(szk, N, ni, na), E, O, P),
	sprawdz_neg_fzd(N, [Q|R]),
	goal(fzd(C,
		 A,
		 S,
		 T,
		 U,
		 Q,
		 ni,
		 I,
		 po),
	     O,
	     E1,
	     V),
	oblpk(C1, [W|X]),
	register(fzd(C,
		     A,
		     Y,
		     Z,
		     A1,
		     H,
		     B1,
		     C1,
		     I1),
		 D1,
		 E1,
		 zdsz3,
		 
		 [ F1/fzd(C, A, Y, Z, A1, H, B1, W, po)
		 | G1
		 ],
		 H1),
	fzd(D1,
	    E1,
	    H1,
	    C,
	    A,
	    Y,
	    Z,
	    A1,
	    H,
	    B1,
	    C1,
	    I1).

formawykrz(O, A, Q, H, na) :-
	do_sequence_of(R,
		       [],
		       A,
		       P,
		       [fw(C, D, E, F, G, post, tak, neut, ni, B, po)/ (sprawdz_pk_iter(I, B, K), oblwym_iter(J, C, L))/[D, E, F, G]/[H]/[M]/ ([I]/[J])/ ([K]/[L])]/[ (0| 0)]/[N]),
	wymagania_zamknij(M),
	register(zdanie(wykrz,
			D,
			E,
			T,
			U,
			G,
			tak,
			neut,
			ni,
			N,
			V),
		 O,
		 P,
		 zk1,
		 [Q/formawykrz(H, na)|R],
		 S),
	zdanie(O,
	       P,
	       S,
	       wykrz,
	       D,
	       E,
	       T,
	       U,
	       G,
	       tak,
	       neut,
	       ni,
	       N,
	       V).

fwe(M, N, O, A, F, G, H, C/D, E, B, I, J, K, L, na) :-
	równe(A, [os, bos, bok, sp:_]),
	wymagania_czyste(_, B),
	C\==mie,
	D\==mie,
	E\==mie,
	register(ff(A,
		    F,
		    G,
		    H,
		    C/D,
		    E,
		    B,
		    I,
		    J,
		    K,
		    L,
		    Q),
		 M,
		 N,
		 fi1,
		 
		 [ O/fwe(A, F, G, H, C/D, E, B, I, J, K, L, na)
		 ],
		 P),
	ff(M,
	   N,
	   P,
	   A,
	   F,
	   G,
	   H,
	   C/D,
	   E,
	   B,
	   I,
	   J,
	   K,
	   L,
	   Q).

fwe(L, M, N, bok, G, H, O, P, Q, F, A, I, J, K, na) :-
	(   A=B/D
	*-> (   B=req(C)
	    *-> C=E
	    ;   D=req(C)
	    *-> C=E
	    ;   true
	    )
	;   A=req(C)
	*-> C=E
	;   true
	),
	wymagania_zamknij(F),
	register(fw(infp(G),
		    S,
		    H,
		    T,
		    U,
		    V,
		    E,
		    I,
		    J,
		    K,
		    W),
		 L,
		 M,
		 wy1,
		 
		 [ N/fwe(bok, G, H, O, P, Q, F, A, I, J, K, na)
		 ],
		 R),
	fw(L,
	   M,
	   R,
	   infp(G),
	   S,
	   H,
	   T,
	   U,
	   V,
	   E,
	   I,
	   J,
	   K,
	   W).

fwe(L, M, N, bok, G, H, O, P, Q, F, A, I, J, K, na) :-
	(   A=B/D
	*-> (   B=req(C)
	    *-> C=E
	    ;   D=req(C)
	    *-> C=E
	    ;   true
	    )
	;   A=req(C)
	*-> C=E
	;   true
	),
	wymagania_zamknij(F),
	register(fw(subj(infp(G)),
		    S,
		    H,
		    r(mn(n), nmo(np(n)))/poj,
		    3,
		    T,
		    E,
		    I,
		    J,
		    K,
		    U),
		 L,
		 M,
		 wy1s,
		 
		 [ N/fwe(bok, G, H, O, P, Q, F, A, I, J, K, na)
		 ],
		 R),
	fw(L,
	   M,
	   R,
	   subj(infp(G)),
	   S,
	   H,
	   r(mn(n), nmo(np(n)))/poj,
	   3,
	   T,
	   E,
	   I,
	   J,
	   K,
	   U).

fwe(H, A, J, psw, K, F, L, M, N, E, O, neut, G, B, na) :-
	optional(P,
		 [],
		 A,
		 I,
		 przec(C, po),
		 { oblpk(D, [ (bp| p), B, C])
		 },
		 { D=B
		 }),
	wymagania_zamknij(E),
	register(fl(R,
		    F,
		    S,
		    T,
		    U,
		    neut,
		    G,
		    D,
		    V),
		 H,
		 I,
		 luw1o,
		 
		 [ J/fwe(psw, K, F, L, M, N, E, O, neut, G, B, na)
		 | P
		 ],
		 Q),
	fl(H,
	   I,
	   Q,
	   R,
	   F,
	   S,
	   T,
	   U,
	   neut,
	   G,
	   D,
	   V).

fwe(G, A, I, psu, J, prze, K, L, M, E, N, neut, F, B, na) :-
	optional(O,
		 [],
		 A,
		 H,
		 przec(C, po),
		 { oblpk(D, [ (bp| p), B, C])
		 },
		 { D=B
		 }),
	wymagania_zamknij(E),
	register(fl(Q,
		    R,
		    S,
		    T,
		    U,
		    neut,
		    F,
		    D,
		    V),
		 G,
		 H,
		 luw2o,
		 
		 [ I/fwe(psu, J, prze, K, L, M, E, N, neut, F, B, na)
		 | O
		 ],
		 P),
	fl(G,
	   H,
	   P,
	   Q,
	   R,
	   S,
	   T,
	   U,
	   neut,
	   F,
	   D,
	   V).

fwe(H, A, J, psu, K, E, L, M, N, F, O, neut, G, B, na) :-
	optional(P,
		 [],
		 A,
		 I,
		 przec(C, po),
		 { oblpk(D, [ (bp| p), B, C])
		 },
		 { D=B
		 }),
	E\=prze,
	wymagania_zamknij(F),
	register(fl(R,
		    przy,
		    S,
		    T,
		    U,
		    neut,
		    G,
		    D,
		    V),
		 H,
		 I,
		 luw3o,
		 
		 [ J/fwe(psu, K, E, L, M, N, F, O, neut, G, B, na)
		 | P
		 ],
		 Q),
	fl(H,
	   I,
	   Q,
	   R,
	   przy,
	   S,
	   T,
	   U,
	   neut,
	   G,
	   D,
	   V).

fwe(H1, D, J1, B, E, F, B1, G, H, A, A1, X, F1, Y, na) :-
	wymagania_czyste(_, A),
	(   member(B, [bok, psu, psw])
	*-> wykluczpodmiot(A, C)
	;   C=A
	),
	do_sequence_of(K1,
		       [],
		       D,
		       I1,
		       [fw(K, E, F, G, H, post, L, I, ni, J, po)/ (obldest_iter(M, I, Q), sprawdz_pk_iter(N, J, R), conajmniej1(O, U, S), oblwym_iter(P, K, T))/[E, F, G, H, L]/[C]/[Z]/ ([M, N, O]/[P])/ ([Q, R, S]/[T]), fl(E, F, G, H, L, I, ni, J, po)/ (obldest_iter(M, I, Q), sprawdz_pk_iter(N, J, R), conajmniej1(O, U, S), najwyżej3(V, _, W))/[E, F, G, H, L]/[0]/[_]/ ([M, N, O]/[V])/ ([Q, R, S]/[W])]/[X, Y, 0]/[E1, G1, 1]),
	wymagania_oznacz_użyte(Z, C1),
	obl_neg_fwe(B, D1, A1, L),
	register(fwe(B,
		     E,
		     F,
		     B1,
		     G,
		     H,
		     C1,
		     D1,
		     E1,
		     F1,
		     G1,
		     M1),
		 H1,
		 I1,
		 wew1,
		 
		 [ J1/fwe(B, E, F, B1, G, H, A, A1, X, F1, Y, na)
		 | K1
		 ],
		 L1),
	fwe(H1,
	    I1,
	    L1,
	    B,
	    E,
	    F,
	    B1,
	    G,
	    H,
	    C1,
	    D1,
	    E1,
	    F1,
	    G1,
	    M1).

fwe(F1, B, H1, D, V, W, E, K/M, O, T, Q, A, D1, H, po) :-
	tylko_neut_pyt(A),
	goal(przec(I, po), B, C, I1),
	goal(spójnik(rc, S, ni, na), C, F, J1),
	goal(fwe(D,
		 L1,
		 M1,
		 E,
		 L/N,
		 P,
		 U,
		 R,
		 G,
		 ni,
		 J,
		 po),
	     F,
	     G1,
	     K1),
	obldest(C1, [A, G]),
	oblpk(E1, [H, I, J]),
	zgodne_iter(K, L, X),
	zgodne_iter(M, N, Y),
	zgodne_iter(O, P, Z),
	neg_do_sąsiada(Q, R, B1),
	oblwym_koord(A1, r1:S, [T, U]),
	register(fwe(D,
		     V,
		     W,
		     E,
		     X/Y,
		     Z,
		     A1,
		     B1,
		     C1,
		     D1,
		     E1,
		     O1),
		 F1,
		 G1,
		 wer1,
		 
		 [ H1/fwe(D, V, W, E, K/M, O, T, Q, A, D1, H, po),
		   B,
		   I1/przec(I, po),
		   C,
		   J1/spójnik(rc, S, ni, na),
		   F,
		   K1/fwe(D, L1, M1, E, L/N, P, U, R, G, ni, J, po)
		 ],
		 N1),
	fwe(F1,
	    G1,
	    N1,
	    D,
	    V,
	    W,
	    E,
	    X/Y,
	    Z,
	    A1,
	    B1,
	    C1,
	    D1,
	    E1,
	    O1).

fwe(C1, A, E1, B, S, T, C, H/J, L, Q, N, neut, A1, F, po) :-
	goal(przec(G1, na), A, D, F1),
	goal(fwe(B,
		 I1,
		 J1,
		 C,
		 I/K,
		 M,
		 R,
		 O,
		 E,
		 i(r, P),
		 G,
		 po),
	     D,
	     D1,
	     H1),
	obldest(Z, [neut, E]),
	oblpk(B1, [F, (p| wp), G]),
	zgodne_iter(H, I, U),
	zgodne_iter(J, K, V),
	zgodne_iter(L, M, W),
	neg_do_sąsiada(N, O, Y),
	oblwym_koord(X, r2:P, [Q, R]),
	register(fwe(B,
		     S,
		     T,
		     C,
		     U/V,
		     W,
		     X,
		     Y,
		     Z,
		     A1,
		     B1,
		     L1),
		 C1,
		 D1,
		 wer2,
		 
		 [ E1/fwe(B, S, T, C, H/J, L, Q, N, neut, A1, F, po),
		   A,
		   F1/przec(G1, na),
		   D,
		   H1/fwe(B, I1, J1, C, I/K, M, R, O, E, i(r, P), G, po)
		 ],
		 K1),
	fwe(C1,
	    D1,
	    K1,
	    B,
	    S,
	    T,
	    C,
	    U/V,
	    W,
	    X,
	    Y,
	    Z,
	    A1,
	    B1,
	    L1).

fwe(N2, D, P2, B, D2, E2, C, O/P, Q, B2, R, A, L2, U1, po) :-
	tylko_neut_pyt(A),
	do_sequence_of(Q2,
		       
		       [ E,
			 L1/spójnik(szk, F, ni, na),
			 K1,
			 T1/fwe(B, M1, N1, C, O1/P1, Q1, T, R1, S1, ni, S, po)
		       ],
		       D,
		       E,
		       [[spójnik(sz, F, ni, po), fwe(B, _, _, C, J/K, L, I, M, H, ni, G, po), przec(N, po)]/ (trzy_na_listę(U, [ (0| 0), G, (p| wp)], C1), obldest_iter(V, H, D1), jeden_na_listę(W, I, E1), zgodne_iter(X, J, F1), zgodne_iter(Y, K, G1), zgodne_iter(Z, L, H1), neg_do_sąsiada(A1, M, I1), conajmniej1(B1, _, J1))/[F, B, C, N]/[V1, A, C2, O, P, Q, R, 0]/[[ (0| 0), S], W1, [T], X1, Y1, Z1, A2, 1]/ ([]/[U, V, W, X, Y, Z, A1, B1])/ ([]/[C1, D1, E1, F1, G1, H1, I1, J1])]/[]/[]),
	goal(spójnik(szk, F, ni, na), E, K1, L1),
	różne(F, [przec, czy]),
	goal(fwe(B,
		 M1,
		 N1,
		 C,
		 O1/P1,
		 Q1,
		 T,
		 R1,
		 S1,
		 ni,
		 S,
		 po),
	     K1,
	     O2,
	     T1),
	oblpk(M2, [U1|V1]),
	obldest_iter(W1, S1, K2),
	zgodne_iter(X1, O1, F2),
	zgodne_iter(Y1, P1, G2),
	zgodne_iter(Z1, Q1, H2),
	neg_do_sąsiada(A2, R1, J2),
	oblwym_koord(I2, sz2:F, [B2|C2]),
	register(fwe(B,
		     D2,
		     E2,
		     C,
		     F2/G2,
		     H2,
		     I2,
		     J2,
		     K2,
		     L2,
		     M2,
		     S2),
		 N2,
		 O2,
		 wes2,
		 
		 [ P2/fwe(B, D2, E2, C, O/P, Q, B2, R, A, L2, U1, po)
		 | Q2
		 ],
		 R2),
	fwe(N2,
	    O2,
	    R2,
	    B,
	    D2,
	    E2,
	    C,
	    F2/G2,
	    H2,
	    I2,
	    J2,
	    K2,
	    L2,
	    M2,
	    S2).

fwe(M2, D, O2, B, C2, D2, C, M/N, O, Z1, P, A, K2, S1, po) :-
	tylko_neut_pyt(A),
	do_sequence_of(P2,
		       
		       [ E,
			 I1/spójnik(szk, G1, ni, na),
			 H1,
			 R1/fwe(B, K1, L1, C, M1/N1, O1, R, P1, Q1, ni, Q, po)
		       ],
		       D,
		       E,
		       [[spójnik(sz, przec, ni, po), fwe(B, _, _, C, I/J, K, H, L, G, ni, F, po)]/ (dwa_na_listę(S, [ (p| wp), F], Z), obldest_iter(T, G, A1), jeden_na_listę(U, H, B1), zgodne_iter(V, I, C1), zgodne_iter(W, J, D1), zgodne_iter(X, K, E1), neg_do_sąsiada(Y, L, F1))/[B, C]/[T1, A, A2, M, N, O, P]/[[J1, Q], U1, [R], V1, W1, X1, Y1]/ ([]/[S, T, U, V, W, X, Y])/ ([]/[Z, A1, B1, C1, D1, E1, F1])]/[]/[]),
	goal(spójnik(szk, G1, ni, na), E, H1, I1),
	G1\=czy,
	(   G1=przec
	->  J1= (p| wp)
	;   J1= (db| 0)
	),
	goal(fwe(B,
		 K1,
		 L1,
		 C,
		 M1/N1,
		 O1,
		 R,
		 P1,
		 Q1,
		 ni,
		 Q,
		 po),
	     H1,
	     N2,
	     R1),
	oblpk(L2, [S1|T1]),
	obldest_iter(U1, Q1, J2),
	zgodne_iter(V1, M1, E2),
	zgodne_iter(W1, N1, F2),
	zgodne_iter(X1, O1, G2),
	neg_do_sąsiada(Y1, P1, I2),
	wyklucz_przecinkowość_w_szeregu([Z1|A2]),
	(   G1\=przec
	;   wymagania_czyste(B2, R)
	*-> B2\=sz:_
	;   true
	),
	oblwym_koord(H2, sz:G1, [Z1|A2]),
	register(fwe(B,
		     C2,
		     D2,
		     C,
		     E2/F2,
		     G2,
		     H2,
		     I2,
		     J2,
		     K2,
		     L2,
		     R2),
		 M2,
		 N2,
		 wes3,
		 
		 [ O2/fwe(B, C2, D2, C, M/N, O, Z1, P, A, K2, S1, po)
		 | P2
		 ],
		 Q2),
	fwe(M2,
	    N2,
	    Q2,
	    B,
	    C2,
	    D2,
	    C,
	    E2/F2,
	    G2,
	    H2,
	    I2,
	    J2,
	    K2,
	    L2,
	    R2).

fpm(G, H, I, A, B, J, K, C, D, E, F, na) :-
	register(fw(prepnp(A, B),
		    M,
		    N,
		    O,
		    P,
		    Q,
		    C,
		    D,
		    E,
		    F,
		    R),
		 G,
		 H,
		 wy2,
		 
		 [ I/fpm(A, B, J, K, C, D, E, F, na)
		 ],
		 L),
	fw(G,
	   H,
	   L,
	   prepnp(A, B),
	   M,
	   N,
	   O,
	   P,
	   Q,
	   C,
	   D,
	   E,
	   F,
	   R).

fpm(E, F, G, H, I, J, K, A, B, C, D, na) :-
	register(fw(advp,
		    M,
		    N,
		    O,
		    P,
		    Q,
		    A,
		    B,
		    C,
		    D,
		    R),
		 E,
		 F,
		 wy11,
		 
		 [ G/fpm(H, I, J, K, A, B, C, D, na)
		 ],
		 L),
	fw(E,
	   F,
	   L,
	   advp,
	   M,
	   N,
	   O,
	   P,
	   Q,
	   A,
	   B,
	   C,
	   D,
	   R).

fpm(H, A, J, K, L, M, N, E, F, G, B, na) :-
	optional(O,
		 [],
		 A,
		 I,
		 przec(C, po),
		 { oblpk(D, [ (bp| p), B, C])
		 },
		 { D=B
		 }),
	register(fl(Q,
		    R,
		    S,
		    T,
		    E,
		    F,
		    G,
		    D,
		    U),
		 H,
		 I,
		 lu1,
		 
		 [ J/fpm(K, L, M, N, E, F, G, B, na)
		 | O
		 ],
		 P),
	fl(H,
	   I,
	   P,
	   Q,
	   R,
	   S,
	   T,
	   E,
	   F,
	   G,
	   D,
	   U).

fpm(M3, B, O3, P3, Q3, R3, D1, A, E1, F1, G1, po) :-
	do_sequence_of(S3,
		       
		       [ C,
			 Q1/fno(H1, E/F, I1, J1, K1, L1, M1, A, N1, O1, P1, na)
		       | X1
		       ],
		       B,
		       C,
		       [[optional(przec(D, po), {}, {D= (bp| p)}), fpt(M, E/F, _, wym([], _, _), _, H, A, I, J, K, po), optional(przec(G, po), {}, {G= (p| bp)})]/ (oblzap_iter(N, H, R), obldest_iter(O, I, S), oblink_iter(P, J, T), sprawdz_pk_iter(Q, L, U), sprawdz_fpt_noa(D/K/G/L))/[M, E, F, A]/[]/[]/ ([N, O, P, Q]/[])/ ([R, S, T, U]/[]), fpm(_, _, _, H, A, I, J, L, po)/ (oblzap_iter(N, H, R), obldest_iter(O, I, S), oblink_iter(P, J, T), sprawdz_pk_iter(Q, L, U))/[A]/[]/[]/ ([N, O, P, Q]/[])/ ([R, S, T, U]/[]), fno(dop, _, 3, wym([], _, _), V, H, pre, A, I, J, L, po)/ (oblzap_iter(N, H, R), obldest_iter(O, I, S), oblink_iter(P, J, T), sprawdz_pk_iter(Q, L, U), sprawdz_kl_nod_prehead(R1/V))/[A]/[]/[]/ ([N, O, P, Q]/[])/ ([R, S, T, U]/[]), fw(W, X, Y, Z, A1, post, A, I, ni, L, po)/ (oblzap_iter(N, H, R), obldest_iter(O, I, S), oblink_iter(P, J, T), sprawdz_pk_iter(Q, L, U), zroblistę_iter(B1, W, C1))/[X, Y, Z, A1, A]/[[]]/[W1]/ ([N, O, P, Q]/[B1])/ ([R, S, T, U]/[C1]), modpart(fno, A, I, ni, L, po)/ (oblzap_iter(N, H, R), obldest_iter(O, I, S), oblink_iter(P, J, T), sprawdz_pk_iter(Q, L, U))/[A]/[]/[]/ ([N, O, P, Q]/[])/ ([R, S, T, U]/[])]/[D1, E1, F1, G1]/[S1, T1, U1, V1]),
	goal(fno(H1,
		 E/F,
		 I1,
		 J1,
		 K1,
		 L1,
		 M1,
		 A,
		 N1,
		 O1,
		 P1,
		 na),
	     C,
	     Y1,
	     Q1),
	J1=wym(_, _, [_|_]),
	sprawdz_kl_noa(K1, H1, M),
	sprawdz_kl_nod_head(R1, K1),
	oblzap_iter(S1, L1, D3),
	obldest_iter(T1, N1, E3),
	oblink_iter(U1, O1, F3),
	sprawdz_pk_iter(V1, P1, G3),
	wyjmijl(W1, J1, A3),
	do_sequence_of(X1,
		       [],
		       Y1,
		       N3,
		       [[optional(przec(Z1, po), {}, {Z1= (bp| p)}), fpt(M, E/F, _, wym([], _, _), _, B2, A, C2, D2, E2, po), optional(przec(A2, po), {}, {A2= (p| bp)})]/ (oblzap_iter(G2, B2, K2), obldest_iter(H2, C2, L2), oblink_iter(I2, D2, M2), sprawdz_pk_iter(J2, F2, N2), sprawdz_fpt_noa(Z1/E2/A2/F2))/[M, E, F, A]/[]/[]/ ([G2, H2, I2, J2]/[])/ ([K2, L2, M2, N2]/[]), fpm(_, _, _, B2, A, C2, D2, F2, po)/ (oblzap_iter(G2, B2, K2), obldest_iter(H2, C2, L2), oblink_iter(I2, D2, M2), sprawdz_pk_iter(J2, F2, N2))/[A]/[]/[]/ ([G2, H2, I2, J2]/[])/ ([K2, L2, M2, N2]/[]), fno(dop, _, 3, wym([], _, _), O2, B2, pre, A, C2, D2, F2, po)/ (oblzap_iter(G2, B2, K2), obldest_iter(H2, C2, L2), oblink_iter(I2, D2, M2), sprawdz_pk_iter(J2, F2, N2), sprawdz_kl_nod(K1/O2))/[A]/[]/[]/ ([G2, H2, I2, J2]/[])/ ([K2, L2, M2, N2]/[]), fzd(P2, nk, Q2, R2, S2, _, ni, F2, po)/ (oblzap_iter(G2, B2, K2), obldest_iter(H2, C2, L2), oblink_iter(I2, D2, M2), sprawdz_pk_iter(J2, F2, N2), sprawdz_fzd_noz(T2, P2, U2))/[Q2, R2, S2]/[E/F/K1/H3]/[_]/ ([G2, H2, I2, J2]/[T2])/ ([K2, L2, M2, N2]/[U2]), fw(V2, W2, X2, Y2, Z2, post, A, C2, ni, F2, po)/ (oblzap_iter(G2, B2, K2), obldest_iter(H2, C2, L2), oblink_iter(I2, D2, M2), sprawdz_pk_iter(J2, F2, N2), oblwym_iter(B3, V2, C3))/[W2, X2, Y2, Z2, A]/[A3]/[I3]/ ([G2, H2, I2, J2]/[B3])/ ([K2, L2, M2, N2]/[C3]), modpart(fno, A, C2, ni, F2, po)/ (oblzap_iter(G2, B2, K2), obldest_iter(H2, C2, L2), oblink_iter(I2, D2, M2), sprawdz_pk_iter(J2, F2, N2))/[A]/[]/[]/ ([G2, H2, I2, J2]/[])/ ([K2, L2, M2, N2]/[])]/[D3, E3, F3, G3]/[H3, J3, K3, L3]),
	wymagania_zamknij_nieuważnie(I3),
	register(fno(H1,
		     E/F,
		     I1,
		     wym(U3, V3, bw),
		     K1,
		     H3,
		     M1,
		     A,
		     J3,
		     K3,
		     L3,
		     W3),
		 M3,
		 N3,
		 nop2,
		 
		 [ O3/fpm(P3, Q3, R3, D1, A, E1, F1, G1, po)
		 | S3
		 ],
		 T3),
	fno(M3,
	    N3,
	    T3,
	    H1,
	    E/F,
	    I1,
	    wym(U3, V3, bw),
	    K1,
	    H3,
	    M1,
	    A,
	    J3,
	    K3,
	    L3,
	    W3).

fpm(Y, B, A1, S, T, A, U, C, P, Q, R, na) :-
	A\= (mod),
	do_sequence_of(B1,
		       [],
		       B,
		       Z,
		       [fps(_, _, C, D, E, F, po)/ (obldest_iter(G, D, K), oblink_iter(H, E, L), sprawdz_pk_iter(I, F, M), conajmniej1(J, O, N))/[C]/[]/[]/ ([G, H, I, J]/[])/ ([K, L, M, N]/[]), modpart(fpm, C, D, E, F, po)/ (obldest_iter(G, D, K), oblink_iter(H, E, L), sprawdz_pk_iter(I, F, M), conajmniej1(J, O, N))/[C]/[]/[]/ ([G, H, I, J]/[])/ ([K, L, M, N]/[])]/[P, Q, R, 0]/[V, W, X, 1]),
	register(fpm(S,
		     T,
		     (mod),
		     U,
		     C,
		     V,
		     W,
		     X,
		     D1),
		 Y,
		 Z,
		 pm4,
		 
		 [ A1/fpm(S, T, A, U, C, P, Q, R, na)
		 | B1
		 ],
		 C1),
	fpm(Y,
	    Z,
	    C1,
	    S,
	    T,
	    (mod),
	    U,
	    C,
	    V,
	    W,
	    X,
	    D1).

fpm(T, A, V, K, L, W, C, D, F, R, H, po) :-
	goal(przec(I, po), A, B, X),
	goal(spójnik(rc, Z, ni, na), B, E, Y),
	goal(fpm(M,
		 N,
		 B1,
		 C,
		 D,
		 G,
		 ni,
		 J,
		 po),
	     E,
	     U,
	     A1),
	obldest_fno_iter(F, G, Q),
	oblpk(S, [H, I, J]),
	obl_pmp([K/L, M/N], O, P),
	register(fpm(O,
		     P,
		     r,
		     C,
		     D,
		     Q,
		     R,
		     S,
		     D1),
		 T,
		 U,
		 pmr1,
		 
		 [ V/fpm(K, L, W, C, D, F, R, H, po),
		   A,
		   X/przec(I, po),
		   B,
		   Y/spójnik(rc, Z, ni, na),
		   E,
		   A1/fpm(M, N, B1, C, D, G, ni, J, po)
		 ],
		 C1),
	fpm(T,
	    U,
	    C1,
	    O,
	    P,
	    r,
	    C,
	    D,
	    Q,
	    R,
	    S,
	    D1).

fpm(X, B, Z, N, O, T, E, F, A, V, J, na) :-
	tylko_neut_pyt(A),
	goal(przec(K, po), B, C, A1),
	goal(spójnik(rc, D, ni, po), C, G, B1),
	member(D, [czyli, więc, mianowicie, raczej]),
	goal(fpm(P,
		 Q,
		 D1,
		 E,
		 F,
		 I,
		 ni,
		 L,
		 po),
	     G,
	     H,
	     C1),
	goal(przec(M, po), H, Y, E1),
	obldest_fno_iter(A, I, U),
	oblpk(W, [J, K, L, M]),
	obl_pmp([N/O, P/Q], R, S),
	register(fpm(R,
		     S,
		     T,
		     E,
		     F,
		     U,
		     V,
		     W,
		     G1),
		 X,
		 Y,
		 pmr3,
		 
		 [ Z/fpm(N, O, T, E, F, A, V, J, na),
		   B,
		   A1/przec(K, po),
		   C,
		   B1/spójnik(rc, D, ni, po),
		   G,
		   C1/fpm(P, Q, D1, E, F, I, ni, L, po),
		   H,
		   E1/przec(M, po)
		 ],
		 F1),
	fpm(X,
	    Y,
	    F1,
	    R,
	    S,
	    T,
	    E,
	    F,
	    U,
	    V,
	    W,
	    G1).

fpm(O1, D, Q1, N, O, A, B, C, M, M1, F1, po) :-
	sprawdz_kl_nie_sz(A),
	do_sequence_of(R1,
		       
		       [ E,
			 Z/spójnik(szk, F, ni, na),
			 Y,
			 E1/fpm(A1, B1, C1, B, C, D1, ni, P, po)
		       ],
		       D,
		       E,
		       [[spójnik(sz, F, ni, na), fpm(J, K, G, B, C, I, ni, H, po), przec(L, po)]/ (sprawdz_kl_nie_sz(G), trzy_na_listę(Q, [ (0| 0), H, (p| wp)], U), obldest_fno_iter(R, I, V), zroblistę_iter(S, J/K, W), conajmniej1(T, _, X))/[F, B, C, L]/[G1, M, [N/O], 0]/[[ (0| 0), P], H1, I1, 1]/ ([]/[Q, R, S, T])/ ([]/[U, V, W, X])]/[]/[]),
	goal(spójnik(szk, F, ni, na), E, Y, Z),
	F\=przec,
	sprawdz_neg(F, C),
	goal(fpm(A1,
		 B1,
		 C1,
		 B,
		 C,
		 D1,
		 ni,
		 P,
		 po),
	     Y,
	     P1,
	     E1),
	sprawdz_kl_nie_sz(C1),
	oblpk(N1, [F1|G1]),
	obldest_fno_iter(H1, D1, L1),
	obl_pmp([A1/B1|I1], J1, K1),
	register(fpm(J1,
		     K1,
		     sz,
		     B,
		     C,
		     L1,
		     M1,
		     N1,
		     T1),
		 O1,
		 P1,
		 pms2,
		 
		 [ Q1/fpm(N, O, A, B, C, M, M1, F1, po)
		 | R1
		 ],
		 S1),
	fpm(O1,
	    P1,
	    S1,
	    J1,
	    K1,
	    sz,
	    B,
	    C,
	    L1,
	    M1,
	    N1,
	    T1).

fpm(M1, D, O1, L, M, A, B, C, K, K1, D1, po) :-
	sprawdz_kl_nie_sz(A),
	do_sequence_of(P1,
		       
		       [ E,
			 W/spójnik(szk, U, ni, na),
			 V,
			 C1/fpm(Y, Z, A1, B, C, B1, ni, N, po)
		       ],
		       D,
		       E,
		       [[spójnik(sz, przec, ni, po), fpm(I, J, F, B, C, H, ni, G, po)]/ (sprawdz_kl_nie_sz(F), dwa_na_listę(O, [ (p| wp), G], R), obldest_fno_iter(P, H, S), zroblistę_iter(Q, I/J, T))/[B, C]/[E1, K, [L/M]]/[[X, N], F1, G1]/ ([]/[O, P, Q])/ ([]/[R, S, T])]/[]/[]),
	goal(spójnik(szk, U, ni, na), E, V, W),
	(   U=przec
	->  X= (p| wp)
	;   X= (0| 0)
	),
	sprawdz_neg(U, C),
	goal(fpm(Y,
		 Z,
		 A1,
		 B,
		 C,
		 B1,
		 ni,
		 N,
		 po),
	     V,
	     N1,
	     C1),
	sprawdz_kl_nie_sz(A1),
	oblpk(L1, [D1|E1]),
	obldest_fno_iter(F1, B1, J1),
	obl_pmp([Y/Z|G1], H1, I1),
	register(fpm(H1,
		     I1,
		     sz,
		     B,
		     C,
		     J1,
		     K1,
		     L1,
		     R1),
		 M1,
		 N1,
		 pmsz3,
		 
		 [ O1/fpm(L, M, A, B, C, K, K1, D1, po)
		 | P1
		 ],
		 Q1),
	fpm(M1,
	    N1,
	    Q1,
	    H1,
	    I1,
	    sz,
	    B,
	    C,
	    J1,
	    K1,
	    L1,
	    R1).

fpm(U2, A, W2, X2, Y2, Z2, Y, A3, Z, A1, B1, po) :-
	do_sequence_of(B3,
		       
		       [ B,
			 J1/fpt(W, X, C1, D1, E1, F1, V, G1, H1, I1, na)
		       | P1
		       ],
		       A,
		       B,
		       [fps(_, _, _, C, D, E, po)/ (oblzap_iter(F, N, J), obldest_iter(G, C, K), oblink_iter(H, D, L), sprawdz_pk_iter(I, E, M))/[]/[]/[]/ ([F, G, H, I]/[])/ ([J, K, L, M]/[]), fpm(_, _, _, N, _, C, D, E, po)/ (oblzap_iter(F, N, J), obldest_iter(G, C, K), oblink_iter(H, D, L), sprawdz_pk_iter(I, E, M))/[]/[]/[]/ ([F, G, H, I]/[])/ ([J, K, L, M]/[]), fw(O, P, Q, R, S, post, tak, C, D, E, po)/ (oblzap_iter(F, N, J), obldest_iter(G, C, K), oblink_iter(H, D, L), sprawdz_pk_iter(I, E, M), zroblistę_iter(T, O, U))/[P, Q, R, S]/[[]]/[O1]/ ([F, G, H, I]/[T])/ ([J, K, L, M]/[U]), modpart(fpt, V, C, D, E, po)/ (oblzap_iter(F, N, J), obldest_iter(G, C, K), oblink_iter(H, D, L), sprawdz_pk_iter(I, E, M))/[V]/[]/[]/ ([F, G, H, I]/[])/ ([J, K, L, M]/[]), modjaki(W, X, N, C, D, E, po)/ (oblzap_iter(F, N, J), obldest_iter(G, C, K), oblink_iter(H, D, L), sprawdz_pk_iter(I, E, M))/[W, X]/[]/[]/ ([F, G, H, I]/[])/ ([J, K, L, M]/[])]/[Y, Z, A1, B1]/[K1, L1, M1, N1]),
	goal(fpt(W,
		 X,
		 C1,
		 D1,
		 E1,
		 F1,
		 V,
		 G1,
		 H1,
		 I1,
		 na),
	     B,
	     Q1,
	     J1),
	D1=wym(_, _, [_|_]),
	oblzap_iter(K1, F1, L2),
	obldest_iter(L1, G1, M2),
	oblink_iter(M1, H1, N2),
	sprawdz_pk_iter(N1, I1, O2),
	wyjmijl(O1, D1, I2),
	do_sequence_of(P1,
		       [],
		       Q1,
		       V2,
		       [fps(_, _, _, R1, S1, T1, po)/ (oblzap_iter(U1, C2, Y1), obldest_iter(V1, R1, Z1), oblink_iter(W1, S1, A2), sprawdz_pk_iter(X1, T1, B2))/[]/[]/[]/ ([U1, V1, W1, X1]/[])/ ([Y1, Z1, A2, B2]/[]), fpm(_, _, _, C2, _, R1, S1, T1, po)/ (oblzap_iter(U1, C2, Y1), obldest_iter(V1, R1, Z1), oblink_iter(W1, S1, A2), sprawdz_pk_iter(X1, T1, B2))/[]/[]/[]/ ([U1, V1, W1, X1]/[])/ ([Y1, Z1, A2, B2]/[]), fw(D2, E2, F2, G2, H2, post, tak, R1, S1, T1, po)/ (oblzap_iter(U1, C2, Y1), obldest_iter(V1, R1, Z1), oblink_iter(W1, S1, A2), sprawdz_pk_iter(X1, T1, B2), oblwym_iter(J2, D2, K2))/[E2, F2, G2, H2]/[I2]/[P2]/ ([U1, V1, W1, X1]/[J2])/ ([Y1, Z1, A2, B2]/[K2]), modpart(fpt, V, R1, S1, T1, po)/ (oblzap_iter(U1, C2, Y1), obldest_iter(V1, R1, Z1), oblink_iter(W1, S1, A2), sprawdz_pk_iter(X1, T1, B2))/[V]/[]/[]/ ([U1, V1, W1, X1]/[])/ ([Y1, Z1, A2, B2]/[]), modjaki(W, X, C2, R1, S1, T1, po)/ (oblzap_iter(U1, C2, Y1), obldest_iter(V1, R1, Z1), oblink_iter(W1, S1, A2), sprawdz_pk_iter(X1, T1, B2))/[W, X]/[]/[]/ ([U1, V1, W1, X1]/[])/ ([Y1, Z1, A2, B2]/[])]/[L2, M2, N2, O2]/[Q2, R2, S2, T2]),
	wymagania_zamknij(P2),
	register(fpt(W,
		     X,
		     C1,
		     wym(D3, E3, bw),
		     E1,
		     Q2,
		     V,
		     R2,
		     S2,
		     T2,
		     F3),
		 U2,
		 V2,
		 ptm2,
		 
		 [ W2/fpm(X2, Y2, Z2, Y, A3, Z, A1, B1, po)
		 | B3
		 ],
		 C3),
	fpt(U2,
	    V2,
	    C3,
	    W,
	    X,
	    C1,
	    wym(D3, E3, bw),
	    E1,
	    Q2,
	    V,
	    R2,
	    S2,
	    T2,
	    F3).

fpm(R1, B, T1, U1, V1, W1, X1, A, N, O, P, po) :-
	do_sequence_of(Y1,
		       
		       [ C,
			 V/fps(Q, R, A, S, T, U, na)
		       | Z
		       ],
		       B,
		       C,
		       [fpm(_, _, M, _, A, D, E, F, po)/ (obldest_iter(G, D, J), oblink_iter(H, E, K), sprawdz_pk_iter(I, F, L))/[A]/[]/[]/ ([G, H, I]/[])/ ([J, K, L]/[]), fps(_, M, A, D, E, F, po)/ (obldest_iter(G, D, J), oblink_iter(H, E, K), sprawdz_pk_iter(I, F, L))/[A]/[]/[]/ ([G, H, I]/[])/ ([J, K, L]/[]), modpart(fpt, A, D, E, F, po)/ (obldest_iter(G, D, J), oblink_iter(H, E, K), sprawdz_pk_iter(I, F, L))/[A]/[]/[]/ ([G, H, I]/[])/ ([J, K, L]/[])]/[N, O, P]/[W, X, Y]),
	goal(fps(Q, R, A, S, T, U, na),
	     C,
	     A1,
	     V),
	R\= (mod),
	obldest_iter(W, S, L1),
	oblink_iter(X, T, M1),
	sprawdz_pk_iter(Y, U, N1),
	do_sequence_of(Z,
		       [],
		       A1,
		       S1,
		       [fpm(_, _, K1, _, A, B1, C1, D1, po)/ (obldest_iter(E1, B1, H1), oblink_iter(F1, C1, I1), sprawdz_pk_iter(G1, D1, J1))/[A]/[]/[]/ ([E1, F1, G1]/[])/ ([H1, I1, J1]/[]), fps(_, K1, A, B1, C1, D1, po)/ (obldest_iter(E1, B1, H1), oblink_iter(F1, C1, I1), sprawdz_pk_iter(G1, D1, J1))/[A]/[]/[]/ ([E1, F1, G1]/[])/ ([H1, I1, J1]/[]), modpart(fpt, A, B1, C1, D1, po)/ (obldest_iter(E1, B1, H1), oblink_iter(F1, C1, I1), sprawdz_pk_iter(G1, D1, J1))/[A]/[]/[]/ ([E1, F1, G1]/[])/ ([H1, I1, J1]/[])]/[L1, M1, N1]/[O1, P1, Q1]),
	register(fps(Q, mod, A, O1, P1, Q1, A2),
		 R1,
		 S1,
		 psm2,
		 
		 [ T1/fpm(U1, V1, W1, X1, A, N, O, P, po)
		 | Y1
		 ],
		 Z1),
	fps(R1,
	    S1,
	    Z1,
	    Q,
	    (mod),
	    A,
	    O1,
	    P1,
	    Q1,
	    A2).

fpmpt(G, H, I, A, B, J, K, C, D, E, F, na) :-
	register(fw(prepadjp(A, B),
		    M,
		    N,
		    O,
		    P,
		    Q,
		    C,
		    D,
		    E,
		    F,
		    R),
		 G,
		 H,
		 wyp1,
		 
		 [ I/fpmpt(A, B, J, K, C, D, E, F, na)
		 ],
		 L),
	fw(G,
	   H,
	   L,
	   prepadjp(A, B),
	   M,
	   N,
	   O,
	   P,
	   Q,
	   C,
	   D,
	   E,
	   F,
	   R).

fpmpt(E, F, G, H, pop, I, J, A, B, C, D, na) :-
	register(fl(L,
		    M,
		    N,
		    O,
		    A,
		    B,
		    C,
		    D,
		    P),
		 E,
		 F,
		 lu14,
		 
		 [ G/fpmpt(H, pop, I, J, A, B, C, D, na)
		 ],
		 K),
	fl(E,
	   F,
	   K,
	   L,
	   M,
	   N,
	   O,
	   A,
	   B,
	   C,
	   D,
	   P).

terminal(A, B, C, morf(D, się, qub)) :-
	register(fw(sie,
		    F,
		    G,
		    H,
		    I,
		    J,
		    K,
		    neut,
		    ni,
		    (0| 0),
		    L),
		 A,
		 B,
		 wy7,
		 [C/terminal(morf(D, się, qub))],
		 E),
	fw(A,
	   B,
	   E,
	   sie,
	   F,
	   G,
	   H,
	   I,
	   J,
	   K,
	   neut,
	   ni,
	   (0| 0),
	   L).

terminal(A, B, C, morf(D, się, qub)) :-
	register(fw(subj(np(mian)),
		    F,
		    G,
		    r(mn(n), nmo(np(n)))/poj,
		    3,
		    H,
		    I,
		    neut,
		    ni,
		    (0| 0),
		    J),
		 A,
		 B,
		 wy8,
		 [C/terminal(morf(D, się, qub))],
		 E),
	fw(A,
	   B,
	   E,
	   subj(np(mian)),
	   F,
	   G,
	   r(mn(n), nmo(np(n)))/poj,
	   3,
	   H,
	   I,
	   neut,
	   ni,
	   (0| 0),
	   J).

terminal(D, E, F, morf(G, A, qub)) :-
	slowpart(A, B),
	member(C, B),
	register(modpart(C, I, neut, ni, (0| 0), J),
		 D,
		 E,
		 mp1,
		 [F/terminal(morf(G, A, qub))],
		 H),
	modpart(D,
		E,
		H,
		C,
		I,
		neut,
		ni,
		(0| 0),
		J).

terminal(C, D, E, morf(F, A, qub)) :-
	member(B, [pyt, pz]),
	member(A, [czy, czyż, czyżby, azali, azaliż, li]),
	register(modpart(fin, H, B, ni, (0| 0), I),
		 C,
		 D,
		 mp2,
		 [E/terminal(morf(F, A, qub))],
		 G),
	modpart(C, D, G, fin, H, B, ni, (0| 0), I).

terminal(G, D, I, morf(J, A, brev:B)) :-
	slowskr(A, _, B, E, qub),
	slowpart(A, C),
	member(F, C),
	optional(K,
		 [],
		 D,
		 H,
		 terminal(morf('.', _, interp)),
		 { E\=kon
		 },
		 { E\=nkon
		 }),
	register(modpart(F, M, neut, ni, (0| 0), N),
		 G,
		 H,
		 mp3,
		 
		 [ I/terminal(morf(J, A, brev:B))
		 | K
		 ],
		 L),
	modpart(G,
		H,
		L,
		F,
		M,
		neut,
		ni,
		(0| 0),
		N).

terminal(E, B, G, morf(H, co, prep:A)) :-
	przypadki(A, bier),
	goal(terminal(morf(J, C, adv:sup)), B, F, I),
	member(C, [wysoko, mało]),
	member(D, [fno, flicz, fpm, fin]),
	register(modpart(D, L, neut, ni, (0| 0), M),
		 E,
		 F,
		 mp5,
		 
		 [ G/terminal(morf(H, co, prep:A)),
		   B,
		   I/terminal(morf(J, C, adv:sup))
		 ],
		 K),
	modpart(E,
		F,
		K,
		D,
		L,
		neut,
		ni,
		(0| 0),
		M).

terminal(E, B, G, morf(H, co, prep:A)) :-
	przypadki(A, bier),
	goal(terminal(morf(J, C, adv:com)), B, F, I),
	member(C, [dużo]),
	member(D, [fin]),
	register(modpart(D, L, neut, ni, (0| 0), M),
		 E,
		 F,
		 mp6,
		 
		 [ G/terminal(morf(H, co, prep:A)),
		   B,
		   I/terminal(morf(J, C, adv:com))
		 ],
		 K),
	modpart(E,
		F,
		K,
		D,
		L,
		neut,
		ni,
		(0| 0),
		M).

terminal(E, A, G, morf(H, nie, qub)) :-
	goal(terminal(morf(J, B, qub)), A, F, I),
	member(B, [byle, całkiem, dosyć, dość, nazbyt, tylko, wprost, za]),
	slowpart(B, C),
	member(D, C),
	register(modpart(D, L, neut, ni, (0| 0), M),
		 E,
		 F,
		 mp7,
		 
		 [ G/terminal(morf(H, nie, qub)),
		   A,
		   I/terminal(morf(J, B, qub))
		 ],
		 K),
	modpart(E,
		F,
		K,
		D,
		L,
		neut,
		ni,
		(0| 0),
		M).

terminal(B, C, D, morf(E, A, adv:pos)) :-
	member(A, [znacznie, dużo]),
	register(modpart(flicz, G, neut, ni, (0| 0), H),
		 B,
		 C,
		 mp8,
		 [D/terminal(morf(E, A, adv:pos))],
		 F),
	modpart(B, C, F, flicz, G, neut, ni, (0| 0), H).

terminal(B, C, D, morf(E, A, adv)) :-
	member(A, [donikąd]),
	register(modpart(fno, G, neut, ni, (0| 0), H),
		 B,
		 C,
		 mp9,
		 [D/terminal(morf(E, A, adv))],
		 F),
	modpart(B, C, F, fno, G, neut, ni, (0| 0), H).

terminal(I, J, K, morf(L, D, subst:A:B:C)) :-
	liczba(A, G),
	przypadki(B, E),
	rodzaj(C, F),
	rekcja_nominalna(D, H),
	register(formarzecz(E, F/G, H, N),
		 I,
		 J,
		 n_rz1,
		 
		 [ K/terminal(morf(L, D, subst:A:B:C))
		 ],
		 M),
	formarzecz(I,
		   J,
		   M,
		   E,
		   F/G,
		   H,
		   N).

terminal(I, J, K, morf(L, D, depr:A:B:C)) :-
	liczba(A, G),
	przypadki(B, E),
	rodzaj(C, F),
	rekcja_nominalna(D, H),
	register(formarzecz(E, F/G, H, N),
		 I,
		 J,
		 n_rz2,
		 
		 [ K/terminal(morf(L, D, depr:A:B:C))
		 ],
		 M),
	formarzecz(I,
		   J,
		   M,
		   E,
		   F/G,
		   H,
		   N).

terminal(I, J, K, morf(L, D, ger:A:B:C:M:N)) :-
	liczba(A, G),
	przypadki(B, E),
	rodzaj(C, F),
	rekcja_gerundialna(D, H),
	register(formarzecz(E, F/G, H, P),
		 I,
		 J,
		 n_rz3,
		 
		 [ K/terminal(morf(L, D, ger:A:B:C:M:N))
		 ],
		 O),
	formarzecz(I,
		   J,
		   O,
		   E,
		   F/G,
		   H,
		   P).

terminal(D, E, F, morf(G, H, siebie:A)) :-
	przypadki(A, B),
	rekcja_pusta(C),
	register(formarzecz(B, J/K, C, L),
		 D,
		 E,
		 n_rz4,
		 [F/terminal(morf(G, H, siebie:A))],
		 I),
	formarzecz(D,
		   E,
		   I,
		   B,
		   J/K,
		   C,
		   L).

terminal(O, E, Q, morf(R, D, subst:A:B:C)) :-
	liczba(A, H),
	przypadki(B, J),
	rodzaj(C, L),
	rekcja_nominalna(D, N),
	goal(terminal(morf(-, -, interp)), E, F, S),
	goal(terminal(morf(U,
			   V,
			   subst:G:I:K)),
	     F,
	     P,
	     T),
	liczba(G, H),
	przypadki(I, J),
	rodzaj(K, M),
	L=M,
	register(formarzecz(J, L/H, N, X),
		 O,
		 P,
		 n_rz5,
		 
		 [ Q/terminal(morf(R, D, subst:A:B:C)),
		   E,
		   S/terminal(morf(-, -, interp)),
		   F,
		   T/terminal(morf(U, V, subst:G:I:K))
		 ],
		 W),
	formarzecz(O,
		   P,
		   W,
		   J,
		   L/H,
		   N,
		   X).

terminal(L, F, N, morf(O, A, brev:B)) :-
	slowskr(A,
		_,
		B,
		G,
		subst:C:D:E),
	liczba(C, J),
	przypadki(D, H),
	rodzaj(E, I),
	rekcja_nominalna(A, K),
	optional(P,
		 [],
		 F,
		 M,
		 terminal(morf('.', _, interp)),
		 { G\=kon
		 },
		 { G\=nkon
		 }),
	register(formarzecz(H, I/J, K, R),
		 L,
		 M,
		 n_rz6,
		 
		 [ N/terminal(morf(O, A, brev:B))
		 | P
		 ],
		 Q),
	formarzecz(L,
		   M,
		   Q,
		   H,
		   I/J,
		   K,
		   R).

terminal(H, D, J, morf(B, A, brev:C)) :-
	slowskr(A, B, C, E, ini),
	member(F, [mian, dop, cel, bier, narz, miej]),
	optional(K,
		 [],
		 D,
		 I,
		 terminal(morf('.', _, interp)),
		 { E\=kon
		 },
		 { E\=nkon
		 }),
	rekcja_zablokowana(G),
	register(formarzecz(F, M/poj, G, N),
		 H,
		 I,
		 n_rz7,
		 
		 [ J/terminal(morf(B, A, brev:C))
		 | K
		 ],
		 L),
	formarzecz(H,
		   I,
		   L,
		   F,
		   M/poj,
		   G,
		   N).

terminal(I, J, K, morf(L, M, ppron12:A:B:C:D)) :-
	liczba(A, G),
	przypadki(B, E),
	rodzaj(C, F),
	osoba(D, H),
	register(zaimos(E, F/G, H, O),
		 I,
		 J,
		 n_zo1,
		 
		 [ K/terminal(morf(L, M, ppron12:A:B:C:D))
		 ],
		 N),
	zaimos(I,
	       J,
	       N,
	       E,
	       F/G,
	       H,
	       O).

terminal(I, J, K, morf(L, M, ppron12:A:B:C:D:N)) :-
	liczba(A, G),
	przypadki(B, E),
	rodzaj(C, F),
	osoba(D, H),
	register(zaimos(E, F/G, H, P),
		 I,
		 J,
		 n_zo2,
		 
		 [ K/terminal(morf(L, M, ppron12:A:B:C:D:N))
		 ],
		 O),
	zaimos(I,
	       J,
	       O,
	       E,
	       F/G,
	       H,
	       P).

terminal(I, J, K, morf(L, M, ppron3:A:B:C:D:N)) :-
	liczba(A, G),
	przypadki(B, E),
	rodzaj(C, F),
	osoba(D, H),
	register(zaimos(E, F/G, H, P),
		 I,
		 J,
		 n_zo3,
		 
		 [ K/terminal(morf(L, M, ppron3:A:B:C:D:N))
		 ],
		 O),
	zaimos(I,
	       J,
	       O,
	       E,
	       F/G,
	       H,
	       P).

terminal(B, C, D, morf(E, A, conj)) :-
	równe(A, [nie, tak, zarówno]),
	register(spójnik(rl, A, ni, G),
		 B,
		 C,
		 sr1,
		 [D/terminal(morf(E, A, conj))],
		 F),
	spójnik(B, C, F, rl, A, ni, G).

terminal(B, A, D, morf(E, nie, conj)) :-
	goal(terminal(morf(G, tylko, conj)), A, C, F),
	register(spójnik(rl, nietylko, ni, I),
		 B,
		 C,
		 sr2,
		 
		 [ D/terminal(morf(E, nie, conj)),
		   A,
		   F/terminal(morf(G, tylko, conj))
		 ],
		 H),
	spójnik(B, C, H, rl, nietylko, ni, I).

terminal(B, C, D, morf(E, A, conj)) :-
	równe(A, [ale, lecz]),
	register(spójnik(rp, nie, ni, G),
		 B,
		 C,
		 sr3,
		 [D/terminal(morf(E, A, conj))],
		 F),
	spójnik(B, C, F, rp, nie, ni, G).

terminal(D, B, F, morf(G, A, conj)) :-
	równe(A, [ale, lecz]),
	goal(terminal(morf(I, C, qub)), B, E, H),
	równe(C, [i, również, także]),
	register(spójnik(rp, nietylko, ni, K),
		 D,
		 E,
		 sr4,
		 
		 [ F/terminal(morf(G, A, conj)),
		   B,
		   H/terminal(morf(I, C, qub))
		 ],
		 J),
	spójnik(D, E, J, rp, nietylko, ni, K).

terminal(B, C, D, morf(E, jak, conj)) :-
	równe(A, [tak, zarówno]),
	register(spójnik(rp, A, ni, G),
		 B,
		 C,
		 sr5,
		 [D/terminal(morf(E, jak, conj))],
		 F),
	spójnik(B, C, F, rp, A, ni, G).

terminal(D, A, F, morf(G, jak, conj)) :-
	goal(terminal(morf(I, B, qub)), A, E, H),
	równe(C, [tak, zarówno]),
	równe(B, [i, też]),
	register(spójnik(rp, C, ni, K),
		 D,
		 E,
		 sr6,
		 
		 [ F/terminal(morf(G, jak, conj)),
		   A,
		   H/terminal(morf(I, B, qub))
		 ],
		 J),
	spójnik(D, E, J, rp, C, ni, K).

terminal(B, C, D, morf(E, A, conj)) :-
	równe(A, [a, ale, lecz]),
	register(spójnik(rc, a, ni, G),
		 B,
		 C,
		 sr10,
		 [D/terminal(morf(E, A, conj))],
		 F),
	spójnik(B, C, F, rc, a, ni, G).

terminal(D, B, F, morf(G, A, conj)) :-
	równe(A, [a, ale, lecz]),
	goal(terminal(morf(I, C, qub)), B, E, H),
	równe(C, [i, nawet, również, także]),
	register(spójnik(rc, alei, ni, K),
		 D,
		 E,
		 sr11,
		 
		 [ F/terminal(morf(G, A, conj)),
		   B,
		   H/terminal(morf(I, C, qub))
		 ],
		 J),
	spójnik(D, E, J, rc, alei, ni, K).

terminal(A, B, C, morf(D, natomiast, conj)) :-
	register(spójnik(rc, natomiast, ni, F),
		 A,
		 B,
		 sr12,
		 [C/terminal(morf(D, natomiast, conj))],
		 E),
	spójnik(A, B, E, rc, natomiast, ni, F).

terminal(C, B, E, morf(F, A, conj)) :-
	równe(A, [a, ale]),
	goal(terminal(morf(H, nie, qub)), B, D, G),
	register(spójnik(rc, nie, ni, J),
		 C,
		 D,
		 sr13,
		 
		 [ E/terminal(morf(F, A, conj)),
		   B,
		   G/terminal(morf(H, nie, qub))
		 ],
		 I),
	spójnik(C, D, I, rc, nie, ni, J).

terminal(B, A, D, morf(E, nie, qub)) :-
	goal(terminal(morf(G, zaś, conj)), A, C, F),
	register(spójnik(rc, nie, ni, I),
		 B,
		 C,
		 sr14,
		 
		 [ D/terminal(morf(E, nie, qub)),
		   A,
		   F/terminal(morf(G, zaś, conj))
		 ],
		 H),
	spójnik(B, C, H, rc, nie, ni, I).

terminal(B, C, D, morf(E, A, conj)) :-
	member(A, [czyli, mianowicie]),
	register(spójnik(rc, A, ni, G),
		 B,
		 C,
		 sr50,
		 [D/terminal(morf(E, A, conj))],
		 F),
	spójnik(B, C, F, rc, A, ni, G).

terminal(B, A, D, morf(E, a, conj)) :-
	goal(terminal(morf(G, mianowicie, conj)), A, C, F),
	register(spójnik(rc, mianowicie, ni, I),
		 B,
		 C,
		 sr51,
		 
		 [ D/terminal(morf(E, a, conj)),
		   A,
		   F/terminal(morf(G, mianowicie, conj))
		 ],
		 H),
	spójnik(B, C, H, rc, mianowicie, ni, I).

terminal(B, A, D, morf(E, a, conj)) :-
	goal(terminal(morf(G, raczej, qub)), A, C, F),
	register(spójnik(rc, raczej, ni, I),
		 B,
		 C,
		 sr52,
		 
		 [ D/terminal(morf(E, a, conj)),
		   A,
		   F/terminal(morf(G, raczej, qub))
		 ],
		 H),
	spójnik(B, C, H, rc, raczej, ni, I).

terminal(B, C, D, morf(E, A, conj)) :-
	równe(A, [natomiast, zaś]),
	register(spójnik(i(r, A), A, ni, G),
		 B,
		 C,
		 sr20,
		 [D/terminal(morf(E, A, conj))],
		 F),
	spójnik(B, C, F, i(r, A), A, ni, G).

terminal(C, D, E, morf(F, A, conj)) :-
	równe(A, [albo, bądź, i, lub]),
	równe(B, [sz, szk]),
	register(spójnik(B, A, ni, H),
		 C,
		 D,
		 sr21,
		 [E/terminal(morf(F, A, conj))],
		 G),
	spójnik(C, D, G, B, A, ni, H).

terminal(C, D, E, morf(F, A, conj)) :-
	równe(B, [sz, szk]),
	równe(A, [ani, ni]),
	register(spójnik(B, ani, ni, H),
		 C,
		 D,
		 sr22,
		 [E/terminal(morf(F, A, conj))],
		 G),
	spójnik(C, D, G, B, ani, ni, H).

terminal(C, D, E, morf(F, A, interp)) :-
	member(A, [',', ;]),
	równe(B, [sz, szk]),
	register(spójnik(B, przec, ni, H),
		 C,
		 D,
		 sr23,
		 [E/terminal(morf(F, A, interp))],
		 G),
	spójnik(C, D, G, B, przec, ni, H).

terminal(D, B, F, morf(G, A, conj)) :-
	równe(A, [albo, bądź, lub]),
	goal(terminal(morf(I, C, qub)), B, E, H),
	równe(C, [nawet, też]),
	register(spójnik(szk, A, ni, K),
		 D,
		 E,
		 sr24,
		 
		 [ F/terminal(morf(G, A, conj)),
		   B,
		   H/terminal(morf(I, C, qub))
		 ],
		 J),
	spójnik(D, E, J, szk, A, ni, K).

terminal(D, B, F, morf(G, A, conj)) :-
	równe(A, [ani, ni]),
	goal(terminal(morf(I, C, qub)), B, E, H),
	równe(C, [nawet, też]),
	register(spójnik(szk, ani, ni, K),
		 D,
		 E,
		 sr25,
		 
		 [ F/terminal(morf(G, A, conj)),
		   B,
		   H/terminal(morf(I, C, qub))
		 ],
		 J),
	spójnik(D, E, J, szk, ani, ni, K).

terminal(C, A, E, morf(F, i, conj)) :-
	goal(terminal(morf(H, B, qub)), A, D, G),
	równe(B, [nawet, także]),
	register(spójnik(szk, i, ni, J),
		 C,
		 D,
		 sr26,
		 
		 [ E/terminal(morf(F, i, conj)),
		   A,
		   G/terminal(morf(H, B, qub))
		 ],
		 I),
	spójnik(C, D, I, szk, i, ni, J).

terminal(A, B, C, morf(D, oraz, conj)) :-
	register(spójnik(szk, i, ni, F),
		 A,
		 B,
		 sr27,
		 [C/terminal(morf(D, oraz, conj))],
		 E),
	spójnik(A, B, E, szk, i, ni, F).

terminal(A, B, C, morf(D, czy, conj)) :-
	register(spójnik(szk, czy, ni, F),
		 A,
		 B,
		 sr49,
		 [C/terminal(morf(D, czy, conj))],
		 E),
	spójnik(A, B, E, szk, czy, ni, F).

terminal(B, A, D, morf(E, czy, conj)) :-
	goal(terminal(morf(G, też, qub)), A, C, F),
	register(spójnik(szk, czy, ni, I),
		 B,
		 C,
		 sr53,
		 
		 [ D/terminal(morf(E, czy, conj)),
		   A,
		   F/terminal(morf(G, też, qub))
		 ],
		 H),
	spójnik(B, C, H, szk, czy, ni, I).

terminal(C, D, E, morf(F, A, conj)) :-
	równe(B, [pl, pp]),
	równe(A, [dopóty, póty]),
	register(spójnik(B, dopóki, ni, H),
		 C,
		 D,
		 spoj22,
		 [E/terminal(morf(F, A, conj))],
		 G),
	spójnik(C, D, G, B, dopóki, ni, H).

terminal(C, D, E, morf(F, A, adv)) :-
	równe(B, [pl, pp]),
	równe(A, [wówczas, wtedy]),
	register(spójnik(B, gdy, ni, H),
		 C,
		 D,
		 spoj23,
		 [E/terminal(morf(F, A, adv))],
		 G),
	spójnik(C, D, G, B, gdy, ni, H).

terminal(B, C, D, morf(E, jednak, conj)) :-
	równe(A, [chociaż, choćby]),
	register(spójnik(pp, A, ni, G),
		 B,
		 C,
		 spoj24,
		 [D/terminal(morf(E, jednak, conj))],
		 F),
	spójnik(B, C, F, pp, A, ni, G).

terminal(C, A, E, morf(F, to, conj)) :-
	goal(terminal(morf(H, jednak, conj)), A, D, G),
	równe(B, [chociaż, choćby]),
	register(spójnik(pp, B, ni, J),
		 C,
		 D,
		 spoj25,
		 
		 [ E/terminal(morf(F, to, conj)),
		   A,
		   G/terminal(morf(H, jednak, conj))
		 ],
		 I),
	spójnik(C, D, I, pp, B, ni, J).

terminal(B, C, D, morf(E, to, conj)) :-
	równe(A, [chociaż, choćby, gdyby, jeśli]),
	register(spójnik(pp, A, ni, G),
		 B,
		 C,
		 spoj26,
		 [D/terminal(morf(E, to, conj))],
		 F),
	spójnik(B, C, F, pp, A, ni, G).

terminal(B, C, D, morf(E, A, comp)) :-
	równe(A, [albowiem, bo, gdyż]),
	register(spójnik(pc, bo, ni, G),
		 B,
		 C,
		 spoj27,
		 [D/terminal(morf(E, A, comp))],
		 F),
	spójnik(B, C, F, pc, bo, ni, G).

terminal(C, D, E, morf(F, A, conj)) :-
	równe(B, [pc, i(p, więc)]),
	równe(A, [przeto, więc, zatem]),
	register(spójnik(B, więc, ni, H),
		 C,
		 D,
		 spoj28,
		 [E/terminal(morf(F, A, conj))],
		 G),
	spójnik(C, D, G, B, więc, ni, H).

terminal(A, B, C, morf(D, toteż, conj)) :-
	register(spójnik(pc, więc, ni, F),
		 A,
		 B,
		 spoj29,
		 [C/terminal(morf(D, toteż, conj))],
		 E),
	spójnik(A, B, E, pc, więc, ni, F).

terminal(A, B, C, morf(D, to, conj)) :-
	register(spójnik(pc, to, ni, F),
		 A,
		 B,
		 spoj50,
		 [C/terminal(morf(D, to, conj))],
		 E),
	spójnik(A, B, E, pc, to, ni, F).

terminal(C, A, E, morf(F, a, conj)) :-
	goal(terminal(morf(H, B, conj)), A, D, G),
	równe(B, [przeto, więc, zatem]),
	register(spójnik(rc, więc, ni, J),
		 C,
		 D,
		 spoj48,
		 
		 [ E/terminal(morf(F, a, conj)),
		   A,
		   G/terminal(morf(H, B, conj))
		 ],
		 I),
	spójnik(C, D, I, rc, więc, ni, J).

terminal(B, C, D, morf(E, A, conj)) :-
	member(A, [względnie, tymczasem]),
	register(spójnik(rc, więc, ni, G),
		 B,
		 C,
		 spoj48,
		 [D/terminal(morf(E, A, conj))],
		 F),
	spójnik(B, C, F, rc, więc, ni, G).

terminal(A, B, C, morf(D, bowiem, comp)) :-
	register(spójnik(i(p, bowiem), bowiem, ni, F),
		 A,
		 B,
		 spoj30,
		 [C/terminal(morf(D, bowiem, comp))],
		 E),
	spójnik(A, B, E, i(p, bowiem), bowiem, ni, F).

terminal(A, B, C, morf(D, aż, comp)) :-
	register(spójnik(po, aż, ni, F),
		 A,
		 B,
		 spoj31,
		 [C/terminal(morf(D, aż, comp))],
		 E),
	spójnik(A, B, E, po, aż, ni, F).

terminal(B, C, D, morf(E, A, comp)) :-
	równe(A, [czy, jak, jakby, jakoby]),
	register(spójnik(po, A, ni, G),
		 B,
		 C,
		 spoj32,
		 [D/terminal(morf(E, A, comp))],
		 F),
	spójnik(B, C, F, po, A, ni, G).

terminal(B, C, D, morf(E, A, comp)) :-
	równe(A, [chociaż, choć]),
	register(spójnik(po, chociaż, ni, G),
		 B,
		 C,
		 spoj33,
		 [D/terminal(morf(E, A, comp))],
		 F),
	spójnik(B, C, F, po, chociaż, ni, G).

terminal(B, C, D, morf(E, A, comp)) :-
	równe(A, [chociażby, choćby]),
	register(spójnik(po, choćby, ni, G),
		 B,
		 C,
		 spoj35,
		 [D/terminal(morf(E, A, comp))],
		 F),
	spójnik(B, C, F, po, choćby, ni, G).

terminal(B, C, D, morf(E, A, comp)) :-
	równe(A, [dopóki, póki]),
	register(spójnik(po, dopóki, ni, G),
		 B,
		 C,
		 spoj36,
		 [D/terminal(morf(E, A, comp))],
		 F),
	spójnik(B, C, F, po, dopóki, ni, G).

terminal(B, C, D, morf(E, A, comp)) :-
	równe(A, [gdy, kiedy]),
	register(spójnik(po, gdy, ni, G),
		 B,
		 C,
		 spoj37,
		 [D/terminal(morf(E, A, comp))],
		 F),
	spójnik(B, C, F, po, gdy, ni, G).

terminal(B, C, D, morf(E, A, comp)) :-
	równe(A, [gdyby, jeśliby, jeżeliby]),
	register(spójnik(po, gdyby, ni, G),
		 B,
		 C,
		 spoj38,
		 [D/terminal(morf(E, A, comp))],
		 F),
	spójnik(B, C, F, po, gdyby, ni, G).

terminal(B, C, D, morf(E, A, comp)) :-
	równe(A, [jeśli, jeżeli]),
	register(spójnik(po, jeśli, ni, G),
		 B,
		 C,
		 spoj39,
		 [D/terminal(morf(E, A, comp))],
		 F),
	spójnik(B, C, F, po, jeśli, ni, G).

terminal(B, C, D, morf(E, A, comp)) :-
	równe(A, [ponieważ, skoro]),
	register(spójnik(po, ponieważ, ni, G),
		 B,
		 C,
		 spoj41,
		 [D/terminal(morf(E, A, comp))],
		 F),
	spójnik(B, C, F, po, ponieważ, ni, G).

terminal(B, C, D, morf(E, A, comp)) :-
	równe(A, [nim, zanim]),
	register(spójnik(po, zanim, ni, G),
		 B,
		 C,
		 spoj42,
		 [D/terminal(morf(E, A, comp))],
		 F),
	spójnik(B, C, F, po, zanim, ni, G).

terminal(B, C, D, morf(E, A, comp)) :-
	równe(A, [iż, że]),
	register(spójnik(po, że, ni, G),
		 B,
		 C,
		 spoj43,
		 [D/terminal(morf(E, A, comp))],
		 F),
	spójnik(B, C, F, po, że, ni, G).

terminal(B, C, D, morf(E, A, comp)) :-
	równe(A, [aby, ażeby, by, iżby, żeby]),
	register(spójnik(po, żeby, ni, G),
		 B,
		 C,
		 spoj44,
		 [D/terminal(morf(E, A, comp))],
		 F),
	spójnik(B, C, F, po, żeby, ni, G).

terminal(H, I, J, morf(K, D, psubst:A:B:C)) :-
	liczba(A, G),
	przypadki(B, E),
	rodzaj(C, F),
	register(zaimrzecz(D, E, F/G, M),
		 H,
		 I,
		 jel5,
		 
		 [ J/terminal(morf(K, D, psubst:A:B:C))
		 ],
		 L),
	zaimrzecz(H,
		  I,
		  L,
		  D,
		  E,
		  F/G,
		  M).

terminal(H, I, J, morf(K, D, padj:A:B:C:pos)) :-
	liczba(A, G),
	przypadki(B, E),
	rodzaj(C, F),
	register(zaimprzym(D, E, F/G, M),
		 H,
		 I,
		 jel6,
		 
		 [ J/terminal(morf(K, D, padj:A:B:C:pos))
		 ],
		 L),
	zaimprzym(H,
		  I,
		  L,
		  D,
		  E,
		  F/G,
		  M).

terminal(K, L, M, morf(N, E, adj:A:B:C:D)) :-
	liczba(A, H),
	przypadki(B, F),
	rodzaj(C, G),
	stopien(D, I),
	rekcja_przymiotnikowa(E, J),
	register(formaprzym(F, G/H, I, J, P),
		 K,
		 L,
		 n_pt1,
		 
		 [ M/terminal(morf(N, E, adj:A:B:C:D))
		 ],
		 O),
	formaprzym(K,
		   L,
		   O,
		   F,
		   G/H,
		   I,
		   J,
		   P).

terminal(H, A, J, morf(K, L, adja)) :-
	goal(terminal(morf(-, -, interp)), A, B, M),
	goal(formaprzym(C, D/E, F, G, na),
	     B,
	     I,
	     N),
	register(formaprzym(C, D/E, F, G, P),
		 H,
		 I,
		 n_pt2,
		 
		 [ J/terminal(morf(K, L, adja)),
		   A,
		   M/terminal(morf(-, -, interp)),
		   B,
		   N/formaprzym(C, D/E, F, G, na)
		 ],
		 O),
	formaprzym(H,
		   I,
		   O,
		   C,
		   D/E,
		   F,
		   G,
		   P).

terminal(B, C, D, morf(E, F, adjp)) :-
	rekcja_zablokowana(A),
	register(formaprzym(pop, H/I, row, A, J),
		 B,
		 C,
		 n_pt7,
		 [D/terminal(morf(E, F, adjp))],
		 G),
	formaprzym(B,
		   C,
		   G,
		   pop,
		   H/I,
		   row,
		   A,
		   J).

terminal(I, J, K, morf(L, D, ppas:A:B:C:M)) :-
	liczba(A, G),
	przypadki(B, E),
	rodzaj(C, F),
	rekcja_ppas(D, H),
	register(formaprzym(E, F/G, row, H, O),
		 I,
		 J,
		 n_pt3,
		 
		 [ K/terminal(morf(L, D, ppas:A:B:C:M))
		 ],
		 N),
	formaprzym(I,
		   J,
		   N,
		   E,
		   F/G,
		   row,
		   H,
		   O).

terminal(I, J, K, morf(L, D, pact:A:B:C:M)) :-
	liczba(A, G),
	przypadki(B, E),
	rodzaj(C, F),
	rekcja_pact(D, H),
	register(formaprzym(E, F/G, row, H, O),
		 I,
		 J,
		 n_pt4,
		 
		 [ K/terminal(morf(L, D, pact:A:B:C:M))
		 ],
		 N),
	formaprzym(I,
		   J,
		   N,
		   E,
		   F/G,
		   row,
		   H,
		   O).

terminal(D, E, F, morf(G, A, adjc)) :-
	rodzaj(m1.m2.m3, B),
	rekcja_przymiotnikowa(A, C),
	register(formaprzym(mian, B/poj, row, C, I),
		 D,
		 E,
		 n_pt5,
		 [F/terminal(morf(G, A, adjc))],
		 H),
	formaprzym(D,
		   E,
		   H,
		   mian,
		   B/poj,
		   row,
		   C,
		   I).

terminal(M, A, O, morf(B, G, adj:C:D:E:F)) :-
	goal(terminal(morf('.', Q, interp)), A, N, P),
	same_cyfry(B),
	liczba(C, J),
	przypadki(D, H),
	rodzaj(E, I),
	stopien(F, K),
	rekcja_przymiotnikowa(G, L),
	register(formaprzym(H,
			    I/J,
			    K,
			    L,
			    S),
		 M,
		 N,
		 n_pt6,
		 
		 [ O/terminal(morf(B, G, adj:C:D:E:F)),
		   A,
		   P/terminal(morf('.', Q, interp))
		 ],
		 R),
	formaprzym(M,
		   N,
		   R,
		   H,
		   I/J,
		   K,
		   L,
		   S).

terminal(P, A, R, morf(D, J, adj:F:G:H:I)) :-
	goal(terminal(morf(B, T, interp)), A, C, S),
	member(B, ['.', :]),
	goal(terminal(morf(E, V, num:pl:nom:f:W)),
	     C,
	     Q,
	     U),
	same_cyfry(D),
	same_cyfry(E),
	liczba(F, M),
	przypadki(G, K),
	rodzaj(H, L),
	stopien(I, N),
	rekcja_przymiotnikowa(J, O),
	register(formaprzym(K,
			    L/M,
			    N,
			    O,
			    Y),
		 P,
		 Q,
		 n_pt8,
		 
		 [ R/terminal(morf(D, J, adj:F:G:H:I)),
		   A,
		   S/terminal(morf(B, T, interp)),
		   C,
		   U/terminal(morf(E, V, num:pl:nom:f:W))
		 ],
		 X),
	formaprzym(P,
		   Q,
		   X,
		   K,
		   L/M,
		   N,
		   O,
		   Y).

terminal(N, G, P, morf(Q, A, brev:B)) :-
	slowskr(A,
		_,
		B,
		H,
		adj:C:D:E:F),
	liczba(C, K),
	przypadki(D, I),
	rodzaj(E, J),
	stopien(F, L),
	rekcja_przymiotnikowa(A, M),
	optional(R,
		 [],
		 G,
		 O,
		 terminal(morf('.', _, interp)),
		 { H\=kon
		 },
		 { H\=nkon
		 }),
	register(formaprzym(I,
			    J/K,
			    L,
			    M,
			    T),
		 N,
		 O,
		 n_pt9,
		 
		 [ P/terminal(morf(Q, A, brev:B))
		 | R
		 ],
		 S),
	formaprzym(N,
		   O,
		   S,
		   I,
		   J/K,
		   L,
		   M,
		   T).

terminal(K, L, M, morf(N, E, num:A:B:C:D)) :-
	liczba(A, H),
	przypadki(B, F),
	rodzaj(C, G),
	akomodacyjnosc(D, I),
	klasa_licz(E, J),
	register(formalicz(F, G/H, I, J, P),
		 K,
		 L,
		 n_li,
		 
		 [ M/terminal(morf(N, E, num:A:B:C:D))
		 ],
		 O),
	formalicz(K,
		  L,
		  O,
		  F,
		  G/H,
		  I,
		  J,
		  P).

terminal(A, B, C, morf(D, E, dig)) :-
	register(formalicz(G, H/I, J, neut, K),
		 A,
		 B,
		 n_li2,
		 [C/terminal(morf(D, E, dig))],
		 F),
	formalicz(A,
		  B,
		  F,
		  G,
		  H/I,
		  J,
		  neut,
		  K).

terminal(J, K, L, morf(M, E, fin:D:C:A)) :-
	aspekt(A, B),
	czas(fin, B, F),
	osoba(C, H),
	liczba(D, G),
	rekcja_finitywna(E, I),
	register(formaczas(os,
			   B,
			   F,
			   ozn,
			   O/G,
			   H,
			   I,
			   tak,
			   P),
		 J,
		 K,
		 n_cz4,
		 
		 [ L/terminal(morf(M, E, fin:D:C:A))
		 ],
		 N),
	formaczas(J,
		  K,
		  N,
		  os,
		  B,
		  F,
		  ozn,
		  O/G,
		  H,
		  I,
		  tak,
		  P).

terminal(F, G, H, morf(I, być, aglt:A:B:J:K)) :-
	liczba(A, C),
	osoba(B, D),
	rekcja_finitywna(być, E),
	register(formaczas(os,
			   M,
			   N,
			   ozn,
			   O/C,
			   D,
			   E,
			   tak,
			   P),
		 F,
		 G,
		 n_cz4b,
		 
		 [ H/terminal(morf(I, być, aglt:A:B:J:K))
		 ],
		 L),
	formaczas(F,
		  G,
		  L,
		  os,
		  M,
		  N,
		  ozn,
		  O/C,
		  D,
		  E,
		  tak,
		  P).

terminal(F, G, H, morf(I, być, bedzie:B:A:imperf)) :-
	osoba(A, D),
	liczba(B, C),
	rekcja_finitywna(być, E),
	register(formaczas(os,
			   nd,
			   przy,
			   ozn,
			   K/C,
			   D,
			   E,
			   tak,
			   L),
		 F,
		 G,
		 n_cz5,
		 
		 [ H/terminal(morf(I, być, bedzie:B:A:imperf))
		 ],
		 J),
	formaczas(F,
		  G,
		  J,
		  os,
		  nd,
		  przy,
		  ozn,
		  K/C,
		  D,
		  E,
		  tak,
		  L).

terminal(D, E, F, morf(G, B, inf:A)) :-
	aspekt(A, nd),
	rekcja_finitywna(B, C),
	register(przyzlo(I, J, C, K),
		 D,
		 E,
		 n_czp1,
		 [F/terminal(morf(G, B, inf:A))],
		 H),
	przyzlo(D, E, H, I, J, C, K).

terminal(I, J, K, morf(L, E, praet:C:D:A)) :-
	asagl(A, B, nagl),
	aspekt(B, nd),
	liczba(C, G),
	rodzaj(D, F),
	rekcja_finitywna(E, H),
	register(przyzlo(N, F/G, H, O),
		 I,
		 J,
		 n_czp2,
		 
		 [ K/terminal(morf(L, E, praet:C:D:A))
		 ],
		 M),
	przyzlo(I,
		J,
		M,
		N,
		F/G,
		H,
		O).

terminal(H, D, J, morf(K, być, bedzie:B:A:imperf)) :-
	osoba(A, F),
	liczba(B, C),
	goal(przyzlo(M, E/C, G, na),
	     D,
	     I,
	     L),
	register(formaczas(os,
			   nd,
			   przy,
			   ozn,
			   E/C,
			   F,
			   G,
			   tak,
			   O),
		 H,
		 I,
		 n_cz6,
		 
		 [ J/terminal(morf(K, być, bedzie:B:A:imperf)),
		   D,
		   L/przyzlo(M, E/C, G, na)
		 ],
		 N),
	formaczas(H,
		  I,
		  N,
		  os,
		  nd,
		  przy,
		  ozn,
		  E/C,
		  F,
		  G,
		  tak,
		  O).

terminal(I, A, K, morf(L, być, bedzie:C:B:imperf)) :-
	goal(terminal(morf(N, się, qub)), A, E, M),
	osoba(B, G),
	liczba(C, D),
	goal(przyzlo(s, F/D, H, na), E, J, O),
	register(formaczas1(n,
			    os,
			    nd,
			    przy,
			    ozn,
			    F/D,
			    G,
			    H,
			    Q),
		 I,
		 J,
		 n_cz8,
		 
		 [ K/terminal(morf(L, być, bedzie:C:B:imperf)),
		   A,
		   M/terminal(morf(N, się, qub)),
		   E,
		   O/przyzlo(s, F/D, H, na)
		 ],
		 P),
	formaczas1(I,
		   J,
		   P,
		   n,
		   os,
		   nd,
		   przy,
		   ozn,
		   F/D,
		   G,
		   H,
		   Q).

terminal(J, K, L, morf(M, E, praet:C:D:A)) :-
	asagl(A, B, nagl),
	aspekt(B, F),
	liczba(C, H),
	rodzaj(D, G),
	rekcja_finitywna(E, I),
	register(formaczas(os,
			   F,
			   prze,
			   ozn,
			   G/H,
			   3,
			   I,
			   tak,
			   O),
		 J,
		 K,
		 n_cz10,
		 
		 [ L/terminal(morf(M, E, praet:C:D:A))
		 ],
		 N),
	formaczas(J,
		  K,
		  N,
		  os,
		  F,
		  prze,
		  ozn,
		  G/H,
		  3,
		  I,
		  tak,
		  O).

terminal(M, F, O, morf(P, E, praet:C:D:A)) :-
	asagl(A, B, agl),
	aspekt(B, H),
	liczba(C, J),
	rodzaj(D, I),
	rekcja_finitywna(E, L),
	goal(terminal(morf(R,
			   być,
			   aglt:C:G:S:T)),
	     F,
	     N,
	     Q),
	osoba(G, K),
	register(formaczas(os,
			   H,
			   prze,
			   ozn,
			   I/J,
			   K,
			   L,
			   tak,
			   V),
		 M,
		 N,
		 n_cz11,
		 
		 [ O/terminal(morf(P, E, praet:C:D:A)),
		   F,
		   Q/terminal(morf(R, być, aglt:C:G:S:T))
		 ],
		 U),
	formaczas(M,
		  N,
		  U,
		  os,
		  H,
		  prze,
		  ozn,
		  I/J,
		  K,
		  L,
		  tak,
		  V).

terminal(M, C, O, morf(P, być, aglt:B:A:Q:R)) :-
	osoba(A, K),
	goal(terminal(morf(T, G, praet:B:F:D)),
	     C,
	     N,
	     S),
	asagl(D, E, agl),
	aspekt(E, H),
	liczba(B, J),
	rodzaj(F, I),
	rekcja_finitywna(G, L),
	register(formaczas(os,
			   H,
			   prze,
			   ozn,
			   I/J,
			   K,
			   L,
			   tak,
			   V),
		 M,
		 N,
		 n_cz111,
		 
		 [ O/terminal(morf(P, być, aglt:B:A:Q:R)),
		   C,
		   S/terminal(morf(T, G, praet:B:F:D))
		 ],
		 U),
	formaczas(M,
		  N,
		  U,
		  os,
		  H,
		  prze,
		  ozn,
		  I/J,
		  K,
		  L,
		  tak,
		  V).

terminal(A, B, C, morf(D, by, qub)) :-
	register(condaglt(F, 3, G),
		 A,
		 B,
		 n_cza1,
		 [C/terminal(morf(D, by, qub))],
		 E),
	condaglt(A, B, E, F, 3, G).

terminal(F, A, H, morf(I, by, qub)) :-
	goal(terminal(morf(K,
			   być,
			   aglt:B:C:L:M)),
	     A,
	     G,
	     J),
	liczba(B, D),
	osoba(C, E),
	register(condaglt(D, E, O),
		 F,
		 G,
		 n_cza2,
		 
		 [ H/terminal(morf(I, by, qub)),
		   A,
		   J/terminal(morf(K, być, aglt:B:C:L:M))
		 ],
		 N),
	condaglt(F, G, N, D, E, O).

terminal(L, G, N, morf(O, E, praet:C:D:A)) :-
	asagl(A, B, nagl),
	aspekt(B, H),
	liczba(C, F),
	rodzaj(D, I),
	rekcja_finitywna(E, K),
	goal(condaglt(F, J, na), G, M, P),
	register(formaczas(os,
			   H,
			   R,
			   war,
			   I/F,
			   J,
			   K,
			   tak,
			   S),
		 L,
		 M,
		 n_cz12,
		 
		 [ N/terminal(morf(O, E, praet:C:D:A)),
		   G,
		   P/condaglt(F, J, na)
		 ],
		 Q),
	formaczas(L,
		  M,
		  Q,
		  os,
		  H,
		  R,
		  war,
		  I/F,
		  J,
		  K,
		  tak,
		  S).

terminal(N, A, P, morf(Q, F, praet:D:E:B)) :-
	goal(terminal(morf(S, się, qub)), A, I, R),
	asagl(B, C, nagl),
	aspekt(C, J),
	liczba(D, H),
	rodzaj(E, K),
	rekcja_finitywna(F, G),
	wyjmijwymaganie(sie, G, M),
	goal(condaglt(H, L, na), I, O, T),
	register(formaczas1(n,
			    os,
			    J,
			    V,
			    war,
			    K/H,
			    L,
			    M,
			    W),
		 N,
		 O,
		 n_cz14,
		 
		 [ P/terminal(morf(Q, F, praet:D:E:B)),
		   A,
		   R/terminal(morf(S, się, qub)),
		   I,
		   T/condaglt(H, L, na)
		 ],
		 U),
	formaczas1(N,
		   O,
		   U,
		   n,
		   os,
		   J,
		   V,
		   war,
		   K/H,
		   L,
		   M,
		   W).

terminal(M, A, O, morf(P, być, praet:B:C:imperf)) :-
	goal(condaglt(G, K, na), A, D, Q),
	goal(terminal(morf(S, H, praet:B:C:E)),
	     D,
	     N,
	     R),
	asagl(E, F, nagl),
	aspekt(F, I),
	liczba(B, G),
	rodzaj(C, J),
	rekcja_finitywna(H, L),
	register(formaczas(os,
			   I,
			   prze,
			   war,
			   J/G,
			   K,
			   L,
			   tak,
			   U),
		 M,
		 N,
		 n_cz37,
		 
		 [ O/terminal(morf(P, być, praet:B:C:imperf)),
		   A,
		   Q/condaglt(G, K, na),
		   D,
		   R/terminal(morf(S, H, praet:B:C:E))
		 ],
		 T),
	formaczas(M,
		  N,
		  T,
		  os,
		  I,
		  prze,
		  war,
		  J/G,
		  K,
		  L,
		  tak,
		  U).

terminal(I, J, K, morf(L, D, impt:C:B:A)) :-
	aspekt(A, E),
	osoba(B, G),
	liczba(C, F),
	rekcja_finitywna(D, H),
	register(formaczas(os,
			   E,
			   przy,
			   roz,
			   N/F,
			   G,
			   H,
			   tak,
			   O),
		 I,
		 J,
		 n_cz16,
		 
		 [ K/terminal(morf(L, D, impt:C:B:A))
		 ],
		 M),
	formaczas(I,
		  J,
		  M,
		  os,
		  E,
		  przy,
		  roz,
		  N/F,
		  G,
		  H,
		  tak,
		  O).

terminal(K, B, M, morf(N, A, qub)) :-
	member(A, [niech, niechaj, niechże, niechajże]),
	goal(terminal(morf(P, F, fin:C:D:E)),
	     B,
	     L,
	     O),
	(   C=sg,
	    D\=sec
	;   C=pl,
	    D=ter
	),
	aspekt(E, G),
	osoba(D, I),
	liczba(C, H),
	rekcja_finitywna(F, J),
	register(formaczas(os,
			   G,
			   przy,
			   roz,
			   R/H,
			   I,
			   J,
			   tak,
			   S),
		 K,
		 L,
		 n_cz17,
		 
		 [ M/terminal(morf(N, A, qub)),
		   B,
		   O/terminal(morf(P, F, fin:C:D:E))
		 ],
		 Q),
	formaczas(K,
		  L,
		  Q,
		  os,
		  G,
		  przy,
		  roz,
		  R/H,
		  I,
		  J,
		  tak,
		  S).

terminal(M, B, O, morf(P, A, qub)) :-
	member(A, [niech, niechaj, niechże, niechajże]),
	goal(terminal(morf(R, się, qub)), B, C, Q),
	goal(terminal(morf(T, G, fin:D:E:F)),
	     C,
	     N,
	     S),
	(   D=sg,
	    E\=sec
	;   D=pl,
	    E=ter
	),
	aspekt(F, I),
	osoba(E, K),
	liczba(D, J),
	rekcja_finitywna(G, H),
	wyjmijwymaganie(sie, H, L),
	register(formaczas1(n,
			    os,
			    I,
			    przy,
			    roz,
			    V/J,
			    K,
			    L,
			    W),
		 M,
		 N,
		 n_cz18,
		 
		 [ O/terminal(morf(P, A, qub)),
		   B,
		   Q/terminal(morf(R, się, qub)),
		   C,
		   S/terminal(morf(T, G, fin:D:E:F))
		 ],
		 U),
	formaczas1(M,
		   N,
		   U,
		   n,
		   os,
		   I,
		   przy,
		   roz,
		   V/J,
		   K,
		   L,
		   W).

terminal(H, B, J, morf(K, A, qub)) :-
	member(A, [niech, niechaj, niechże, niechajże]),
	goal(terminal(morf(M, być, bedzie:C:D:imperf)),
	     B,
	     I,
	     L),
	(   C=sg,
	    D\=sec
	;   C=pl,
	    D=ter
	),
	osoba(D, F),
	liczba(C, E),
	rekcja_finitywna(być, G),
	register(formaczas(os,
			   nd,
			   przy,
			   roz,
			   O/E,
			   F,
			   G,
			   tak,
			   P),
		 H,
		 I,
		 n_cz40,
		 
		 [ J/terminal(morf(K, A, qub)),
		   B,
		   L/terminal(morf(M, być, bedzie:C:D:imperf))
		 ],
		 N),
	formaczas(H,
		  I,
		  N,
		  os,
		  nd,
		  przy,
		  roz,
		  O/E,
		  F,
		  G,
		  tak,
		  P).

terminal(E, F, G, morf(H, B, imps:A)) :-
	aspekt(A, C),
	rekcja_niefinitywna(B, D),
	register(formaczas(bos,
			   C,
			   prze,
			   ozn,
			   J,
			   K,
			   D,
			   tak,
			   L),
		 E,
		 F,
		 n_cz19,
		 [G/terminal(morf(H, B, imps:A))],
		 I),
	formaczas(E,
		  F,
		  I,
		  bos,
		  C,
		  prze,
		  ozn,
		  J,
		  K,
		  D,
		  tak,
		  L).

terminal(F, A, H, morf(I, C, imps:B)) :-
	goal(terminal(morf(K, by, qub)), A, G, J),
	aspekt(B, D),
	rekcja_niefinitywna(C, E),
	register(formaczas(bos,
			   D,
			   M,
			   war,
			   N,
			   O,
			   E,
			   tak,
			   P),
		 F,
		 G,
		 n_cz20,
		 
		 [ H/terminal(morf(I, C, imps:B)),
		   A,
		   J/terminal(morf(K, by, qub))
		 ],
		 L),
	formaczas(F,
		  G,
		  L,
		  bos,
		  D,
		  M,
		  war,
		  N,
		  O,
		  E,
		  tak,
		  P).

terminal(F, A, H, morf(I, by, qub)) :-
	goal(terminal(morf(K, C, imps:B)),
	     A,
	     G,
	     J),
	aspekt(B, D),
	rekcja_niefinitywna(C, E),
	register(formaczas(bos,
			   D,
			   M,
			   war,
			   N,
			   O,
			   E,
			   tak,
			   P),
		 F,
		 G,
		 n_cz21,
		 
		 [ H/terminal(morf(I, by, qub)),
		   A,
		   J/terminal(morf(K, C, imps:B))
		 ],
		 L),
	formaczas(F,
		  G,
		  L,
		  bos,
		  D,
		  M,
		  war,
		  N,
		  O,
		  E,
		  tak,
		  P).

terminal(H, A, J, morf(K, D, imps:C)) :-
	goal(terminal(morf(M, się, qub)), A, B, L),
	goal(terminal(morf(by, by, qub)), B, I, N),
	aspekt(C, F),
	rekcja_niefinitywna(D, E),
	wyjmijwymaganie(sie, E, G),
	register(formaczas1(n,
			    bos,
			    F,
			    P,
			    war,
			    Q,
			    R,
			    G,
			    S),
		 H,
		 I,
		 n_cz22,
		 
		 [ J/terminal(morf(K, D, imps:C)),
		   A,
		   L/terminal(morf(M, się, qub)),
		   B,
		   N/terminal(morf(by, by, qub))
		 ],
		 O),
	formaczas1(H,
		   I,
		   O,
		   n,
		   bos,
		   F,
		   P,
		   war,
		   Q,
		   R,
		   G,
		   S).

terminal(H, A, J, morf(K, by, qub)) :-
	goal(terminal(morf(M, się, qub)), A, B, L),
	goal(terminal(morf(O, D, imps:C)),
	     B,
	     I,
	     N),
	aspekt(C, F),
	fail,
	rekcja_niefinitywna(D, E),
	wyjmijwymaganie(sie, E, G),
	register(formaczas1(n,
			    bos,
			    F,
			    Q,
			    war,
			    R,
			    S,
			    G,
			    T),
		 H,
		 I,
		 n_cz23,
		 
		 [ J/terminal(morf(K, by, qub)),
		   A,
		   L/terminal(morf(M, się, qub)),
		   B,
		   N/terminal(morf(O, D, imps:C))
		 ],
		 P),
	formaczas1(H,
		   I,
		   P,
		   n,
		   bos,
		   F,
		   Q,
		   war,
		   R,
		   S,
		   G,
		   T).

terminal(E, F, G, morf(H, B, inf:A)) :-
	aspekt(A, C),
	rekcja_finitywna(B, D),
	register(formaczas(bok,
			   C,
			   J,
			   K,
			   L,
			   M,
			   D,
			   tak,
			   N),
		 E,
		 F,
		 n_cz24,
		 [G/terminal(morf(H, B, inf:A))],
		 I),
	formaczas(E,
		  F,
		  I,
		  bok,
		  C,
		  J,
		  K,
		  L,
		  M,
		  D,
		  tak,
		  N).

terminal(E, F, G, morf(H, B, pant:A)) :-
	aspekt(A, C),
	rekcja_niefinitywna(B, D),
	register(formaczas(psu,
			   C,
			   J,
			   K,
			   L,
			   M,
			   D,
			   tak,
			   N),
		 E,
		 F,
		 n_cz25,
		 [G/terminal(morf(H, B, pant:A))],
		 I),
	formaczas(E,
		  F,
		  I,
		  psu,
		  C,
		  J,
		  K,
		  L,
		  M,
		  D,
		  tak,
		  N).

terminal(E, F, G, morf(H, B, pcon:A)) :-
	aspekt(A, C),
	rekcja_niefinitywna(B, D),
	register(formaczas(psw,
			   C,
			   J,
			   K,
			   L,
			   M,
			   D,
			   tak,
			   N),
		 E,
		 F,
		 n_cz26,
		 [G/terminal(morf(H, B, pcon:A))],
		 I),
	formaczas(E,
		  F,
		  I,
		  psw,
		  C,
		  J,
		  K,
		  L,
		  M,
		  D,
		  tak,
		  N).

terminal(C, D, E, morf(F, A, pred)) :-
	rekcja_finitywna(A, B),
	register(formaczas(os, nd, ter, ozn, H, I, B, tak, J),
		 C,
		 D,
		 n_cz27,
		 [E/terminal(morf(F, A, pred))],
		 G),
	formaczas(C,
		  D,
		  G,
		  os,
		  nd,
		  ter,
		  ozn,
		  H,
		  I,
		  B,
		  tak,
		  J).

terminal(D, A, F, morf(będzie, być, bedzie:sg:ter:imperf)) :-
	goal(terminal(morf(H, B, pred)), A, E, G),
	B\=to,
	rekcja_finitywna(B, C),
	register(formaczas(os,
			   nd,
			   przy,
			   ozn,
			   J,
			   K,
			   C,
			   tak,
			   L),
		 D,
		 E,
		 n_cz28,
		 
		 [ F/terminal(morf(będzie, być, bedzie:sg:ter:imperf)),
		   A,
		   G/terminal(morf(H, B, pred))
		 ],
		 I),
	formaczas(D,
		  E,
		  I,
		  os,
		  nd,
		  przy,
		  ozn,
		  J,
		  K,
		  C,
		  tak,
		  L).

terminal(D, A, F, morf(G, B, pred)) :-
	goal(terminal(morf(będzie, być, bedzie:sg:ter:imperf)),
	     A,
	     E,
	     H),
	B\=to,
	rekcja_finitywna(B, C),
	register(formaczas(os,
			   nd,
			   przy,
			   ozn,
			   J,
			   K,
			   C,
			   tak,
			   L),
		 D,
		 E,
		 n_cz29,
		 
		 [ F/terminal(morf(G, B, pred)),
		   A,
		   H/terminal(morf(będzie, być, bedzie:sg:ter:imperf))
		 ],
		 I),
	formaczas(D,
		  E,
		  I,
		  os,
		  nd,
		  przy,
		  ozn,
		  J,
		  K,
		  C,
		  tak,
		  L).

terminal(D, A, F, morf(było, być, praet:sg:G:imperf)) :-
	goal(terminal(morf(I, B, pred)), A, E, H),
	B\=to,
	rekcja_finitywna(B, C),
	register(formaczas(os,
			   nd,
			   prze,
			   ozn,
			   K,
			   L,
			   C,
			   tak,
			   M),
		 D,
		 E,
		 n_cz30,
		 
		 [ F/terminal(morf(było, być, praet:sg:G:imperf)),
		   A,
		   H/terminal(morf(I, B, pred))
		 ],
		 J),
	formaczas(D,
		  E,
		  J,
		  os,
		  nd,
		  prze,
		  ozn,
		  K,
		  L,
		  C,
		  tak,
		  M).

terminal(D, A, F, morf(G, B, pred)) :-
	goal(terminal(morf(było, być, praet:sg:I:imperf)),
	     A,
	     E,
	     H),
	B\=to,
	rekcja_finitywna(B, C),
	register(formaczas(os,
			   nd,
			   prze,
			   ozn,
			   K,
			   L,
			   C,
			   tak,
			   M),
		 D,
		 E,
		 n_cz31,
		 
		 [ F/terminal(morf(G, B, pred)),
		   A,
		   H/terminal(morf(było, być, praet:sg:I:imperf))
		 ],
		 J),
	formaczas(D,
		  E,
		  J,
		  os,
		  nd,
		  prze,
		  ozn,
		  K,
		  L,
		  C,
		  tak,
		  M).

terminal(D, A, F, morf(G, B, pred)) :-
	goal(terminal(morf(I, by, qub)), A, E, H),
	B\=to,
	rekcja_finitywna(B, C),
	register(formaczas(os,
			   nd,
			   K,
			   war,
			   L,
			   M,
			   C,
			   tak,
			   N),
		 D,
		 E,
		 n_cz32,
		 
		 [ F/terminal(morf(G, B, pred)),
		   A,
		   H/terminal(morf(I, by, qub))
		 ],
		 J),
	formaczas(D,
		  E,
		  J,
		  os,
		  nd,
		  K,
		  war,
		  L,
		  M,
		  C,
		  tak,
		  N).

terminal(D, A, F, morf(G, by, qub)) :-
	goal(terminal(morf(I, B, pred)), A, E, H),
	B\=to,
	rekcja_finitywna(B, C),
	register(formaczas(os,
			   nd,
			   K,
			   war,
			   L,
			   M,
			   C,
			   tak,
			   N),
		 D,
		 E,
		 n_cz33,
		 
		 [ F/terminal(morf(G, by, qub)),
		   A,
		   H/terminal(morf(I, B, pred))
		 ],
		 J),
	formaczas(D,
		  E,
		  J,
		  os,
		  nd,
		  K,
		  war,
		  L,
		  M,
		  C,
		  tak,
		  N).

terminal(D, A, F, morf(G, być, inf:imperf)) :-
	goal(terminal(morf(I, B, pred)), A, E, H),
	B\=to,
	rekcja_finitywna(B, C),
	register(formaczas(bok,
			   nd,
			   K,
			   L,
			   M,
			   N,
			   C,
			   tak,
			   O),
		 D,
		 E,
		 n_cz34,
		 
		 [ F/terminal(morf(G, być, inf:imperf)),
		   A,
		   H/terminal(morf(I, B, pred))
		 ],
		 J),
	formaczas(D,
		  E,
		  J,
		  bok,
		  nd,
		  K,
		  L,
		  M,
		  N,
		  C,
		  tak,
		  O).

terminal(G, C, I, morf(J, być, praet:A:B:imperf)) :-
	liczba(A, E),
	rodzaj(B, D),
	goal(terminal(morf(L, to, pred)), C, H, K),
	rekcja_finitywna(to, F),
	register(formaczas(os,
			   nd,
			   prze,
			   ozn,
			   D/E,
			   3,
			   F,
			   tak,
			   N),
		 G,
		 H,
		 to2,
		 
		 [ I/terminal(morf(J, być, praet:A:B:imperf)),
		   C,
		   K/terminal(morf(L, to, pred))
		 ],
		 M),
	formaczas(G,
		  H,
		  M,
		  os,
		  nd,
		  prze,
		  ozn,
		  D/E,
		  3,
		  F,
		  tak,
		  N).

terminal(J, C, L, morf(M, być, praet:A:B:imperf)) :-
	liczba(A, G),
	rodzaj(B, F),
	goal(terminal(morf(O,
			   być,
			   aglt:A:D:P:Q)),
	     C,
	     E,
	     N),
	osoba(D, H),
	goal(terminal(morf(S, to, pred)), E, K, R),
	rekcja_finitywna(to, I),
	register(formaczas(os,
			   nd,
			   prze,
			   ozn,
			   F/G,
			   H,
			   I,
			   tak,
			   U),
		 J,
		 K,
		 to3,
		 
		 [ L/terminal(morf(M, być, praet:A:B:imperf)),
		   C,
		   N/terminal(morf(O, być, aglt:A:D:P:Q)),
		   E,
		   R/terminal(morf(S, to, pred))
		 ],
		 T),
	formaczas(J,
		  K,
		  T,
		  os,
		  nd,
		  prze,
		  ozn,
		  F/G,
		  H,
		  I,
		  tak,
		  U).

terminal(G, A, I, morf(J, to, pred)) :-
	goal(terminal(morf(L, być, praet:B:C:imperf)),
	     A,
	     H,
	     K),
	liczba(B, E),
	rodzaj(C, D),
	rekcja_finitywna(to, F),
	register(formaczas(os,
			   nd,
			   prze,
			   ozn,
			   D/E,
			   3,
			   F,
			   tak,
			   N),
		 G,
		 H,
		 to4,
		 
		 [ I/terminal(morf(J, to, pred)),
		   A,
		   K/terminal(morf(L, być, praet:B:C:imperf))
		 ],
		 M),
	formaczas(G,
		  H,
		  M,
		  os,
		  nd,
		  prze,
		  ozn,
		  D/E,
		  3,
		  F,
		  tak,
		  N).

terminal(J, A, L, morf(M, to, pred)) :-
	goal(terminal(morf(O, być, praet:B:C:imperf)),
	     A,
	     D,
	     N),
	liczba(B, G),
	rodzaj(C, F),
	goal(terminal(morf(Q,
			   być,
			   aglt:B:E:R:S)),
	     D,
	     K,
	     P),
	osoba(E, H),
	rekcja_finitywna(to, I),
	register(formaczas(os,
			   nd,
			   prze,
			   ozn,
			   F/G,
			   H,
			   I,
			   tak,
			   U),
		 J,
		 K,
		 to5,
		 
		 [ L/terminal(morf(M, to, pred)),
		   A,
		   N/terminal(morf(O, być, praet:B:C:imperf)),
		   D,
		   P/terminal(morf(Q, być, aglt:B:E:R:S))
		 ],
		 T),
	formaczas(J,
		  K,
		  T,
		  os,
		  nd,
		  prze,
		  ozn,
		  F/G,
		  H,
		  I,
		  tak,
		  U).

terminal(G, C, I, morf(J, być, bedzie:B:A:imperf)) :-
	osoba(A, E),
	liczba(B, D),
	goal(terminal(morf(L, to, pred)), C, H, K),
	rekcja_finitywna(to, F),
	register(formaczas(os,
			   nd,
			   przy,
			   ozn,
			   N/D,
			   E,
			   F,
			   tak,
			   O),
		 G,
		 H,
		 to6,
		 
		 [ I/terminal(morf(J, być, bedzie:B:A:imperf)),
		   C,
		   K/terminal(morf(L, to, pred))
		 ],
		 M),
	formaczas(G,
		  H,
		  M,
		  os,
		  nd,
		  przy,
		  ozn,
		  N/D,
		  E,
		  F,
		  tak,
		  O).

terminal(G, A, I, morf(J, to, pred)) :-
	goal(terminal(morf(L, być, bedzie:C:B:imperf)),
	     A,
	     H,
	     K),
	osoba(B, E),
	liczba(C, D),
	rekcja_finitywna(to, F),
	register(formaczas(os,
			   nd,
			   przy,
			   ozn,
			   N/D,
			   E,
			   F,
			   tak,
			   O),
		 G,
		 H,
		 to7,
		 
		 [ I/terminal(morf(J, to, pred)),
		   A,
		   K/terminal(morf(L, być, bedzie:C:B:imperf))
		 ],
		 M),
	formaczas(G,
		  H,
		  M,
		  os,
		  nd,
		  przy,
		  ozn,
		  N/D,
		  E,
		  F,
		  tak,
		  O).

terminal(G, C, I, morf(J, być, fin:B:A:imperf)) :-
	osoba(A, E),
	liczba(B, D),
	goal(terminal(morf(L, to, pred)), C, H, K),
	rekcja_finitywna(to, F),
	register(formaczas(os,
			   nd,
			   ter,
			   ozn,
			   N/D,
			   E,
			   F,
			   tak,
			   O),
		 G,
		 H,
		 to8,
		 
		 [ I/terminal(morf(J, być, fin:B:A:imperf)),
		   C,
		   K/terminal(morf(L, to, pred))
		 ],
		 M),
	formaczas(G,
		  H,
		  M,
		  os,
		  nd,
		  ter,
		  ozn,
		  N/D,
		  E,
		  F,
		  tak,
		  O).

terminal(G, A, I, morf(J, to, pred)) :-
	goal(terminal(morf(L, być, fin:C:B:imperf)),
	     A,
	     H,
	     K),
	osoba(B, E),
	liczba(C, D),
	rekcja_finitywna(to, F),
	register(formaczas(os,
			   nd,
			   ter,
			   ozn,
			   N/D,
			   E,
			   F,
			   tak,
			   O),
		 G,
		 H,
		 to9,
		 
		 [ I/terminal(morf(J, to, pred)),
		   A,
		   K/terminal(morf(L, być, fin:C:B:imperf))
		 ],
		 M),
	formaczas(G,
		  H,
		  M,
		  os,
		  nd,
		  ter,
		  ozn,
		  N/D,
		  E,
		  F,
		  tak,
		  O).

terminal(C, A, E, morf(F, to, pred)) :-
	goal(terminal(morf(H, nie, qub)), A, D, G),
	rekcja_finitywna(to, B),
	register(formaczas(os,
			   nd,
			   ter,
			   ozn,
			   J,
			   K,
			   B,
			   nie(L),
			   M),
		 C,
		 D,
		 to10,
		 
		 [ E/terminal(morf(F, to, pred)),
		   A,
		   G/terminal(morf(H, nie, qub))
		 ],
		 I),
	formaczas(C,
		  D,
		  I,
		  os,
		  nd,
		  ter,
		  ozn,
		  J,
		  K,
		  B,
		  nie(L),
		  M).

terminal(H, A, J, morf(K, to, pred)) :-
	goal(terminal(morf(M, nie, qub)), A, B, L),
	goal(terminal(morf(O, być, praet:C:D:imperf)),
	     B,
	     I,
	     N),
	liczba(C, F),
	rodzaj(D, E),
	rekcja_finitywna(to, G),
	register(formaczas(os,
			   nd,
			   prze,
			   ozn,
			   E/F,
			   3,
			   G,
			   nie(Q),
			   R),
		 H,
		 I,
		 to14,
		 
		 [ J/terminal(morf(K, to, pred)),
		   A,
		   L/terminal(morf(M, nie, qub)),
		   B,
		   N/terminal(morf(O, być, praet:C:D:imperf))
		 ],
		 P),
	formaczas(H,
		  I,
		  P,
		  os,
		  nd,
		  prze,
		  ozn,
		  E/F,
		  3,
		  G,
		  nie(Q),
		  R).

terminal(H, A, J, morf(K, to, pred)) :-
	goal(terminal(morf(M, nie, qub)), A, B, L),
	goal(terminal(morf(O, być, bedzie:D:C:imperf)),
	     B,
	     I,
	     N),
	osoba(C, F),
	liczba(D, E),
	rekcja_finitywna(to, G),
	register(formaczas(os,
			   nd,
			   przy,
			   ozn,
			   Q/E,
			   F,
			   G,
			   nie(R),
			   S),
		 H,
		 I,
		 to17,
		 
		 [ J/terminal(morf(K, to, pred)),
		   A,
		   L/terminal(morf(M, nie, qub)),
		   B,
		   N/terminal(morf(O, być, bedzie:D:C:imperf))
		 ],
		 P),
	formaczas(H,
		  I,
		  P,
		  os,
		  nd,
		  przy,
		  ozn,
		  Q/E,
		  F,
		  G,
		  nie(R),
		  S).

terminal(H, A, J, morf(K, to, pred)) :-
	goal(terminal(morf(M, nie, qub)), A, B, L),
	goal(terminal(morf(O, być, fin:D:C:imperf)),
	     B,
	     I,
	     N),
	osoba(C, F),
	liczba(D, E),
	rekcja_finitywna(to, G),
	register(formaczas(os,
			   nd,
			   ter,
			   ozn,
			   Q/E,
			   F,
			   G,
			   nie(R),
			   S),
		 H,
		 I,
		 to19,
		 
		 [ J/terminal(morf(K, to, pred)),
		   A,
		   L/terminal(morf(M, nie, qub)),
		   B,
		   N/terminal(morf(O, być, fin:D:C:imperf))
		 ],
		 P),
	formaczas(H,
		  I,
		  P,
		  os,
		  nd,
		  ter,
		  ozn,
		  Q/E,
		  F,
		  G,
		  nie(R),
		  S).

terminal(I, A, K, morf(L, to, pred)) :-
	goal(terminal(morf(N, być, praet:C:E:imperf)),
	     A,
	     B,
	     M),
	goal(condaglt(D, G, na), B, J, O),
	liczba(C, D),
	rodzaj(E, F),
	rekcja_finitywna(to, H),
	register(formaczas(os,
			   nd,
			   Q,
			   war,
			   F/D,
			   G,
			   H,
			   tak,
			   R),
		 I,
		 J,
		 to20,
		 
		 [ K/terminal(morf(L, to, pred)),
		   A,
		   M/terminal(morf(N, być, praet:C:E:imperf)),
		   B,
		   O/condaglt(D, G, na)
		 ],
		 P),
	formaczas(I,
		  J,
		  P,
		  os,
		  nd,
		  Q,
		  war,
		  F/D,
		  G,
		  H,
		  tak,
		  R).

terminal(I, A, K, morf(L, to, pred)) :-
	goal(condaglt(D, G, na), A, B, M),
	goal(terminal(morf(O, być, praet:C:E:imperf)),
	     B,
	     J,
	     N),
	liczba(C, D),
	rodzaj(E, F),
	rekcja_finitywna(to, H),
	register(formaczas(os,
			   nd,
			   Q,
			   war,
			   F/D,
			   G,
			   H,
			   tak,
			   R),
		 I,
		 J,
		 to21,
		 
		 [ K/terminal(morf(L, to, pred)),
		   A,
		   M/condaglt(D, G, na),
		   B,
		   N/terminal(morf(O, być, praet:C:E:imperf))
		 ],
		 P),
	formaczas(I,
		  J,
		  P,
		  os,
		  nd,
		  Q,
		  war,
		  F/D,
		  G,
		  H,
		  tak,
		  R).

terminal(I, A, K, morf(L, być, praet:C:E:imperf)) :-
	goal(condaglt(D, G, na), A, B, M),
	goal(terminal(morf(O, to, pred)), B, J, N),
	liczba(C, D),
	rodzaj(E, F),
	rekcja_finitywna(to, H),
	register(formaczas(os,
			   nd,
			   Q,
			   war,
			   F/D,
			   G,
			   H,
			   tak,
			   R),
		 I,
		 J,
		 to21,
		 
		 [ K/terminal(morf(L, być, praet:C:E:imperf)),
		   A,
		   M/condaglt(D, G, na),
		   B,
		   N/terminal(morf(O, to, pred))
		 ],
		 P),
	formaczas(I,
		  J,
		  P,
		  os,
		  nd,
		  Q,
		  war,
		  F/D,
		  G,
		  H,
		  tak,
		  R).

terminal(J, K, L, morf(M, E, winien:C:D:A)) :-
	asagl(A, B, nagl),
	aspekt(B, F),
	liczba(C, H),
	rodzaj(D, G),
	rekcja_finitywna(E, I),
	register(formaczas(os,
			   F,
			   ter,
			   ozn,
			   G/H,
			   3,
			   I,
			   tak,
			   O),
		 J,
		 K,
		 n_cz35,
		 
		 [ L/terminal(morf(M, E, winien:C:D:A))
		 ],
		 N),
	formaczas(J,
		  K,
		  N,
		  os,
		  F,
		  ter,
		  ozn,
		  G/H,
		  3,
		  I,
		  tak,
		  O).

terminal(M, F, O, morf(P, E, winien:C:D:A)) :-
	asagl(A, B, agl),
	aspekt(B, H),
	liczba(C, J),
	rodzaj(D, I),
	rekcja_finitywna(E, L),
	goal(terminal(morf(R,
			   być,
			   aglt:C:G:S:T)),
	     F,
	     N,
	     Q),
	osoba(G, K),
	register(formaczas(os,
			   H,
			   ter,
			   ozn,
			   I/J,
			   K,
			   L,
			   tak,
			   V),
		 M,
		 N,
		 n_cz36,
		 
		 [ O/terminal(morf(P, E, winien:C:D:A)),
		   F,
		   Q/terminal(morf(R, być, aglt:C:G:S:T))
		 ],
		 U),
	formaczas(M,
		  N,
		  U,
		  os,
		  H,
		  ter,
		  ozn,
		  I/J,
		  K,
		  L,
		  tak,
		  V).

terminal(E, F, G, morf(H, być, aglt:A:B:I:J)) :-
	liczba(A, D),
	osoba(B, C),
	register(posiłk(agl(C),
			L/D,
			neut,
			ni,
			(0| 0),
			M),
		 E,
		 F,
		 po1,
		 
		 [ G/terminal(morf(H, być, aglt:A:B:I:J))
		 ],
		 K),
	posiłk(E,
	       F,
	       K,
	       agl(C),
	       L/D,
	       neut,
	       ni,
	       (0| 0),
	       M).

terminal(B, C, D, morf(E, A, qub)) :-
	member(A, [niech, niechaj, niechże, niechajże]),
	register(posiłk(niech, G, neut, ni, (0| 0), H),
		 B,
		 C,
		 po2,
		 [D/terminal(morf(E, A, qub))],
		 F),
	posiłk(B, C, F, niech, G, neut, ni, (0| 0), H).

terminal(G, A, I, morf(J, być, praet:B:D:imperf)) :-
	goal(condaglt(C, E, na), A, H, K),
	liczba(B, C),
	rodzaj(D, F),
	register(posiłk(byłby(E, tak),
			F/C,
			neut,
			ni,
			(0| 0),
			M),
		 G,
		 H,
		 po4,
		 
		 [ I/terminal(morf(J, być, praet:B:D:imperf)),
		   A,
		   K/condaglt(C, E, na)
		 ],
		 L),
	posiłk(G,
	       H,
	       L,
	       byłby(E, tak),
	       F/C,
	       neut,
	       ni,
	       (0| 0),
	       M).

terminal(E, F, G, morf(H, być, bedzie:B:A:imperf)) :-
	osoba(A, C),
	liczba(B, D),
	register(posiłk(bedzie(C, tak),
			J/D,
			neut,
			ni,
			(0| 0),
			K),
		 E,
		 F,
		 po5,
		 
		 [ G/terminal(morf(H, być, bedzie:B:A:imperf))
		 ],
		 I),
	posiłk(E,
	       F,
	       I,
	       bedzie(C, tak),
	       J/D,
	       neut,
	       ni,
	       (0| 0),
	       K).

terminal(C, D, E, morf(F, G, adv:A)) :-
	stopien(A, B),
	register(formaprzys(B, przys, I, neut, J),
		 C,
		 D,
		 eps1,
		 [E/terminal(morf(F, G, adv:A))],
		 H),
	formaprzys(C, D, H, B, przys, I, neut, J).

terminal(A, B, C, morf(D, E, adv)) :-
	register(formaprzys(row, przys, G, neut, H),
		 A,
		 B,
		 eps2,
		 [C/terminal(morf(D, E, adv))],
		 F),
	formaprzys(A, B, F, row, przys, G, neut, H).

terminal(C, D, E, morf(F, A, padv)) :-
	równe(A,
	      [dlaczego, dokąd, gdzie, jak, kiedy, którędy, odkąd, skąd, czemu]),
	równe(B, [pyt, pz]),
	register(formaprzys(row, przys, H, B, I),
		 C,
		 D,
		 eps3,
		 [E/terminal(morf(F, A, padv))],
		 G),
	formaprzys(C, D, G, row, przys, H, B, I).

terminal(B, C, D, morf(E, A, padv)) :-
	równe(A, [dokąd, gdzie, jak, kiedy, którędy, odkąd, skąd]),
	register(formaprzys(row, przys, G, wz(A, przys), H),
		 B,
		 C,
		 eps30,
		 [D/terminal(morf(E, A, padv))],
		 F),
	formaprzys(B,
		   C,
		   F,
		   row,
		   przys,
		   G,
		   wz(A, przys),
		   H).

terminal(B, C, D, morf(E, A, padv)) :-
	member(A, [tak]),
	register(formaprzys(row, tk, G, neut, H),
		 B,
		 C,
		 eps4,
		 [D/terminal(morf(E, A, padv))],
		 F),
	formaprzys(B, C, F, row, tk, G, neut, H).

terminal(A, B, C, morf(D, nigdy, padv)) :-
	register(formaprzys(row, przys, nie(F), neut, G),
		 A,
		 B,
		 eps5,
		 [C/terminal(morf(D, nigdy, padv))],
		 E),
	formaprzys(A,
		   B,
		   E,
		   row,
		   przys,
		   nie(F),
		   neut,
		   G).

terminal(D, B, F, morf(G, na, prep:A)) :-
	przypadki(A, bier),
	goal(terminal(morf(I, C, adv:pos)), B, E, H),
	member(C,
	       
	       [ bieżąco,
		 długo,
		 fest,
		 krótko,
		 lewo,
		 nowo,
		 okrągło,
		 pewno,
		 prawo,
		 próżno,
		 szybko,
		 żywo,
		 biało,
		 czarno,
		 czerwono,
		 niebiesko,
		 różowo,
		 rudo,
		 zielono,
		 żółto
	       ]),
	register(formaprzys(row, przys, K, neut, L),
		 D,
		 E,
		 eps10,
		 
		 [ F/terminal(morf(G, na, prep:A)),
		   B,
		   H/terminal(morf(I, C, adv:pos))
		 ],
		 J),
	formaprzys(D, E, J, row, przys, K, neut, L).

terminal(D, B, F, morf(G, na, prep:A)) :-
	przypadki(A, bier),
	goal(terminal(morf(I, C, adv)), B, E, H),
	member(C, [darmo, serio, tip-top, tyle, wpół, zawsze, zewnątrz]),
	register(formaprzys(row, przys, K, neut, L),
		 D,
		 E,
		 eps12,
		 
		 [ F/terminal(morf(G, na, prep:A)),
		   B,
		   H/terminal(morf(I, C, adv))
		 ],
		 J),
	formaprzys(D, E, J, row, przys, K, neut, L).

terminal(D, B, F, morf(G, na, prep:A)) :-
	przypadki(A, bier),
	goal(terminal(morf(I, C, burk)), B, E, H),
	member(C, [przekór, przemian]),
	register(formaprzys(row, przys, K, neut, L),
		 D,
		 E,
		 eps15,
		 
		 [ F/terminal(morf(G, na, prep:A)),
		   B,
		   H/terminal(morf(I, C, burk))
		 ],
		 J),
	formaprzys(D, E, J, row, przys, K, neut, L).

terminal(B, A, D, morf(E, i, conj)) :-
	goal(terminal(morf(G, tak, padv)), A, C, F),
	register(formaprzys(row, przys, I, neut, J),
		 B,
		 C,
		 eps11,
		 
		 [ D/terminal(morf(E, i, conj)),
		   A,
		   F/terminal(morf(G, tak, padv))
		 ],
		 H),
	formaprzys(B, C, H, row, przys, I, neut, J).

terminal(B, A, D, morf(E, jak, padv)) :-
	goal(terminal(morf(G, zwykle, adv:pos)), A, C, F),
	register(formaprzys(row, przys, I, neut, J),
		 B,
		 C,
		 eps13,
		 
		 [ D/terminal(morf(E, jak, padv)),
		   A,
		   F/terminal(morf(G, zwykle, adv:pos))
		 ],
		 H),
	formaprzys(B, C, H, row, przys, I, neut, J).

terminal(D, B, F, morf(G, za, prep:A)) :-
	przypadki(A, bier),
	goal(terminal(morf(I, C, adv)), B, E, H),
	member(C, [darmo]),
	register(formaprzys(row, przys, K, neut, L),
		 D,
		 E,
		 eps14,
		 
		 [ F/terminal(morf(G, za, prep:A)),
		   B,
		   H/terminal(morf(I, C, adv))
		 ],
		 J),
	formaprzys(D, E, J, row, przys, K, neut, L).

terminal(B, C, D, morf(E, A, qub)) :-
	register(partykuła(A, G),
		 B,
		 C,
		 jel2,
		 [D/terminal(morf(E, A, qub))],
		 F),
	partykuła(B, C, F, A, G).

terminal(D, E, F, morf(G, B, prep:A)) :-
	przypadki(A, C),
	B\=przeciwko,
	register(przyimek(B, C, I),
		 D,
		 E,
		 jel3,
		 [F/terminal(morf(G, B, prep:A))],
		 H),
	przyimek(D, E, H, B, C, I).

terminal(D, E, F, morf(G, B, prep:A:H)) :-
	przypadki(A, C),
	register(przyimek(B, C, J),
		 D,
		 E,
		 jel3x,
		 
		 [ F/terminal(morf(G, B, prep:A:H))
		 ],
		 I),
	przyimek(D, E, I, B, C, J).

terminal(C, D, E, morf(F, przeciwko, prep:A)) :-
	przypadki(A, B),
	register(przyimek(przeciw, B, H),
		 C,
		 D,
		 jel3p,
		 [E/terminal(morf(F, przeciwko, prep:A))],
		 G),
	przyimek(C, D, G, przeciw, B, H).

terminal(B, A, D, morf(co, co, prep:acc)) :-
	goal(terminal(morf(do, do, prep:gen)), A, C, E),
	register(przyimek('co do', dop, G),
		 B,
		 C,
		 jel3a,
		 
		 [ D/terminal(morf(co, co, prep:acc)),
		   A,
		   E/terminal(morf(do, do, prep:gen))
		 ],
		 F),
	przyimek(B, C, F, 'co do', dop, G).

terminal(B, A, D, morf(na, na, prep:[acc|loc])) :-
	goal(terminal(morf(temat, temat, subst:sg:[nom|acc]:m3)),
	     A,
	     C,
	     E),
	register(przyimek('na temat', dop, G),
		 B,
		 C,
		 jel3b,
		 
		 [ D/terminal(morf(na, na, prep:[acc|loc])),
		   A,
		   E/terminal(morf(temat, temat, subst:sg:[nom|acc]:m3))
		 ],
		 F),
	przyimek(B, C, F, 'na temat', dop, G).

terminal(B, A, D, morf(w, w, prep:[acc|loc]:nwok)) :-
	goal(terminal(morf(sprawie, sprawa, subst:sg:[dat|loc]:f)),
	     A,
	     C,
	     E),
	register(przyimek('w sprawie', dop, G),
		 B,
		 C,
		 jel3c,
		 
		 [ D/terminal(morf(w, w, prep:[acc|loc]:nwok)),
		   A,
		   E/terminal(morf(sprawie, sprawa, subst:sg:[dat|loc]:f))
		 ],
		 F),
	przyimek(B, C, F, 'w sprawie', dop, G).

terminal(B, A, D, morf(z, z, prep:[gen, acc|inst]:nwok)) :-
	goal(terminal(morf(powodu, powód, subst:sg:gen:m3)),
	     A,
	     C,
	     E),
	register(przyimek('z powodu', dop, G),
		 B,
		 C,
		 jel3d,
		 
		 [ D/terminal(morf(z, z, prep:[gen, acc|inst]:nwok)),
		   A,
		   E/terminal(morf(powodu, powód, subst:sg:gen:m3))
		 ],
		 F),
	przyimek(B, C, F, 'z powodu', dop, G).

terminal(D, B, F, morf(w, w, prep:A:nwok)) :-
	przypadki(A, miej),
	goal(terminal(morf(trakcie, trakt, subst:sg:C:m3)),
	     B,
	     E,
	     G),
	przypadki(C, miej),
	register(przyimek('w trakcie', dop, I),
		 D,
		 E,
		 jel3e,
		 
		 [ F/terminal(morf(w, w, prep:A:nwok)),
		   B,
		   G/terminal(morf(trakcie, trakt, subst:sg:C:m3))
		 ],
		 H),
	przyimek(D, E, H, 'w trakcie', dop, I).

terminal(C, B, E, morf(wraz, wraz, A)) :-
	równe(A, [burk, adv]),
	goal(terminal(morf(z, z, prep:G:nwok)), B, D, F),
	register(przyimek('wraz z', narz, I),
		 C,
		 D,
		 jel3f,
		 
		 [ E/terminal(morf(wraz, wraz, A)),
		   B,
		   F/terminal(morf(z, z, prep:G:nwok))
		 ],
		 H),
	przyimek(C, D, H, 'wraz z', narz, I).

terminal(D, B, F, morf(w, w, prep:A:nwok)) :-
	przypadki(A, miej),
	goal(terminal(morf(ciągu, ciąg, subst:sg:C:m3)),
	     B,
	     E,
	     G),
	przypadki(C, miej),
	register(przyimek('w ciągu', dop, I),
		 D,
		 E,
		 jel3g,
		 
		 [ F/terminal(morf(w, w, prep:A:nwok)),
		   B,
		   G/terminal(morf(ciągu, ciąg, subst:sg:C:m3))
		 ],
		 H),
	przyimek(D, E, H, 'w ciągu', dop, I).

terminal(D, B, F, morf(na, na, prep:A)) :-
	przypadki(A, bier),
	goal(terminal(morf(skutek, skutek, subst:sg:C:m3)),
	     B,
	     E,
	     G),
	przypadki(C, bier),
	register(przyimek('na skutek', dop, I),
		 D,
		 E,
		 jel3h,
		 
		 [ F/terminal(morf(na, na, prep:A)),
		   B,
		   G/terminal(morf(skutek, skutek, subst:sg:C:m3))
		 ],
		 H),
	przyimek(D, E, H, 'na skutek', dop, I).

terminal(G, D, I, morf(J, A, brev:B)) :-
	slowskr(A, _, B, E, prep:C),
	przypadki(C, F),
	optional(K,
		 [],
		 D,
		 H,
		 terminal(morf('.', _, interp)),
		 { E\=kon
		 },
		 { E\=nkon
		 }),
	register(przyimek(A, F, M),
		 G,
		 H,
		 jel3s,
		 
		 [ I/terminal(morf(J, A, brev:B))
		 | K
		 ],
		 L),
	przyimek(G, H, L, A, F, M).

terminal(C, D, E, morf(F, A, interj)) :-
	rekcja_wykrzyknikowa(A, B),
	register(formawykrz(B, H),
		 C,
		 D,
		 wk1,
		 [E/terminal(morf(F, A, interj))],
		 G),
	formawykrz(C, D, G, B, H).

terminal(D, A, F, morf(G, H, interj)) :-
	goal(terminal(morf(J, B, interj)), A, E, I),
	rekcja_wykrzyknikowa(B, C),
	register(formawykrz(C, L),
		 D,
		 E,
		 wk2,
		 
		 [ F/terminal(morf(G, H, interj)),
		   A,
		   I/terminal(morf(J, B, interj))
		 ],
		 K),
	formawykrz(D, E, K, C, L).

terminal(E, A, G, morf(H, I, interj)) :-
	goal(terminal(morf(-, -, interp)), A, B, J),
	goal(terminal(morf(L, C, interj)), B, F, K),
	rekcja_wykrzyknikowa(C, D),
	register(formawykrz(D, N),
		 E,
		 F,
		 wk2,
		 
		 [ G/terminal(morf(H, I, interj)),
		   A,
		   J/terminal(morf(-, -, interp)),
		   B,
		   K/terminal(morf(L, C, interj))
		 ],
		 M),
	formawykrz(E, F, M, D, N).

terminal(A, B, C, morf(?, D, interp)) :-
	register(znakkonca(pyt, F),
		 A,
		 B,
		 int1,
		 [C/terminal(morf(?, D, interp))],
		 E),
	znakkonca(A, B, E, pyt, F).

terminal(B, A, D, morf(!, E, interp)) :-
	goal(terminal(morf(?, G, interp)), A, C, F),
	register(znakkonca(pyt, I),
		 B,
		 C,
		 int8,
		 
		 [ D/terminal(morf(!, E, interp)),
		   A,
		   F/terminal(morf(?, G, interp))
		 ],
		 H),
	znakkonca(B, C, H, pyt, I).

terminal(B, A, D, morf(?, E, interp)) :-
	goal(terminal(morf(!, G, interp)), A, C, F),
	register(znakkonca(pyt, I),
		 B,
		 C,
		 int9,
		 
		 [ D/terminal(morf(?, E, interp)),
		   A,
		   F/terminal(morf(!, G, interp))
		 ],
		 H),
	znakkonca(B, C, H, pyt, I).

terminal(D, A, F, morf('.', G, interp)) :-
	goal(terminal(morf('.', I, interp)), A, B, H),
	goal(terminal(morf('.', K, interp)), B, C, J),
	goal(terminal(morf(?, M, interp)), C, E, L),
	register(znakkonca(pyt, O),
		 D,
		 E,
		 int11,
		 
		 [ F/terminal(morf('.', G, interp)),
		   A,
		   H/terminal(morf('.', I, interp)),
		   B,
		   J/terminal(morf('.', K, interp)),
		   C,
		   L/terminal(morf(?, M, interp))
		 ],
		 N),
	znakkonca(D, E, N, pyt, O).

terminal(D, A, F, morf(?, G, interp)) :-
	goal(terminal(morf('.', I, interp)), A, B, H),
	goal(terminal(morf('.', K, interp)), B, C, J),
	goal(terminal(morf('.', M, interp)), C, E, L),
	register(znakkonca(pyt, O),
		 D,
		 E,
		 int12,
		 
		 [ F/terminal(morf(?, G, interp)),
		   A,
		   H/terminal(morf('.', I, interp)),
		   B,
		   J/terminal(morf('.', K, interp)),
		   C,
		   L/terminal(morf('.', M, interp))
		 ],
		 N),
	znakkonca(D, E, N, pyt, O).

terminal(E, A, G, morf(?, H, interp)) :-
	goal(terminal(morf(!, J, interp)), A, B, I),
	goal(terminal(morf('.', L, interp)), B, C, K),
	goal(terminal(morf('.', N, interp)), C, D, M),
	goal(terminal(morf('.', P, interp)), D, F, O),
	register(znakkonca(pyt, R),
		 E,
		 F,
		 int20,
		 
		 [ G/terminal(morf(?, H, interp)),
		   A,
		   I/terminal(morf(!, J, interp)),
		   B,
		   K/terminal(morf('.', L, interp)),
		   C,
		   M/terminal(morf('.', N, interp)),
		   D,
		   O/terminal(morf('.', P, interp))
		 ],
		 Q),
	znakkonca(E, F, Q, pyt, R).

terminal(A, B, C, morf('.', D, interp)) :-
	register(znakkonca(neut, F),
		 A,
		 B,
		 int2,
		 [C/terminal(morf('.', D, interp))],
		 E),
	znakkonca(A, B, E, neut, F).

terminal(A, B, C, morf(!, D, interp)) :-
	register(znakkonca(neut, F),
		 A,
		 B,
		 int3,
		 [C/terminal(morf(!, D, interp))],
		 E),
	znakkonca(A, B, E, neut, F).

terminal(C, A, E, morf(!, F, interp)) :-
	goal(terminal(morf(!, H, interp)), A, B, G),
	goal(terminal(morf(!, J, interp)), B, D, I),
	register(znakkonca(neut, L),
		 C,
		 D,
		 int10,
		 
		 [ E/terminal(morf(!, F, interp)),
		   A,
		   G/terminal(morf(!, H, interp)),
		   B,
		   I/terminal(morf(!, J, interp))
		 ],
		 K),
	znakkonca(C, D, K, neut, L).

terminal(C, A, E, morf('.', F, interp)) :-
	goal(terminal(morf('.', H, interp)), A, B, G),
	goal(terminal(morf('.', J, interp)), B, D, I),
	register(znakkonca(neut, L),
		 C,
		 D,
		 int4,
		 
		 [ E/terminal(morf('.', F, interp)),
		   A,
		   G/terminal(morf('.', H, interp)),
		   B,
		   I/terminal(morf('.', J, interp))
		 ],
		 K),
	znakkonca(C, D, K, neut, L).

terminal(A, B, C, morf('…', D, interp)) :-
	register(znakkonca(neut, F),
		 A,
		 B,
		 int5,
		 [C/terminal(morf('…', D, interp))],
		 E),
	znakkonca(A, B, E, neut, F).

terminal(D, A, F, morf('.', G, interp)) :-
	goal(terminal(morf('.', I, interp)), A, B, H),
	goal(terminal(morf('.', K, interp)), B, C, J),
	goal(terminal(morf(!, M, interp)), C, E, L),
	register(znakkonca(neut, O),
		 D,
		 E,
		 int7,
		 
		 [ F/terminal(morf('.', G, interp)),
		   A,
		   H/terminal(morf('.', I, interp)),
		   B,
		   J/terminal(morf('.', K, interp)),
		   C,
		   L/terminal(morf(!, M, interp))
		 ],
		 N),
	znakkonca(D, E, N, neut, O).

terminal(B, A, D, morf('…', E, interp)) :-
	goal(terminal(morf(!, G, interp)), A, C, F),
	register(znakkonca(neut, I),
		 B,
		 C,
		 int15,
		 
		 [ D/terminal(morf('…', E, interp)),
		   A,
		   F/terminal(morf(!, G, interp))
		 ],
		 H),
	znakkonca(B, C, H, neut, I).

terminal(D, A, F, morf(!, G, interp)) :-
	goal(terminal(morf('.', I, interp)), A, B, H),
	goal(terminal(morf('.', K, interp)), B, C, J),
	goal(terminal(morf('.', M, interp)), C, E, L),
	register(znakkonca(neut, O),
		 D,
		 E,
		 int18,
		 
		 [ F/terminal(morf(!, G, interp)),
		   A,
		   H/terminal(morf('.', I, interp)),
		   B,
		   J/terminal(morf('.', K, interp)),
		   C,
		   L/terminal(morf('.', M, interp))
		 ],
		 N),
	znakkonca(D, E, N, neut, O).

terminal(B, A, D, morf(!, E, interp)) :-
	goal(terminal(morf('…', G, interp)), A, C, F),
	register(znakkonca(neut, I),
		 B,
		 C,
		 int19,
		 
		 [ D/terminal(morf(!, E, interp)),
		   A,
		   F/terminal(morf('…', G, interp))
		 ],
		 H),
	znakkonca(B, C, H, neut, I).

terminal(A, B, C, morf(D, ',', interp)) :-
	register(przec((p| p), F),
		 A,
		 B,
		 int6,
		 [C/terminal(morf(D, ',', interp))],
		 E),
	przec(A, B, E, (p| p), F).

terminal(A, B, C, morf(D, ;, interp)) :-
	register(przec((p| p), F),
		 A,
		 B,
		 int13,
		 [C/terminal(morf(D, ;, interp))],
		 E),
	przec(A, B, E, (p| p), F).

terminal(A, B, C, morf('"', D, interp)) :-
	register(cudz(F, G),
		 A,
		 B,
		 intc1,
		 [C/terminal(morf('"', D, interp))],
		 E),
	cudz(A, B, E, F, G).

terminal(A, B, C, morf('„', D, interp)) :-
	register(cudz(o, F),
		 A,
		 B,
		 intc2,
		 [C/terminal(morf('„', D, interp))],
		 E),
	cudz(A, B, E, o, F).

terminal(B, A, D, morf(',', E, interp)) :-
	goal(terminal(morf(',', G, interp)), A, C, F),
	register(cudz(o, I),
		 B,
		 C,
		 intc5,
		 
		 [ D/terminal(morf(',', E, interp)),
		   A,
		   F/terminal(morf(',', G, interp))
		 ],
		 H),
	cudz(B, C, H, o, I).

terminal(A, B, C, morf('”', D, interp)) :-
	register(cudz(z, F),
		 A,
		 B,
		 intc3,
		 [C/terminal(morf('”', D, interp))],
		 E),
	cudz(A, B, E, z, F).

terminal(A, B, C, morf('\'\'', D, interp)) :-
	register(cudz(z, F),
		 A,
		 B,
		 intc6,
		 [C/terminal(morf('\'\'', D, interp))],
		 E),
	cudz(A, B, E, z, F).

terminal(B, A, D, morf('\'', E, interp)) :-
	goal(terminal(morf('\'', G, interp)), A, C, F),
	register(cudz(z, I),
		 B,
		 C,
		 intc7,
		 
		 [ D/terminal(morf('\'', E, interp)),
		   A,
		   F/terminal(morf('\'', G, interp))
		 ],
		 H),
	cudz(B, C, H, z, I).

terminal(A, B, C, morf('“', D, interp)) :-
	register(cudz(F, G),
		 A,
		 B,
		 intc4,
		 [C/terminal(morf('“', D, interp))],
		 E),
	cudz(A, B, E, F, G).

terminal(A, B, C, morf('—', D, interp)) :-
	register(pauza(F),
		 A,
		 B,
		 intp1,
		 [C/terminal(morf('—', D, interp))],
		 E),
	pauza(A, B, E, F).

terminal(A, B, C, morf('–', D, interp)) :-
	register(pauza(F),
		 A,
		 B,
		 intp2,
		 [C/terminal(morf('–', D, interp))],
		 E),
	pauza(A, B, E, F).

terminal(A, B, C, morf(-, D, interp)) :-
	register(pauza(F),
		 A,
		 B,
		 intp3,
		 [C/terminal(morf(-, D, interp))],
		 E),
	pauza(A, B, E, F).

terminal(B, A, D, morf(-, E, interp)) :-
	goal(terminal(morf(-, G, interp)), A, C, F),
	register(pauza(I),
		 B,
		 C,
		 intp4,
		 
		 [ D/terminal(morf(-, E, interp)),
		   A,
		   F/terminal(morf(-, G, interp))
		 ],
		 H),
	pauza(B, C, H, I).

terminal(C, A, E, morf(-, F, interp)) :-
	goal(terminal(morf(-, H, interp)), A, B, G),
	goal(terminal(morf(-, J, interp)), B, D, I),
	register(pauza(L),
		 C,
		 D,
		 intp5,
		 
		 [ E/terminal(morf(-, F, interp)),
		   A,
		   G/terminal(morf(-, H, interp)),
		   B,
		   I/terminal(morf(-, J, interp))
		 ],
		 K),
	pauza(C, D, K, L).

terminal(A, B, C, morf('(', D, interp)) :-
	register(nawias(o, o, F),
		 A,
		 B,
		 intn1,
		 [C/terminal(morf('(', D, interp))],
		 E),
	nawias(A, B, E, o, o, F).

terminal(A, B, C, morf(')', D, interp)) :-
	register(nawias(z, o, F),
		 A,
		 B,
		 intn2,
		 [C/terminal(morf(')', D, interp))],
		 E),
	nawias(A, B, E, z, o, F).

terminal(A, B, C, morf('[', D, interp)) :-
	register(nawias(o, k, F),
		 A,
		 B,
		 intn3,
		 [C/terminal(morf('[', D, interp))],
		 E),
	nawias(A, B, E, o, k, F).

terminal(A, B, C, morf(']', D, interp)) :-
	register(nawias(z, k, F),
		 A,
		 B,
		 intn4,
		 [C/terminal(morf(']', D, interp))],
		 E),
	nawias(A, B, E, z, k, F).

terminal(A, B, C, morf(:, D, interp)) :-
	register(dwukropek(F),
		 A,
		 B,
		 intd1,
		 [C/terminal(morf(:, D, interp))],
		 E),
	dwukropek(A, B, E, F).

fpt(G, H, I, A, J, K, wym([], L, M), N, O, C, D, E, F, na) :-
	member(A, [mian, narz]),
	member(B, [A, pred]),
	register(fw(adjp(B),
		    Q,
		    R,
		    S,
		    T,
		    U,
		    C,
		    D,
		    E,
		    F,
		    V),
		 G,
		 H,
		 wya1,
		 
		 [ I/fpt(A, J, K, wym([], L, M), N, O, C, D, E, F, na)
		 ],
		 P),
	fw(G,
	   H,
	   P,
	   adjp(B),
	   Q,
	   R,
	   S,
	   T,
	   U,
	   C,
	   D,
	   E,
	   F,
	   V).

fpt(E, F, G, dop, H, I, wym([], J, K), L, M, nie(A), B, C, D, na) :-
	register(fw(adjp(bier),
		    O,
		    P,
		    Q,
		    R,
		    S,
		    nie(A),
		    B,
		    C,
		    D,
		    T),
		 E,
		 F,
		 wya2,
		 
		 [ G/fpt(dop, H, I, wym([], J, K), L, M, nie(A), B, C, D, na)
		 ],
		 N),
	fw(E,
	   F,
	   N,
	   adjp(bier),
	   O,
	   P,
	   Q,
	   R,
	   S,
	   nie(A),
	   B,
	   C,
	   D,
	   T).

fpt(D, E, F, bier, G, H, wym([], I, J), K, L, tak, A, B, C, na) :-
	register(fw(adjp(bier),
		    N,
		    O,
		    P,
		    Q,
		    R,
		    tak,
		    A,
		    B,
		    C,
		    S),
		 D,
		 E,
		 wya3,
		 
		 [ F/fpt(bier, G, H, wym([], I, J), K, L, tak, A, B, C, na)
		 ],
		 M),
	fw(D,
	   E,
	   M,
	   adjp(bier),
	   N,
	   O,
	   P,
	   Q,
	   R,
	   tak,
	   A,
	   B,
	   C,
	   S).

fpt(I, B, K, A, L, M, wym([], N, O), P, Q, F, G, H, C, na) :-
	równe(A, [mian, dop, cel, bier, narz]),
	optional(R,
		 [],
		 B,
		 J,
		 przec(D, po),
		 { oblpk(E, [ (bp| p), C, D])
		 },
		 { E=C
		 }),
	register(fl(T,
		    U,
		    V,
		    W,
		    F,
		    G,
		    H,
		    E,
		    X),
		 I,
		 J,
		 lu15,
		 
		 [ K/fpt(A, L, M, wym([], N, O), P, Q, F, G, H, C, na)
		 | R
		 ],
		 S),
	fl(I,
	   J,
	   S,
	   T,
	   U,
	   V,
	   W,
	   F,
	   G,
	   H,
	   E,
	   X).

fpt(H, I, J, A, B/C, K, wym([], D, L), M, bzap, E, neut, F, G, na) :-
	register(fno(A,
		     B/C,
		     3,
		     wym(O, D, [[]]),
		     przym,
		     bzap,
		     P,
		     E,
		     neut,
		     F,
		     G,
		     Q),
		 H,
		 I,
		 no9,
		 
		 [ J/fpt(A, B/C, K, wym([], D, L), M, bzap, E, neut, F, G, na)
		 ],
		 N),
	fno(H,
	    I,
	    N,
	    A,
	    B/C,
	    3,
	    wym(O, D, [[]]),
	    przym,
	    bzap,
	    P,
	    E,
	    neut,
	    F,
	    G,
	    Q).

fpt(N3, D, P3, G, A/B, Q3, wym([], J3, R3), S3, D1, C, E1, F1, G1, po) :-
	do_sequence_of(T3,
		       
		       [ E,
			 Q1/fno(H1, A/B, I1, J1, K1, L1, M1, C, N1, O1, P1, na)
		       | X1
		       ],
		       D,
		       E,
		       [[optional(przec(F, po), {}, {F= (bp| p)}), fpt(G, A/B, _, wym([], _, _), _, I, C, J, K, L, po), optional(przec(H, po), {}, {H= (p| bp)})]/ (oblzap_iter(N, I, R), obldest_iter(O, J, S), oblink_iter(P, K, T), sprawdz_pk_iter(Q, M, U), sprawdz_fpt_noa(F/L/H/M))/[G, A, B, C]/[]/[]/ ([N, O, P, Q]/[])/ ([R, S, T, U]/[]), fpm(_, _, _, I, C, J, K, M, po)/ (oblzap_iter(N, I, R), obldest_iter(O, J, S), oblink_iter(P, K, T), sprawdz_pk_iter(Q, M, U))/[C]/[]/[]/ ([N, O, P, Q]/[])/ ([R, S, T, U]/[]), fno(dop, _, 3, wym([], _, _), V, I, pre, C, J, K, M, po)/ (oblzap_iter(N, I, R), obldest_iter(O, J, S), oblink_iter(P, K, T), sprawdz_pk_iter(Q, M, U), sprawdz_kl_nod_prehead(R1/V))/[C]/[]/[]/ ([N, O, P, Q]/[])/ ([R, S, T, U]/[]), fw(W, X, Y, Z, A1, post, C, J, ni, M, po)/ (oblzap_iter(N, I, R), obldest_iter(O, J, S), oblink_iter(P, K, T), sprawdz_pk_iter(Q, M, U), zroblistę_iter(B1, W, C1))/[X, Y, Z, A1, C]/[[]]/[W1]/ ([N, O, P, Q]/[B1])/ ([R, S, T, U]/[C1]), modpart(fno, C, J, ni, M, po)/ (oblzap_iter(N, I, R), obldest_iter(O, J, S), oblink_iter(P, K, T), sprawdz_pk_iter(Q, M, U))/[C]/[]/[]/ ([N, O, P, Q]/[])/ ([R, S, T, U]/[])]/[D1, E1, F1, G1]/[S1, T1, U1, V1]),
	goal(fno(H1,
		 A/B,
		 I1,
		 J1,
		 K1,
		 L1,
		 M1,
		 C,
		 N1,
		 O1,
		 P1,
		 na),
	     E,
	     Y1,
	     Q1),
	J1=wym(_, _, [_|_]),
	sprawdz_kl_noa(K1, H1, G),
	sprawdz_kl_nod_head(R1, K1),
	oblzap_iter(S1, L1, D3),
	obldest_iter(T1, N1, E3),
	oblink_iter(U1, O1, F3),
	sprawdz_pk_iter(V1, P1, G3),
	wyjmijl(W1, J1, A3),
	do_sequence_of(X1,
		       [],
		       Y1,
		       O3,
		       [[optional(przec(Z1, po), {}, {Z1= (bp| p)}), fpt(G, A/B, _, wym([], _, _), _, B2, C, C2, D2, E2, po), optional(przec(A2, po), {}, {A2= (p| bp)})]/ (oblzap_iter(G2, B2, K2), obldest_iter(H2, C2, L2), oblink_iter(I2, D2, M2), sprawdz_pk_iter(J2, F2, N2), sprawdz_fpt_noa(Z1/E2/A2/F2))/[G, A, B, C]/[]/[]/ ([G2, H2, I2, J2]/[])/ ([K2, L2, M2, N2]/[]), fpm(_, _, _, B2, C, C2, D2, F2, po)/ (oblzap_iter(G2, B2, K2), obldest_iter(H2, C2, L2), oblink_iter(I2, D2, M2), sprawdz_pk_iter(J2, F2, N2))/[C]/[]/[]/ ([G2, H2, I2, J2]/[])/ ([K2, L2, M2, N2]/[]), fno(dop, _, 3, wym([], _, _), O2, B2, pre, C, C2, D2, F2, po)/ (oblzap_iter(G2, B2, K2), obldest_iter(H2, C2, L2), oblink_iter(I2, D2, M2), sprawdz_pk_iter(J2, F2, N2), sprawdz_kl_nod(K1/O2))/[C]/[]/[]/ ([G2, H2, I2, J2]/[])/ ([K2, L2, M2, N2]/[]), fzd(P2, nk, Q2, R2, S2, _, ni, F2, po)/ (oblzap_iter(G2, B2, K2), obldest_iter(H2, C2, L2), oblink_iter(I2, D2, M2), sprawdz_pk_iter(J2, F2, N2), sprawdz_fzd_noz(T2, P2, U2))/[Q2, R2, S2]/[A/B/K1/H3]/[_]/ ([G2, H2, I2, J2]/[T2])/ ([K2, L2, M2, N2]/[U2]), fw(V2, W2, X2, Y2, Z2, post, C, C2, ni, F2, po)/ (oblzap_iter(G2, B2, K2), obldest_iter(H2, C2, L2), oblink_iter(I2, D2, M2), sprawdz_pk_iter(J2, F2, N2), oblwym_iter(B3, V2, C3))/[W2, X2, Y2, Z2, C]/[A3]/[I3]/ ([G2, H2, I2, J2]/[B3])/ ([K2, L2, M2, N2]/[C3]), modpart(fno, C, C2, ni, F2, po)/ (oblzap_iter(G2, B2, K2), obldest_iter(H2, C2, L2), oblink_iter(I2, D2, M2), sprawdz_pk_iter(J2, F2, N2))/[C]/[]/[]/ ([G2, H2, I2, J2]/[])/ ([K2, L2, M2, N2]/[])]/[D3, E3, F3, G3]/[H3, K3, L3, M3]),
	wymagania_zamknij_nieuważnie(I3),
	register(fno(H1,
		     A/B,
		     I1,
		     wym(V3, J3, bw),
		     K1,
		     H3,
		     M1,
		     C,
		     K3,
		     L3,
		     M3,
		     W3),
		 N3,
		 O3,
		 noa2,
		 
		 [ P3/fpt(G, A/B, Q3, wym([], J3, R3), S3, D1, C, E1, F1, G1, po)
		 | T3
		 ],
		 U3),
	fno(N3,
	    O3,
	    U3,
	    H1,
	    A/B,
	    I1,
	    wym(V3, J3, bw),
	    K1,
	    H3,
	    M1,
	    C,
	    K3,
	    L3,
	    M3,
	    W3).

fpt(R, C, T, dop, A/B, U, wym([], V, W), X, H, M, D, F, J, po) :-
	goal(flicz(mian,
		   A/B,
		   nuzg,
		   I,
		   E,
		   G,
		   K,
		   na),
	     C,
	     S,
	     Y),
	obldest(N, D, E),
	oblink(O, F, G),
	oblzap(Q, [H, I]),
	oblpk(P, [J, K]),
	rekcja_pusta(L),
	register(fno(mian,
		     r(mn(n), nmo(np(n)))/poj,
		     3,
		     L,
		     A1,
		     nuzg,
		     B1,
		     M,
		     N,
		     O,
		     P,
		     Q),
		 R,
		 S,
		 nol10,
		 
		 [ T/fpt(dop, A/B, U, wym([], V, W), X, H, M, D, F, J, po),
		   C,
		   Y/flicz(mian, A/B, nuzg, I, E, G, K, na)
		 ],
		 Z),
	fno(R,
	    S,
	    Z,
	    mian,
	    r(mn(n), nmo(np(n)))/poj,
	    3,
	    L,
	    A1,
	    nuzg,
	    B1,
	    M,
	    N,
	    O,
	    P,
	    Q).

fpt(Z, C, B1, dop, A/B, C1, wym([], D1, E1), F1, O, M, F, I, R, po) :-
	goal(flicz(mian,
		   A/B,
		   nuzg,
		   P,
		   G,
		   J,
		   S,
		   na),
	     C,
	     D,
	     G1),
	goal(fno(dop,
		 A/B,
		 I1,
		 U,
		 E,
		 Q,
		 pre,
		 N,
		 H,
		 L,
		 T,
		 po),
	     D,
	     A1,
	     H1),
	różne(E, uzg.nuzg.egz),
	obldest(X, [F, G, H]),
	oblink(K, I, J),
	oblink(K, J, L),
	oblneg(-ani, W, M, N),
	oblzap(V, [O, P, Q]),
	oblpk(Y, [R, S, T]),
	register(fno(mian,
		     r(mn(n), nmo(np(n)))/poj,
		     3,
		     U,
		     nuzg,
		     V,
		     K1,
		     W,
		     X,
		     K,
		     Y,
		     L1),
		 Z,
		 A1,
		 nol11,
		 
		 [ B1/fpt(dop, A/B, C1, wym([], D1, E1), F1, O, M, F, I, R, po),
		   C,
		   G1/flicz(mian, A/B, nuzg, P, G, J, S, na),
		   D,
		   H1/fno(dop, A/B, I1, U, E, Q, pre, N, H, L, T, po)
		 ],
		 J1),
	fno(Z,
	    A1,
	    J1,
	    mian,
	    r(mn(n), nmo(np(n)))/poj,
	    3,
	    U,
	    nuzg,
	    V,
	    K1,
	    W,
	    X,
	    K,
	    Y,
	    L1).

fpt(R, C, T, mian, A/B, U, wym([], V, W), X, H, N, D, F, J, po) :-
	goal(flicz(mian,
		   A/B,
		   nuzg,
		   I,
		   E,
		   G,
		   K,
		   na),
	     C,
	     S,
	     Y),
	A=r(_, nmo(_)),
	obldest(O, [D, E]),
	oblink(P, F, G),
	oblzap(M, [H, I]),
	oblpk(Q, [J, K]),
	rekcja_pusta(L),
	register(fno(mian,
		     r(mn(n), nmo(np(n)))/poj,
		     3,
		     L,
		     nuzg,
		     M,
		     A1,
		     N,
		     O,
		     P,
		     Q,
		     B1),
		 R,
		 S,
		 nol12,
		 
		 [ T/fpt(mian, A/B, U, wym([], V, W), X, H, N, D, F, J, po),
		   C,
		   Y/flicz(mian, A/B, nuzg, I, E, G, K, na)
		 ],
		 Z),
	fno(R,
	    S,
	    Z,
	    mian,
	    r(mn(n), nmo(np(n)))/poj,
	    3,
	    L,
	    nuzg,
	    M,
	    A1,
	    N,
	    O,
	    P,
	    Q,
	    B1).

fpt(Z, C, B1, mian, A/B, C1, wym([], D1, E1), F1, O, M, F, I, R, po) :-
	goal(flicz(mian,
		   A/B,
		   nuzg,
		   P,
		   G,
		   J,
		   S,
		   na),
	     C,
	     D,
	     G1),
	goal(fno(dop,
		 A/B,
		 I1,
		 U,
		 E,
		 Q,
		 pre,
		 N,
		 H,
		 L,
		 T,
		 po),
	     D,
	     A1,
	     H1),
	różne(E, uzg.nuzg.egz),
	A=r(_, nmo(_)),
	obldest(X, [F, G, H]),
	oblink(K, I, J),
	oblink(K, J, L),
	oblneg(-ani, W, M, N),
	oblzap(V, [O, P, Q]),
	oblpk(Y, [R, S, T]),
	register(fno(mian,
		     r(mn(n), nmo(np(n)))/poj,
		     3,
		     U,
		     nuzg,
		     V,
		     K1,
		     W,
		     X,
		     K,
		     Y,
		     L1),
		 Z,
		 A1,
		 nol13,
		 
		 [ B1/fpt(mian, A/B, C1, wym([], D1, E1), F1, O, M, F, I, R, po),
		   C,
		   G1/flicz(mian, A/B, nuzg, P, G, J, S, na),
		   D,
		   H1/fno(dop, A/B, I1, U, E, Q, pre, N, H, L, T, po)
		 ],
		 J1),
	fno(Z,
	    A1,
	    J1,
	    mian,
	    r(mn(n), nmo(np(n)))/poj,
	    3,
	    U,
	    nuzg,
	    V,
	    K1,
	    W,
	    X,
	    K,
	    Y,
	    L1).

fpt(M1, B, O1, Z, A1, G1, A, H1, B1, Y, C1, D1, E1, na) :-
	A=wym(_, _, [_|_]),
	do_sequence_of(P1,
		       [],
		       B,
		       N1,
		       [fps(_, _, _, C, D, E, po)/ (oblzap_iter(F, P, K), obldest_iter(G, C, L), oblink_iter(H, D, M), sprawdz_pk_iter(I, E, N), conajmniej1(J, Q, O))/[]/[]/[]/ ([F, G, H, I, J]/[])/ ([K, L, M, N, O]/[]), fpm(_, _, _, P, _, C, D, E, po)/ (oblzap_iter(F, P, K), obldest_iter(G, C, L), oblink_iter(H, D, M), sprawdz_pk_iter(I, E, N), conajmniej1(J, Q, O))/[]/[]/[]/ ([F, G, H, I, J]/[])/ ([K, L, M, N, O]/[]), fw(R, S, T, U, V, post, tak, C, D, E, po)/ (oblzap_iter(F, P, K), obldest_iter(G, C, L), oblink_iter(H, D, M), sprawdz_pk_iter(I, E, N), conajmniej1(J, Q, O), oblwym_iter(W, R, X))/[S, T, U, V]/[A]/[F1]/ ([F, G, H, I, J]/[W])/ ([K, L, M, N, O]/[X]), modpart(fpt, Y, C, D, E, po)/ (oblzap_iter(F, P, K), obldest_iter(G, C, L), oblink_iter(H, D, M), sprawdz_pk_iter(I, E, N), conajmniej1(J, Q, O))/[Y]/[]/[]/ ([F, G, H, I, J]/[])/ ([K, L, M, N, O]/[]), modjaki(Z, A1, P, C, D, E, po)/ (oblzap_iter(F, P, K), obldest_iter(G, C, L), oblink_iter(H, D, M), sprawdz_pk_iter(I, E, N), conajmniej1(J, Q, O))/[Z, A1]/[]/[]/ ([F, G, H, I, J]/[])/ ([K, L, M, N, O]/[])]/[B1, C1, D1, E1, 0]/[I1, J1, K1, L1, 1]),
	wymagania_zamknij(F1),
	register(fpt(Z,
		     A1,
		     G1,
		     wym(R1, S1, bw),
		     H1,
		     I1,
		     Y,
		     J1,
		     K1,
		     L1,
		     T1),
		 M1,
		 N1,
		 pts1,
		 
		 [ O1/fpt(Z, A1, G1, A, H1, B1, Y, C1, D1, E1, na)
		 | P1
		 ],
		 Q1),
	fpt(M1,
	    N1,
	    Q1,
	    Z,
	    A1,
	    G1,
	    wym(R1, S1, bw),
	    H1,
	    I1,
	    Y,
	    J1,
	    K1,
	    L1,
	    T1).

fpt(S, A, U, C, D/E, N, wym([], V, W), O, F, G, I, Q, K, po) :-
	goal(przec(L, po), A, B, X),
	goal(spójnik(rc, Z, ni, na), B, H, Y),
	goal(fpt(C,
		 D/E,
		 B1,
		 wym([], C1, D1),
		 E1,
		 F,
		 G,
		 J,
		 ni,
		 M,
		 po),
	     H,
	     T,
	     A1),
	obldest_fno_iter(I, J, P),
	oblpk(R, [K, L, M]),
	register(fpt(C,
		     D/E,
		     N,
		     wym([], G1, [[]]),
		     O,
		     F,
		     G,
		     P,
		     Q,
		     R,
		     H1),
		 S,
		 T,
		 ptr1,
		 
		 [ U/fpt(C, D/E, N, wym([], V, W), O, F, G, I, Q, K, po),
		   A,
		   X/przec(L, po),
		   B,
		   Y/spójnik(rc, Z, ni, na),
		   H,
		   A1/fpt(C, D/E, B1, wym([], C1, D1), E1, F, G, J, ni, M, po)
		 ],
		 F1),
	fpt(S,
	    T,
	    F1,
	    C,
	    D/E,
	    N,
	    wym([], G1, [[]]),
	    O,
	    F,
	    G,
	    P,
	    Q,
	    R,
	    H1).

fpt(V, B, X, E, F/G, Q, wym([], Y, Z), R, H, I, A, T, M, po) :-
	tylko_neut_pyt(A),
	goal(przec(N, po), B, C, A1),
	goal(spójnik(rc, D, ni, po), C, J, B1),
	member(D, [czyli, więc, mianowicie, raczej]),
	goal(fpt(E,
		 F/G,
		 D1,
		 wym([], E1, F1),
		 G1,
		 H,
		 I,
		 L,
		 ni,
		 O,
		 po),
	     J,
	     K,
	     C1),
	goal(przec(P, po), K, W, H1),
	obldest_fno_iter(A, L, S),
	oblpk(U, [M, N, O, P]),
	register(fpt(E,
		     F/G,
		     Q,
		     wym([], J1, [[]]),
		     R,
		     H,
		     I,
		     S,
		     T,
		     U,
		     K1),
		 V,
		 W,
		 ptr3,
		 
		 [ X/fpt(E, F/G, Q, wym([], Y, Z), R, H, I, A, T, M, po),
		   B,
		   A1/przec(N, po),
		   C,
		   B1/spójnik(rc, D, ni, po),
		   J,
		   C1/fpt(E, F/G, D1, wym([], E1, F1), G1, H, I, L, ni, O, po),
		   K,
		   H1/przec(P, po)
		 ],
		 I1),
	fpt(V,
	    W,
	    I1,
	    E,
	    F/G,
	    Q,
	    wym([], J1, [[]]),
	    R,
	    H,
	    I,
	    S,
	    T,
	    U,
	    K1).

fpt(H1, F, J1, A, B/C, K1, wym([], L1, M1), N1, D, E, L, F1, B1, po) :-
	do_sequence_of(O1,
		       
		       [ G,
			 T/spójnik(szk, R, ni, na),
			 S,
			 A1/fpt(A, B/C, V, wym([], W, X), Y, D, E, Z, ni, M, po)
		       ],
		       F,
		       G,
		       [[spójnik(sz, przec, ni, po), fpt(A, B/C, J, wym([], _, _), K, D, E, I, ni, H, po)]/ (dwa_na_listę(N, [ (p| wp), H], P), obldest_fno_iter(O, I, Q))/[A, B, C, J, K, D, E]/[C1, L]/[[U, M], D1]/ ([]/[N, O])/ ([]/[P, Q])]/[]/[]),
	goal(spójnik(szk, R, ni, na), G, S, T),
	(   R=przec
	->  U= (p| wp)
	;   U= (0| 0)
	),
	sprawdz_neg(R, E),
	goal(fpt(A,
		 B/C,
		 V,
		 wym([], W, X),
		 Y,
		 D,
		 E,
		 Z,
		 ni,
		 M,
		 po),
	     S,
	     I1,
	     A1),
	oblpk(G1, [B1|C1]),
	obldest_fno_iter(D1, Z, E1),
	register(fpt(A,
		     B/C,
		     Q1,
		     wym([], R1, [[]]),
		     S1,
		     D,
		     E,
		     E1,
		     F1,
		     G1,
		     T1),
		 H1,
		 I1,
		 ptsz3,
		 
		 [ J1/fpt(A, B/C, K1, wym([], L1, M1), N1, D, E, L, F1, B1, po)
		 | O1
		 ],
		 P1),
	fpt(H1,
	    I1,
	    P1,
	    A,
	    B/C,
	    Q1,
	    wym([], R1, [[]]),
	    S1,
	    D,
	    E,
	    E1,
	    F1,
	    G1,
	    T1).

fps(E, F, G, H, I, A, B, C, D, na) :-
	register(fw(advp,
		    K,
		    L,
		    M,
		    N,
		    O,
		    A,
		    B,
		    C,
		    D,
		    P),
		 E,
		 F,
		 wy9,
		 
		 [ G/fps(H, I, A, B, C, D, na)
		 ],
		 J),
	fw(E,
	   F,
	   J,
	   advp,
	   K,
	   L,
	   M,
	   N,
	   O,
	   A,
	   B,
	   C,
	   D,
	   P).

fps(H, A, J, K, L, E, F, G, B, na) :-
	optional(M,
		 [],
		 A,
		 I,
		 przec(C, po),
		 { oblpk(D, [ (bp| p), B, C])
		 },
		 { D=B
		 }),
	register(fl(O,
		    P,
		    Q,
		    R,
		    E,
		    F,
		    G,
		    D,
		    S),
		 H,
		 I,
		 lu3,
		 
		 [ J/fps(K, L, E, F, G, B, na)
		 | M
		 ],
		 N),
	fl(H,
	   I,
	   N,
	   O,
	   P,
	   Q,
	   R,
	   E,
	   F,
	   G,
	   D,
	   S).

fps(Q1, B, S1, T1, U1, A, N, O, P, po) :-
	do_sequence_of(V1,
		       
		       [ C,
			 X/fpm(Q, R, S, T, A, U, V, W, na)
		       | B1
		       ],
		       B,
		       C,
		       [fps(_, _, A, F, D, E, po)/ (obldest_iter(G, M, J), oblink_iter(H, D, K), sprawdz_pk_iter(I, E, L))/[A, F]/[]/[]/ ([G, H, I]/[])/ ([J, K, L]/[]), modpart(fpm, A, M, D, E, po)/ (obldest_iter(G, M, J), oblink_iter(H, D, K), sprawdz_pk_iter(I, E, L))/[A]/[]/[]/ ([G, H, I]/[])/ ([J, K, L]/[])]/[N, O, P]/[Y, Z, A1]),
	goal(fpm(Q,
		 R,
		 S,
		 T,
		 A,
		 U,
		 V,
		 W,
		 na),
	     C,
	     C1,
	     X),
	S\= (mod),
	obldest_iter(Y, U, L1),
	oblink_iter(Z, V, _),
	sprawdz_pk_iter(A1, W, M1),
	do_sequence_of(B1,
		       [],
		       C1,
		       R1,
		       [fps(_, _, A, F, D1, E1, po)/ (obldest_iter(F1, F, I1), oblink_iter(G1, D1, J1), sprawdz_pk_iter(H1, E1, K1))/[A]/[]/[]/ ([F1, G1, H1]/[])/ ([I1, J1, K1]/[]), modpart(fpm, A, F, D1, E1, po)/ (obldest_iter(F1, F, I1), oblink_iter(G1, D1, J1), sprawdz_pk_iter(H1, E1, K1))/[A]/[]/[]/ ([F1, G1, H1]/[])/ ([I1, J1, K1]/[])]/[L1, Z, M1]/[N1, O1, P1]),
	register(fpm(Q,
		     R,
		     (mod),
		     T,
		     A,
		     N1,
		     O1,
		     P1,
		     X1),
		 Q1,
		 R1,
		 pm5,
		 
		 [ S1/fps(T1, U1, A, N, O, P, po)
		 | V1
		 ],
		 W1),
	fpm(Q1,
	    R1,
	    W1,
	    Q,
	    R,
	    (mod),
	    T,
	    A,
	    N1,
	    O1,
	    P1,
	    X1).

fps(T2, A, V2, W2, X2, Y2, Y, Z, A1, po) :-
	do_sequence_of(Z2,
		       
		       [ B,
			 I1/fpt(W, X, B1, C1, D1, E1, V, F1, G1, H1, na)
		       | O1
		       ],
		       A,
		       B,
		       [fps(_, _, _, C, D, E, po)/ (oblzap_iter(F, N, J), obldest_iter(G, C, K), oblink_iter(H, D, L), sprawdz_pk_iter(I, E, M))/[]/[]/[]/ ([F, G, H, I]/[])/ ([J, K, L, M]/[]), fpm(_, _, _, N, _, C, D, E, po)/ (oblzap_iter(F, N, J), obldest_iter(G, C, K), oblink_iter(H, D, L), sprawdz_pk_iter(I, E, M))/[]/[]/[]/ ([F, G, H, I]/[])/ ([J, K, L, M]/[]), fw(O, P, Q, R, S, post, tak, C, D, E, po)/ (oblzap_iter(F, N, J), obldest_iter(G, C, K), oblink_iter(H, D, L), sprawdz_pk_iter(I, E, M), zroblistę_iter(T, O, U))/[P, Q, R, S]/[[]]/[N1]/ ([F, G, H, I]/[T])/ ([J, K, L, M]/[U]), modpart(fpt, V, C, D, E, po)/ (oblzap_iter(F, N, J), obldest_iter(G, C, K), oblink_iter(H, D, L), sprawdz_pk_iter(I, E, M))/[V]/[]/[]/ ([F, G, H, I]/[])/ ([J, K, L, M]/[]), modjaki(W, X, N, C, D, E, po)/ (oblzap_iter(F, N, J), obldest_iter(G, C, K), oblink_iter(H, D, L), sprawdz_pk_iter(I, E, M))/[W, X]/[]/[]/ ([F, G, H, I]/[])/ ([J, K, L, M]/[])]/[_, Y, Z, A1]/[J1, K1, L1, M1]),
	goal(fpt(W,
		 X,
		 B1,
		 C1,
		 D1,
		 E1,
		 V,
		 F1,
		 G1,
		 H1,
		 na),
	     B,
	     P1,
	     I1),
	C1=wym(_, _, [_|_]),
	oblzap_iter(J1, E1, K2),
	obldest_iter(K1, F1, L2),
	oblink_iter(L1, G1, M2),
	sprawdz_pk_iter(M1, H1, N2),
	wyjmijl(N1, C1, H2),
	do_sequence_of(O1,
		       [],
		       P1,
		       U2,
		       [fps(_, _, _, Q1, R1, S1, po)/ (oblzap_iter(T1, B2, X1), obldest_iter(U1, Q1, Y1), oblink_iter(V1, R1, Z1), sprawdz_pk_iter(W1, S1, A2))/[]/[]/[]/ ([T1, U1, V1, W1]/[])/ ([X1, Y1, Z1, A2]/[]), fpm(_, _, _, B2, _, Q1, R1, S1, po)/ (oblzap_iter(T1, B2, X1), obldest_iter(U1, Q1, Y1), oblink_iter(V1, R1, Z1), sprawdz_pk_iter(W1, S1, A2))/[]/[]/[]/ ([T1, U1, V1, W1]/[])/ ([X1, Y1, Z1, A2]/[]), fw(C2, D2, E2, F2, G2, post, tak, Q1, R1, S1, po)/ (oblzap_iter(T1, B2, X1), obldest_iter(U1, Q1, Y1), oblink_iter(V1, R1, Z1), sprawdz_pk_iter(W1, S1, A2), oblwym_iter(I2, C2, J2))/[D2, E2, F2, G2]/[H2]/[O2]/ ([T1, U1, V1, W1]/[I2])/ ([X1, Y1, Z1, A2]/[J2]), modpart(fpt, V, Q1, R1, S1, po)/ (oblzap_iter(T1, B2, X1), obldest_iter(U1, Q1, Y1), oblink_iter(V1, R1, Z1), sprawdz_pk_iter(W1, S1, A2))/[V]/[]/[]/ ([T1, U1, V1, W1]/[])/ ([X1, Y1, Z1, A2]/[]), modjaki(W, X, B2, Q1, R1, S1, po)/ (oblzap_iter(T1, B2, X1), obldest_iter(U1, Q1, Y1), oblink_iter(V1, R1, Z1), sprawdz_pk_iter(W1, S1, A2))/[W, X]/[]/[]/ ([T1, U1, V1, W1]/[])/ ([X1, Y1, Z1, A2]/[])]/[K2, L2, M2, N2]/[P2, Q2, R2, S2]),
	wymagania_zamknij(O2),
	register(fpt(W,
		     X,
		     B1,
		     wym(B3, C3, bw),
		     D1,
		     P2,
		     V,
		     Q2,
		     R2,
		     S2,
		     D3),
		 T2,
		 U2,
		 pts2,
		 
		 [ V2/fps(W2, X2, Y2, Y, Z, A1, po)
		 | Z2
		 ],
		 A3),
	fpt(T2,
	    U2,
	    A3,
	    W,
	    X,
	    B1,
	    wym(B3, C3, bw),
	    D1,
	    P2,
	    V,
	    Q2,
	    R2,
	    S2,
	    D3).

fps(X, B, Z, T, A, C, Q, R, S, na) :-
	A\= (mod),
	do_sequence_of(A1,
		       [],
		       B,
		       Y,
		       [fpm(_, _, O, _, C, D, E, F, po)/ (obldest_iter(G, D, K), oblink_iter(H, E, L), sprawdz_pk_iter(I, F, M), conajmniej1(J, P, N))/[C]/[]/[]/ ([G, H, I, J]/[])/ ([K, L, M, N]/[]), fps(_, O, C, D, E, F, po)/ (obldest_iter(G, D, K), oblink_iter(H, E, L), sprawdz_pk_iter(I, F, M), conajmniej1(J, P, N))/[C]/[]/[]/ ([G, H, I, J]/[])/ ([K, L, M, N]/[]), modpart(fpt, C, D, E, F, po)/ (obldest_iter(G, D, K), oblink_iter(H, E, L), sprawdz_pk_iter(I, F, M), conajmniej1(J, P, N))/[C]/[]/[]/ ([G, H, I, J]/[])/ ([K, L, M, N]/[])]/[Q, R, S, 0]/[U, V, W, 1]),
	register(fps(T, mod, C, U, V, W, C1),
		 X,
		 Y,
		 psm1,
		 
		 [ Z/fps(T, A, C, Q, R, S, na)
		 | A1
		 ],
		 B1),
	fps(X,
	    Y,
	    B1,
	    T,
	    (mod),
	    C,
	    U,
	    V,
	    W,
	    C1).

fps(R1, B, T1, U1, V1, A, N, O, P, po) :-
	do_sequence_of(W1,
		       
		       [ C,
			 V/fps(Q, R, A, S, T, U, na)
		       | Z
		       ],
		       B,
		       C,
		       [fpm(_, _, M, _, A, D, E, F, po)/ (obldest_iter(G, D, J), oblink_iter(H, E, K), sprawdz_pk_iter(I, F, L))/[A]/[]/[]/ ([G, H, I]/[])/ ([J, K, L]/[]), fps(_, M, A, D, E, F, po)/ (obldest_iter(G, D, J), oblink_iter(H, E, K), sprawdz_pk_iter(I, F, L))/[A]/[]/[]/ ([G, H, I]/[])/ ([J, K, L]/[]), modpart(fpt, A, D, E, F, po)/ (obldest_iter(G, D, J), oblink_iter(H, E, K), sprawdz_pk_iter(I, F, L))/[A]/[]/[]/ ([G, H, I]/[])/ ([J, K, L]/[])]/[N, O, P]/[W, X, Y]),
	goal(fps(Q, R, A, S, T, U, na),
	     C,
	     A1,
	     V),
	R\= (mod),
	obldest_iter(W, S, L1),
	oblink_iter(X, T, M1),
	sprawdz_pk_iter(Y, U, N1),
	do_sequence_of(Z,
		       [],
		       A1,
		       S1,
		       [fpm(_, _, K1, _, A, B1, C1, D1, po)/ (obldest_iter(E1, B1, H1), oblink_iter(F1, C1, I1), sprawdz_pk_iter(G1, D1, J1))/[A]/[]/[]/ ([E1, F1, G1]/[])/ ([H1, I1, J1]/[]), fps(_, K1, A, B1, C1, D1, po)/ (obldest_iter(E1, B1, H1), oblink_iter(F1, C1, I1), sprawdz_pk_iter(G1, D1, J1))/[A]/[]/[]/ ([E1, F1, G1]/[])/ ([H1, I1, J1]/[]), modpart(fpt, A, B1, C1, D1, po)/ (obldest_iter(E1, B1, H1), oblink_iter(F1, C1, I1), sprawdz_pk_iter(G1, D1, J1))/[A]/[]/[]/ ([E1, F1, G1]/[])/ ([H1, I1, J1]/[])]/[L1, M1, N1]/[O1, P1, Q1]),
	register(fps(Q, mod, A, O1, P1, Q1, Y1),
		 R1,
		 S1,
		 psm4,
		 
		 [ T1/fps(U1, V1, A, N, O, P, po)
		 | W1
		 ],
		 X1),
	fps(R1,
	    S1,
	    X1,
	    Q,
	    (mod),
	    A,
	    O1,
	    P1,
	    Q1,
	    Y1).

fps(F1, B, H1, B1, Z, A, G, D1, W, po) :-
	do_sequence_of(I1,
		       
		       [ C,
			 R/spójnik(szk, P, ni, na),
			 Q,
			 V/fps(T, I, A, U, ni, H, po)
		       ],
		       B,
		       C,
		       [[spójnik(sz, przec, ni, po), fps(_, F, A, E, ni, D, po)]/ (dwa_na_listę(J, [ (p| wp), D], M), obldest_fno_iter(K, E, N), jeden_na_listę(L, F, O))/[A]/[X, G, A1]/[[S, H], Y, [I]]/ ([]/[J, K, L])/ ([]/[M, N, O])]/[]/[]),
	goal(spójnik(szk, P, ni, na), C, Q, R),
	(   P=przec
	->  S= (p| wp)
	;   S= (0| 0)
	),
	sprawdz_neg(P, A),
	goal(fps(T, I, A, U, ni, H, po),
	     Q,
	     G1,
	     V),
	oblpk(E1, [W|X]),
	obldest_fno_iter(Y, U, C1),
	różne(sp:sz:P, [Z|A1]),
	różne(sp:sz:przec, [Z|A1]),
	(   P\=przec
	;   I\=sp:sz:_
	),
	register(fps(B1,
		     sp:sz:P,
		     A,
		     C1,
		     D1,
		     E1,
		     K1),
		 F1,
		 G1,
		 pss3,
		 
		 [ H1/fps(B1, Z, A, G, D1, W, po)
		 | I1
		 ],
		 J1),
	fps(F1,
	    G1,
	    J1,
	    B1,
	    sp:sz:P,
	    A,
	    C1,
	    D1,
	    E1,
	    K1).

dwukropek(W, A, Y, po) :-
	optional(Z, B, A, C, pauza(po), {}, {}),
	optional(B,
		 
		 [ D,
		   P/zdanie(F, G, H, I, J, K, L, M, N, O, na)
		 | Q
		 ],
		 C,
		 D,
		 cudz(o, po),
		 { E=t
		 },
		 { E=f
		 }),
	goal(zdanie(F,
		    G,
		    H,
		    I,
		    J,
		    K,
		    L,
		    M,
		    N,
		    O,
		    na),
	     D,
	     R,
	     P),
	F\=bc(_),
	optional(Q,
		 T,
		 R,
		 U,
		 znakkonca(S, po),
		 { zgodnyznakk(M, S)
		 },
		 {}),
	optional(T,
		 [],
		 U,
		 X,
		 cudz(z, po),
		 { E=t
		 },
		 { E=f
		 }),
	oblpk(V, [ (0| wp), O, (p| wkw)]),
	register(fw(or,
		    B1,
		    C1,
		    D1,
		    E1,
		    post,
		    F1,
		    neut,
		    ni,
		    V,
		    G1),
		 W,
		 X,
		 wyor3,
		 [Y/dwukropek(po)|Z],
		 A1),
	fw(W,
	   X,
	   A1,
	   or,
	   B1,
	   C1,
	   D1,
	   E1,
	   post,
	   F1,
	   neut,
	   ni,
	   V,
	   G1).

przec(J, A, L, C, po) :-
	goal(fpm(N,
		 O,
		 P,
		 Q,
		 G,
		 H,
		 I,
		 D,
		 na),
	     A,
	     B,
	     M),
	optional(R,
		 [],
		 B,
		 K,
		 przec(E, po),
		 { oblpk(F, [C, D, E])
		 },
		 { oblpk(F, [C, D, (p| bp)])
		 }),
	register(fl(T,
		    U,
		    V,
		    W,
		    G,
		    H,
		    I,
		    F,
		    X),
		 J,
		 K,
		 lu1p,
		 
		 [ L/przec(C, po),
		   A,
		   M/fpm(N, O, P, Q, G, H, I, D, na)
		 | R
		 ],
		 S),
	fl(J,
	   K,
	   S,
	   T,
	   U,
	   V,
	   W,
	   G,
	   H,
	   I,
	   F,
	   X).

przec(L, A, N, E, po) :-
	goal(fno(B,
		 P,
		 Q,
		 wym([], R, S),
		 C,
		 T,
		 pre,
		 I,
		 J,
		 K,
		 F,
		 na),
	     A,
	     D,
	     O),
	równe(B, [cel, bier, narz]),
	C\=przym,
	optional(U,
		 [],
		 D,
		 M,
		 przec(G, po),
		 { oblpk(H, [E, F, G])
		 },
		 { oblpk(H, [E, F, (p| bp)])
		 }),
	register(fl(W,
		    X,
		    Y,
		    Z,
		    I,
		    J,
		    K,
		    H,
		    A1),
		 L,
		 M,
		 lu2p,
		 
		 [ N/przec(E, po),
		   A,
		   O/fno(B, P, Q, wym([], R, S), C, T, pre, I, J, K, F, na)
		 | U
		 ],
		 V),
	fl(L,
	   M,
	   V,
	   W,
	   X,
	   Y,
	   Z,
	   I,
	   J,
	   K,
	   H,
	   A1).

przec(J, A, L, C, po) :-
	goal(fps(N, O, G, H, I, D, na),
	     A,
	     B,
	     M),
	optional(P,
		 [],
		 B,
		 K,
		 przec(E, po),
		 { oblpk(F, [C, D, E])
		 },
		 { oblpk(F, [C, D, (p| bp)])
		 }),
	register(fl(R,
		    S,
		    T,
		    U,
		    G,
		    H,
		    I,
		    F,
		    V),
		 J,
		 K,
		 lu3p,
		 
		 [ L/przec(C, po),
		   A,
		   M/fps(N, O, G, H, I, D, na)
		 | P
		 ],
		 Q),
	fl(J,
	   K,
	   Q,
	   R,
	   S,
	   T,
	   U,
	   G,
	   H,
	   I,
	   F,
	   V).

przec(I, A, K, C, po) :-
	goal(modpart(fin, G, H, ni, D, na),
	     A,
	     B,
	     L),
	optional(M,
		 [],
		 B,
		 J,
		 przec(E, po),
		 { oblpk(F, [C, D, E])
		 },
		 { oblpk(F, [C, D, (p| bp)])
		 }),
	register(fl(O,
		    P,
		    Q,
		    R,
		    G,
		    H,
		    ni,
		    F,
		    S),
		 I,
		 J,
		 lu4p,
		 
		 [ K/przec(C, po),
		   A,
		   L/modpart(fin, G, H, ni, D, na)
		 | M
		 ],
		 N),
	fl(I,
	   J,
	   N,
	   O,
	   P,
	   Q,
	   R,
	   G,
	   H,
	   ni,
	   F,
	   S).

przec(J, A, L, F, po) :-
	goal(fno(B,
		 H,
		 N,
		 wym([], O, P),
		 C,
		 Q,
		 pre,
		 R,
		 neut,
		 ni,
		 G,
		 na),
	     A,
	     D,
	     M),
	member(B, [wol, mian]),
	C\=przym,
	optional(S,
		 [],
		 D,
		 K,
		 przec(E, po),
		 { B=wol
		 },
		 { (   B=wol
		   *-> E= (p| bp)
		   ;   E= (p| wkw)
		   )
		 }),
	oblpk(I, [F, G, E]),
	register(fl(U,
		    V,
		    H,
		    2,
		    W,
		    neut,
		    ni,
		    I,
		    X),
		 J,
		 K,
		 lu12,
		 
		 [ L/przec(F, po),
		   A,
		   M/fno(B, H, N, wym([], O, P), C, Q, pre, R, neut, ni, G, na)
		 | S
		 ],
		 T),
	fl(J,
	   K,
	   T,
	   U,
	   V,
	   H,
	   2,
	   W,
	   neut,
	   ni,
	   I,
	   X).

przec(I, A, K, E, po) :-
	goal(fno(wol,
		 M,
		 N,
		 wym([], O, P),
		 B,
		 Q,
		 pre,
		 R,
		 neut,
		 ni,
		 F,
		 na),
	     A,
	     C,
	     L),
	B\=przym,
	optional(S,
		 [],
		 C,
		 J,
		 przec(D, po),
		 {},
		 { D= (p| bp)
		 }),
	równe(G, [1, 3]),
	oblpk(H, [E, F, D]),
	register(fl(U,
		    V,
		    W,
		    G,
		    X,
		    neut,
		    ni,
		    H,
		    Y),
		 I,
		 J,
		 lu13,
		 
		 [ K/przec(E, po),
		   A,
		   L/fno(wol, M, N, wym([], O, P), B, Q, pre, R, neut, ni, F, na)
		 | S
		 ],
		 T),
	fl(I,
	   J,
	   T,
	   U,
	   V,
	   W,
	   G,
	   X,
	   neut,
	   ni,
	   H,
	   Y).

przec(K, A, M, D, po) :-
	goal(fpt(B,
		 O,
		 P,
		 wym([], Q, R),
		 S,
		 T,
		 H,
		 I,
		 J,
		 E,
		 na),
	     A,
	     C,
	     N),
	równe(B, [mian, dop, cel, bier, narz]),
	optional(U,
		 [],
		 C,
		 L,
		 przec(F, po),
		 { oblpk(G, [D, E, F])
		 },
		 { oblpk(G, [D, E, (p| bp)])
		 }),
	register(fl(W,
		    X,
		    Y,
		    Z,
		    H,
		    I,
		    J,
		    G,
		    A1),
		 K,
		 L,
		 lu15p,
		 
		 [ M/przec(D, po),
		   A,
		   N/fpt(B, O, P, wym([], Q, R), S, T, H, I, J, E, na)
		 | U
		 ],
		 V),
	fl(K,
	   L,
	   V,
	   W,
	   X,
	   Y,
	   Z,
	   H,
	   I,
	   J,
	   G,
	   A1).

przec(J, A, L, D, po) :-
	goal(fwe(psw,
		 N,
		 G,
		 O,
		 P,
		 Q,
		 F,
		 R,
		 neut,
		 H,
		 E,
		 na),
	     A,
	     B,
	     M),
	optional(S,
		 [],
		 B,
		 K,
		 przec(C, po),
		 {},
		 { C= (p| bp)
		 }),
	oblpk(I, [D, E, C]),
	wymagania_zamknij(F),
	register(fl(U,
		    G,
		    V,
		    W,
		    X,
		    neut,
		    H,
		    I,
		    Y),
		 J,
		 K,
		 luw1,
		 
		 [ L/przec(D, po),
		   A,
		   M/fwe(psw, N, G, O, P, Q, F, R, neut, H, E, na)
		 | S
		 ],
		 T),
	fl(J,
	   K,
	   T,
	   U,
	   G,
	   V,
	   W,
	   X,
	   neut,
	   H,
	   I,
	   Y).

przec(I, A, K, D, po) :-
	goal(fwe(psu,
		 M,
		 prze,
		 N,
		 O,
		 P,
		 F,
		 Q,
		 neut,
		 G,
		 E,
		 na),
	     A,
	     B,
	     L),
	optional(R,
		 [],
		 B,
		 J,
		 przec(C, po),
		 {},
		 { C= (p| bp)
		 }),
	oblpk(H, [D, E, C]),
	wymagania_zamknij(F),
	register(fl(T,
		    U,
		    V,
		    W,
		    X,
		    neut,
		    G,
		    H,
		    Y),
		 I,
		 J,
		 luw2,
		 
		 [ K/przec(D, po),
		   A,
		   L/fwe(psu, M, prze, N, O, P, F, Q, neut, G, E, na)
		 | R
		 ],
		 S),
	fl(I,
	   J,
	   S,
	   T,
	   U,
	   V,
	   W,
	   X,
	   neut,
	   G,
	   H,
	   Y).

przec(J, A, L, E, po) :-
	goal(fwe(psu,
		 N,
		 D,
		 O,
		 P,
		 Q,
		 G,
		 R,
		 neut,
		 H,
		 F,
		 na),
	     A,
	     B,
	     M),
	optional(S,
		 [],
		 B,
		 K,
		 przec(C, po),
		 {},
		 { C= (p| bp)
		 }),
	D\=prze,
	oblpk(I, [E, F, C]),
	wymagania_zamknij(G),
	register(fl(U,
		    przy,
		    V,
		    W,
		    X,
		    neut,
		    H,
		    I,
		    Y),
		 J,
		 K,
		 luw3,
		 
		 [ L/przec(E, po),
		   A,
		   M/fwe(psu, N, D, O, P, Q, G, R, neut, H, F, na)
		 | S
		 ],
		 T),
	fl(J,
	   K,
	   T,
	   U,
	   przy,
	   V,
	   W,
	   X,
	   neut,
	   H,
	   I,
	   Y).

przec(N, A, P, F, po) :-
	goal(zdanie(D,
		    H,
		    I,
		    J,
		    R,
		    S,
		    K,
		    E,
		    L,
		    G,
		    na),
	     A,
	     B,
	     Q),
	optional(T,
		 [],
		 B,
		 O,
		 przec(C, po),
		 {},
		 { C= (p| bp)
		 }),
	D\=bc(_),
	równe(E, [wz(_, _), pz]),
	oblpk(M, [F, G, C]),
	register(fzd(E,
		     nk,
		     H,
		     I,
		     J,
		     K,
		     L,
		     M,
		     V),
		 N,
		 O,
		 zd1,
		 
		 [ P/przec(F, po),
		   A,
		   Q/zdanie(D, H, I, J, R, S, K, E, L, G, na)
		 | T
		 ],
		 U),
	fzd(N,
	    O,
	    U,
	    E,
	    nk,
	    H,
	    I,
	    J,
	    K,
	    L,
	    M,
	    V).

przec(O, A, Q, G, po) :-
	goal(spójnik(po, F, M, na), A, B, R),
	goal(zdanie(E,
		    I,
		    J,
		    K,
		    T,
		    U,
		    L,
		    neut,
		    ni,
		    H,
		    po),
	     B,
	     C,
	     S),
	optional(V,
		 [],
		 C,
		 P,
		 przec(D, po),
		 {},
		 { D= (p| bp)
		 }),
	E\=bc(_),
	member(F,
	       [aż, chociaż, czy, dopóki, gdy, jak, jeśli, podczas, ponieważ, zanim, że]),
	oblpk(N, [G, H, D]),
	(   E=bok
	*-> member(F, [gdy, jeśli])
	;   true
	),
	register(fzd(F,
		     nk,
		     I,
		     J,
		     K,
		     L,
		     M,
		     N,
		     X),
		 O,
		 P,
		 zds1,
		 
		 [ Q/przec(G, po),
		   A,
		   R/spójnik(po, F, M, na),
		   B,
		   S/zdanie(E, I, J, K, T, U, L, neut, ni, H, po)
		 | V
		 ],
		 W),
	fzd(O,
	    P,
	    W,
	    F,
	    nk,
	    I,
	    J,
	    K,
	    L,
	    M,
	    N,
	    X).

przec(Q, A, S, I, po) :-
	goal(spójnik(po, H, O, na), A, B, T),
	goal(zdanie(C,
		    K,
		    L,
		    M,
		    V,
		    D,
		    N,
		    E,
		    ni,
		    J,
		    po),
	     B,
	     F,
	     U),
	(   C=os
	*-> member(D/E, [3/neut, _/agl])
	;   C\=bc(_)
	),
	optional(W,
		 [],
		 F,
		 R,
		 przec(G, po),
		 {},
		 { G= (p| bp)
		 }),
	member(H, [choćby, gdyby, jakby, jakoby, żeby]),
	oblpk(P, [I, J, G]),
	register(fzd(H,
		     nk,
		     K,
		     L,
		     M,
		     N,
		     O,
		     P,
		     Y),
		 Q,
		 R,
		 zds2,
		 
		 [ S/przec(I, po),
		   A,
		   T/spójnik(po, H, O, na),
		   B,
		   U/zdanie(C, K, L, M, V, D, N, E, ni, J, po)
		 | W
		 ],
		 X),
	fzd(Q,
	    R,
	    X,
	    H,
	    nk,
	    K,
	    L,
	    M,
	    N,
	    O,
	    P,
	    Y).

modpart(H, A, J, fin, E, F, G, B, na) :-
	optional(K,
		 [],
		 A,
		 I,
		 przec(C, po),
		 { oblpk(D, [ (bp| p), B, C])
		 },
		 { D=B
		 }),
	register(fl(M,
		    N,
		    O,
		    P,
		    E,
		    F,
		    G,
		    D,
		    Q),
		 H,
		 I,
		 lu4,
		 
		 [ J/modpart(fin, E, F, G, B, na)
		 | K
		 ],
		 L),
	fl(H,
	   I,
	   L,
	   M,
	   N,
	   O,
	   P,
	   E,
	   F,
	   G,
	   D,
	   Q).

modpart(L3, B, N3, fno, A, D1, E1, F1, po) :-
	do_sequence_of(O3,
		       
		       [ C,
			 P1/fno(G1, E/F, H1, I1, J1, K1, L1, A, M1, N1, O1, na)
		       | W1
		       ],
		       B,
		       C,
		       [[optional(przec(D, po), {}, {D= (bp| p)}), fpt(M, E/F, _, wym([], _, _), _, H, A, I, J, K, po), optional(przec(G, po), {}, {G= (p| bp)})]/ (oblzap_iter(N, H, R), obldest_iter(O, I, S), oblink_iter(P, J, T), sprawdz_pk_iter(Q, L, U), sprawdz_fpt_noa(D/K/G/L))/[M, E, F, A]/[]/[]/ ([N, O, P, Q]/[])/ ([R, S, T, U]/[]), fpm(_, _, _, H, A, I, J, L, po)/ (oblzap_iter(N, H, R), obldest_iter(O, I, S), oblink_iter(P, J, T), sprawdz_pk_iter(Q, L, U))/[A]/[]/[]/ ([N, O, P, Q]/[])/ ([R, S, T, U]/[]), fno(dop, _, 3, wym([], _, _), V, H, pre, A, I, J, L, po)/ (oblzap_iter(N, H, R), obldest_iter(O, I, S), oblink_iter(P, J, T), sprawdz_pk_iter(Q, L, U), sprawdz_kl_nod_prehead(Q1/V))/[A]/[]/[]/ ([N, O, P, Q]/[])/ ([R, S, T, U]/[]), fw(W, X, Y, Z, A1, post, A, I, ni, L, po)/ (oblzap_iter(N, H, R), obldest_iter(O, I, S), oblink_iter(P, J, T), sprawdz_pk_iter(Q, L, U), zroblistę_iter(B1, W, C1))/[X, Y, Z, A1, A]/[[]]/[V1]/ ([N, O, P, Q]/[B1])/ ([R, S, T, U]/[C1]), modpart(fno, A, I, ni, L, po)/ (oblzap_iter(N, H, R), obldest_iter(O, I, S), oblink_iter(P, J, T), sprawdz_pk_iter(Q, L, U))/[A]/[]/[]/ ([N, O, P, Q]/[])/ ([R, S, T, U]/[])]/[bzap, D1, E1, F1]/[R1, S1, T1, U1]),
	goal(fno(G1,
		 E/F,
		 H1,
		 I1,
		 J1,
		 K1,
		 L1,
		 A,
		 M1,
		 N1,
		 O1,
		 na),
	     C,
	     X1,
	     P1),
	I1=wym(_, _, [_|_]),
	sprawdz_kl_noa(J1, G1, M),
	sprawdz_kl_nod_head(Q1, J1),
	oblzap_iter(R1, K1, C3),
	obldest_iter(S1, M1, D3),
	oblink_iter(T1, N1, E3),
	sprawdz_pk_iter(U1, O1, F3),
	wyjmijl(V1, I1, Z2),
	do_sequence_of(W1,
		       [],
		       X1,
		       M3,
		       [[optional(przec(Y1, po), {}, {Y1= (bp| p)}), fpt(M, E/F, _, wym([], _, _), _, A2, A, B2, C2, D2, po), optional(przec(Z1, po), {}, {Z1= (p| bp)})]/ (oblzap_iter(F2, A2, J2), obldest_iter(G2, B2, K2), oblink_iter(H2, C2, L2), sprawdz_pk_iter(I2, E2, M2), sprawdz_fpt_noa(Y1/D2/Z1/E2))/[M, E, F, A]/[]/[]/ ([F2, G2, H2, I2]/[])/ ([J2, K2, L2, M2]/[]), fpm(_, _, _, A2, A, B2, C2, E2, po)/ (oblzap_iter(F2, A2, J2), obldest_iter(G2, B2, K2), oblink_iter(H2, C2, L2), sprawdz_pk_iter(I2, E2, M2))/[A]/[]/[]/ ([F2, G2, H2, I2]/[])/ ([J2, K2, L2, M2]/[]), fno(dop, _, 3, wym([], _, _), N2, A2, pre, A, B2, C2, E2, po)/ (oblzap_iter(F2, A2, J2), obldest_iter(G2, B2, K2), oblink_iter(H2, C2, L2), sprawdz_pk_iter(I2, E2, M2), sprawdz_kl_nod(J1/N2))/[A]/[]/[]/ ([F2, G2, H2, I2]/[])/ ([J2, K2, L2, M2]/[]), fzd(O2, nk, P2, Q2, R2, _, ni, E2, po)/ (oblzap_iter(F2, A2, J2), obldest_iter(G2, B2, K2), oblink_iter(H2, C2, L2), sprawdz_pk_iter(I2, E2, M2), sprawdz_fzd_noz(S2, O2, T2))/[P2, Q2, R2]/[E/F/J1/G3]/[_]/ ([F2, G2, H2, I2]/[S2])/ ([J2, K2, L2, M2]/[T2]), fw(U2, V2, W2, X2, Y2, post, A, B2, ni, E2, po)/ (oblzap_iter(F2, A2, J2), obldest_iter(G2, B2, K2), oblink_iter(H2, C2, L2), sprawdz_pk_iter(I2, E2, M2), oblwym_iter(A3, U2, B3))/[V2, W2, X2, Y2, A]/[Z2]/[H3]/ ([F2, G2, H2, I2]/[A3])/ ([J2, K2, L2, M2]/[B3]), modpart(fno, A, B2, ni, E2, po)/ (oblzap_iter(F2, A2, J2), obldest_iter(G2, B2, K2), oblink_iter(H2, C2, L2), sprawdz_pk_iter(I2, E2, M2))/[A]/[]/[]/ ([F2, G2, H2, I2]/[])/ ([J2, K2, L2, M2]/[])]/[C3, D3, E3, F3]/[G3, I3, J3, K3]),
	wymagania_zamknij_nieuważnie(H3),
	register(fno(G1,
		     E/F,
		     H1,
		     wym(Q3, R3, bw),
		     J1,
		     G3,
		     L1,
		     A,
		     I3,
		     J3,
		     K3,
		     S3),
		 L3,
		 M3,
		 nom1,
		 
		 [ N3/modpart(fno, A, D1, E1, F1, po)
		 | O3
		 ],
		 P3),
	fno(L3,
	    M3,
	    P3,
	    G1,
	    E/F,
	    H1,
	    wym(Q3, R3, bw),
	    J1,
	    G3,
	    L1,
	    A,
	    I3,
	    J3,
	    K3,
	    S3).

modpart(Q1, B, S1, fpm, A, N, O, P, po) :-
	do_sequence_of(T1,
		       
		       [ C,
			 X/fpm(Q, R, S, T, A, U, V, W, na)
		       | B1
		       ],
		       B,
		       C,
		       [fps(_, _, A, F, D, E, po)/ (obldest_iter(G, M, J), oblink_iter(H, D, K), sprawdz_pk_iter(I, E, L))/[A, F]/[]/[]/ ([G, H, I]/[])/ ([J, K, L]/[]), modpart(fpm, A, M, D, E, po)/ (obldest_iter(G, M, J), oblink_iter(H, D, K), sprawdz_pk_iter(I, E, L))/[A]/[]/[]/ ([G, H, I]/[])/ ([J, K, L]/[])]/[N, O, P]/[Y, Z, A1]),
	goal(fpm(Q,
		 R,
		 S,
		 T,
		 A,
		 U,
		 V,
		 W,
		 na),
	     C,
	     C1,
	     X),
	S\= (mod),
	obldest_iter(Y, U, L1),
	oblink_iter(Z, V, _),
	sprawdz_pk_iter(A1, W, M1),
	do_sequence_of(B1,
		       [],
		       C1,
		       R1,
		       [fps(_, _, A, F, D1, E1, po)/ (obldest_iter(F1, F, I1), oblink_iter(G1, D1, J1), sprawdz_pk_iter(H1, E1, K1))/[A]/[]/[]/ ([F1, G1, H1]/[])/ ([I1, J1, K1]/[]), modpart(fpm, A, F, D1, E1, po)/ (obldest_iter(F1, F, I1), oblink_iter(G1, D1, J1), sprawdz_pk_iter(H1, E1, K1))/[A]/[]/[]/ ([F1, G1, H1]/[])/ ([I1, J1, K1]/[])]/[L1, Z, M1]/[N1, O1, P1]),
	register(fpm(Q,
		     R,
		     (mod),
		     T,
		     A,
		     N1,
		     O1,
		     P1,
		     V1),
		 Q1,
		 R1,
		 pm3,
		 
		 [ S1/modpart(fpm, A, N, O, P, po)
		 | T1
		 ],
		 U1),
	fpm(Q1,
	    R1,
	    U1,
	    Q,
	    R,
	    (mod),
	    T,
	    A,
	    N1,
	    O1,
	    P1,
	    V1).

modpart(T2, B, V2, fpt, A, Y, Z, A1, po) :-
	do_sequence_of(W2,
		       
		       [ C,
			 I1/fpt(W, X, B1, C1, D1, E1, A, F1, G1, H1, na)
		       | O1
		       ],
		       B,
		       C,
		       [fps(_, _, _, D, E, F, po)/ (oblzap_iter(G, O, K), obldest_iter(H, D, L), oblink_iter(I, E, M), sprawdz_pk_iter(J, F, N))/[]/[]/[]/ ([G, H, I, J]/[])/ ([K, L, M, N]/[]), fpm(_, _, _, O, _, D, E, F, po)/ (oblzap_iter(G, O, K), obldest_iter(H, D, L), oblink_iter(I, E, M), sprawdz_pk_iter(J, F, N))/[]/[]/[]/ ([G, H, I, J]/[])/ ([K, L, M, N]/[]), fw(P, Q, R, S, T, post, tak, D, E, F, po)/ (oblzap_iter(G, O, K), obldest_iter(H, D, L), oblink_iter(I, E, M), sprawdz_pk_iter(J, F, N), zroblistę_iter(U, P, V))/[Q, R, S, T]/[[]]/[N1]/ ([G, H, I, J]/[U])/ ([K, L, M, N]/[V]), modpart(fpt, A, D, E, F, po)/ (oblzap_iter(G, O, K), obldest_iter(H, D, L), oblink_iter(I, E, M), sprawdz_pk_iter(J, F, N))/[A]/[]/[]/ ([G, H, I, J]/[])/ ([K, L, M, N]/[]), modjaki(W, X, O, D, E, F, po)/ (oblzap_iter(G, O, K), obldest_iter(H, D, L), oblink_iter(I, E, M), sprawdz_pk_iter(J, F, N))/[W, X]/[]/[]/ ([G, H, I, J]/[])/ ([K, L, M, N]/[])]/[_, Y, Z, A1]/[J1, K1, L1, M1]),
	goal(fpt(W,
		 X,
		 B1,
		 C1,
		 D1,
		 E1,
		 A,
		 F1,
		 G1,
		 H1,
		 na),
	     C,
	     P1,
	     I1),
	C1=wym(_, _, [_|_]),
	oblzap_iter(J1, E1, K2),
	obldest_iter(K1, F1, L2),
	oblink_iter(L1, G1, M2),
	sprawdz_pk_iter(M1, H1, N2),
	wyjmijl(N1, C1, H2),
	do_sequence_of(O1,
		       [],
		       P1,
		       U2,
		       [fps(_, _, _, Q1, R1, S1, po)/ (oblzap_iter(T1, B2, X1), obldest_iter(U1, Q1, Y1), oblink_iter(V1, R1, Z1), sprawdz_pk_iter(W1, S1, A2))/[]/[]/[]/ ([T1, U1, V1, W1]/[])/ ([X1, Y1, Z1, A2]/[]), fpm(_, _, _, B2, _, Q1, R1, S1, po)/ (oblzap_iter(T1, B2, X1), obldest_iter(U1, Q1, Y1), oblink_iter(V1, R1, Z1), sprawdz_pk_iter(W1, S1, A2))/[]/[]/[]/ ([T1, U1, V1, W1]/[])/ ([X1, Y1, Z1, A2]/[]), fw(C2, D2, E2, F2, G2, post, tak, Q1, R1, S1, po)/ (oblzap_iter(T1, B2, X1), obldest_iter(U1, Q1, Y1), oblink_iter(V1, R1, Z1), sprawdz_pk_iter(W1, S1, A2), oblwym_iter(I2, C2, J2))/[D2, E2, F2, G2]/[H2]/[O2]/ ([T1, U1, V1, W1]/[I2])/ ([X1, Y1, Z1, A2]/[J2]), modpart(fpt, A, Q1, R1, S1, po)/ (oblzap_iter(T1, B2, X1), obldest_iter(U1, Q1, Y1), oblink_iter(V1, R1, Z1), sprawdz_pk_iter(W1, S1, A2))/[A]/[]/[]/ ([T1, U1, V1, W1]/[])/ ([X1, Y1, Z1, A2]/[]), modjaki(W, X, B2, Q1, R1, S1, po)/ (oblzap_iter(T1, B2, X1), obldest_iter(U1, Q1, Y1), oblink_iter(V1, R1, Z1), sprawdz_pk_iter(W1, S1, A2))/[W, X]/[]/[]/ ([T1, U1, V1, W1]/[])/ ([X1, Y1, Z1, A2]/[])]/[K2, L2, M2, N2]/[P2, Q2, R2, S2]),
	wymagania_zamknij(O2),
	register(fpt(W,
		     X,
		     B1,
		     wym(Y2, Z2, bw),
		     D1,
		     P2,
		     A,
		     Q2,
		     R2,
		     S2,
		     A3),
		 T2,
		 U2,
		 ptm3,
		 
		 [ V2/modpart(fpt, A, Y, Z, A1, po)
		 | W2
		 ],
		 X2),
	fpt(T2,
	    U2,
	    X2,
	    W,
	    X,
	    B1,
	    wym(Y2, Z2, bw),
	    D1,
	    P2,
	    A,
	    Q2,
	    R2,
	    S2,
	    A3).

modpart(I1, A, K1, flicz, C, J, G1, K, po) :-
	do_sequence_of(L1,
		       
		       [ B,
			 S/flicz(L, M, N, O, P, ni, Q, R)
		       | V
		       ],
		       A,
		       B,
		       [modpart(flicz, C, D, ni, E, po)/ (obldest_iter(F, D, H), sprawdz_pk_iter(G, E, I))/[C]/[]/[]/ ([F, G]/[])/ ([H, I]/[])]/[J, K]/[T, U]),
	goal(flicz(L,
		   M,
		   N,
		   O,
		   P,
		   ni,
		   Q,
		   R),
	     B,
	     W,
	     S),
	var(R),
	R=na,
	obldest_iter(T, P, D1),
	sprawdz_pk_iter(U, Q, E1),
	do_sequence_of(V,
		       [],
		       W,
		       J1,
		       [modpart(flicz, C, X, ni, Y, po)/ (obldest_iter(Z, X, B1), sprawdz_pk_iter(A1, Y, C1))/[C]/[]/[]/ ([Z, A1]/[])/ ([B1, C1]/[])]/[D1, E1]/[F1, H1]),
	register(flicz(L,
		       M,
		       N,
		       O,
		       F1,
		       G1,
		       H1,
		       na),
		 I1,
		 J1,
		 lim1,
		 
		 [ K1/modpart(flicz, C, J, G1, K, po)
		 | L1
		 ],
		 M1),
	flicz(I1,
	      J1,
	      M1,
	      L,
	      M,
	      N,
	      O,
	      F1,
	      G1,
	      H1,
	      na).

modpart(R1, B, T1, fpt, A, N, O, P, po) :-
	do_sequence_of(U1,
		       
		       [ C,
			 V/fps(Q, R, A, S, T, U, na)
		       | Z
		       ],
		       B,
		       C,
		       [fpm(_, _, M, _, A, D, E, F, po)/ (obldest_iter(G, D, J), oblink_iter(H, E, K), sprawdz_pk_iter(I, F, L))/[A]/[]/[]/ ([G, H, I]/[])/ ([J, K, L]/[]), fps(_, M, A, D, E, F, po)/ (obldest_iter(G, D, J), oblink_iter(H, E, K), sprawdz_pk_iter(I, F, L))/[A]/[]/[]/ ([G, H, I]/[])/ ([J, K, L]/[]), modpart(fpt, A, D, E, F, po)/ (obldest_iter(G, D, J), oblink_iter(H, E, K), sprawdz_pk_iter(I, F, L))/[A]/[]/[]/ ([G, H, I]/[])/ ([J, K, L]/[])]/[N, O, P]/[W, X, Y]),
	goal(fps(Q, R, A, S, T, U, na),
	     C,
	     A1,
	     V),
	R\= (mod),
	obldest_iter(W, S, L1),
	oblink_iter(X, T, M1),
	sprawdz_pk_iter(Y, U, N1),
	do_sequence_of(Z,
		       [],
		       A1,
		       S1,
		       [fpm(_, _, K1, _, A, B1, C1, D1, po)/ (obldest_iter(E1, B1, H1), oblink_iter(F1, C1, I1), sprawdz_pk_iter(G1, D1, J1))/[A]/[]/[]/ ([E1, F1, G1]/[])/ ([H1, I1, J1]/[]), fps(_, K1, A, B1, C1, D1, po)/ (obldest_iter(E1, B1, H1), oblink_iter(F1, C1, I1), sprawdz_pk_iter(G1, D1, J1))/[A]/[]/[]/ ([E1, F1, G1]/[])/ ([H1, I1, J1]/[]), modpart(fpt, A, B1, C1, D1, po)/ (obldest_iter(E1, B1, H1), oblink_iter(F1, C1, I1), sprawdz_pk_iter(G1, D1, J1))/[A]/[]/[]/ ([E1, F1, G1]/[])/ ([H1, I1, J1]/[])]/[L1, M1, N1]/[O1, P1, Q1]),
	register(fps(Q, mod, A, O1, P1, Q1, W1),
		 R1,
		 S1,
		 psm3,
		 
		 [ T1/modpart(fpt, A, N, O, P, po)
		 | U1
		 ],
		 V1),
	fps(R1,
	    S1,
	    V1,
	    Q,
	    (mod),
	    A,
	    O1,
	    P1,
	    Q1,
	    W1).

modpart(H, A, J, B, C, D, ni, G, na) :-
	goal(spójnik(i(E, F), L, ni, po),
	     A,
	     I,
	     K),
	register(modpart(B,
			 C,
			 D,
			 i(E, F),
			 G,
			 N),
		 H,
		 I,
		 mp4,
		 
		 [ J/modpart(B, C, D, ni, G, na),
		   A,
		   K/spójnik(i(E, F), L, ni, po)
		 ],
		 M),
	modpart(H,
		I,
		M,
		B,
		C,
		D,
		i(E, F),
		G,
		N).

formaczas(M, A, O, E, F, G, H, I, J, K, L, na) :-
	optional(P,
		 [],
		 A,
		 N,
		 spójnik(i(B, C), _, ni, po),
		 { D=i(B, C)
		 },
		 { D=ni
		 }),
	register(fwe(E,
		     F,
		     G,
		     H,
		     I,
		     J,
		     K,
		     L,
		     neut,
		     D,
		     (0| 0),
		     R),
		 M,
		 N,
		 we1,
		 
		 [ O/formaczas(E, F, G, H, I, J, K, L, na)
		 | P
		 ],
		 Q),
	fwe(M,
	    N,
	    Q,
	    E,
	    F,
	    G,
	    H,
	    I,
	    J,
	    K,
	    L,
	    neut,
	    D,
	    (0| 0),
	    R).

partykuła(M, A, O, nie, po) :-
	goal(formaczas(F,
		       G,
		       H,
		       I,
		       J,
		       K,
		       L,
		       tak,
		       na),
	     A,
	     B,
	     P),
	optional(Q,
		 [],
		 B,
		 N,
		 spójnik(i(C, D), _, ni, po),
		 { E=i(C, D)
		 },
		 { E=ni
		 }),
	register(fwe(F,
		     G,
		     H,
		     I,
		     J,
		     K,
		     L,
		     nie(S),
		     neut,
		     E,
		     (0| 0),
		     T),
		 M,
		 N,
		 we2,
		 
		 [ O/partykuła(nie, po),
		   A,
		   P/formaczas(F, G, H, I, J, K, L, tak, na)
		 | Q
		 ],
		 R),
	fwe(M,
	    N,
	    R,
	    F,
	    G,
	    H,
	    I,
	    J,
	    K,
	    L,
	    nie(S),
	    neut,
	    E,
	    (0| 0),
	    T).

partykuła(G, A, I, nie, po) :-
	goal(posiłk(bedzie(B, tak), C, D, E, F, na),
	     A,
	     H,
	     J),
	register(posiłk(bedzie(B, nie(L)),
			C,
			D,
			E,
			F,
			M),
		 G,
		 H,
		 po6,
		 
		 [ I/partykuła(nie, po),
		   A,
		   J/posiłk(bedzie(B, tak), C, D, E, F, na)
		 ],
		 K),
	posiłk(G,
	       H,
	       K,
	       bedzie(B, nie(L)),
	       C,
	       D,
	       E,
	       F,
	       M).

formarzecz(I, A, K, E, F/G, H, na) :-
	optional(L,
		 [],
		 A,
		 J,
		 spójnik(i(B, C), _, ni, po),
		 { D=i(B, C)
		 },
		 { D=ni
		 }),
	register(fno(E,
		     F/G,
		     3,
		     H,
		     rzecz,
		     bzap,
		     N,
		     O,
		     neut,
		     D,
		     (0| 0),
		     P),
		 I,
		 J,
		 no1,
		 
		 [ K/formarzecz(E, F/G, H, na)
		 | L
		 ],
		 M),
	fno(I,
	    J,
	    M,
	    E,
	    F/G,
	    3,
	    H,
	    rzecz,
	    bzap,
	    N,
	    O,
	    neut,
	    D,
	    (0| 0),
	    P).

zaimos(J, A, L, E, F/G, H, na) :-
	optional(M,
		 [],
		 A,
		 K,
		 spójnik(i(B, C), _, ni, po),
		 { D=i(B, C)
		 },
		 { D=ni
		 }),
	rekcja_pusta(I),
	register(fno(E,
		     F/G,
		     H,
		     I,
		     os,
		     bzap,
		     O,
		     P,
		     neut,
		     D,
		     (0| 0),
		     Q),
		 J,
		 K,
		 no2,
		 
		 [ L/zaimos(E, F/G, H, na)
		 | M
		 ],
		 N),
	fno(J,
	    K,
	    N,
	    E,
	    F/G,
	    H,
	    I,
	    os,
	    bzap,
	    O,
	    P,
	    neut,
	    D,
	    (0| 0),
	    Q).

zaimrzecz(J, B, L, A, F, G/H, na) :-
	równe(A, ktoś.ktokolwiek),
	optional(M,
		 [],
		 B,
		 K,
		 spójnik(i(C, D), _, ni, po),
		 { E=i(C, D)
		 },
		 { E=ni
		 }),
	rekcja_pusta(I),
	register(fno(F,
		     G/H,
		     3,
		     I,
		     kto,
		     bzap,
		     O,
		     P,
		     neut,
		     E,
		     (0| 0),
		     Q),
		 J,
		 K,
		 no3,
		 
		 [ L/zaimrzecz(A, F, G/H, na)
		 | M
		 ],
		 N),
	fno(J,
	    K,
	    N,
	    F,
	    G/H,
	    3,
	    I,
	    kto,
	    bzap,
	    O,
	    P,
	    neut,
	    E,
	    (0| 0),
	    Q).

zaimrzecz(J, B, L, A, F, G/H, na) :-
	równe(A, coś.cokolwiek.co),
	optional(M,
		 [],
		 B,
		 K,
		 spójnik(i(C, D), _, ni, po),
		 { E=i(C, D)
		 },
		 { E=ni
		 }),
	rekcja_pusta(I),
	register(fno(F,
		     G/H,
		     3,
		     I,
		     co,
		     bzap,
		     O,
		     P,
		     neut,
		     E,
		     (0| 0),
		     Q),
		 J,
		 K,
		 no4,
		 
		 [ L/zaimrzecz(A, F, G/H, na)
		 | M
		 ],
		 N),
	fno(J,
	    K,
	    N,
	    F,
	    G/H,
	    3,
	    I,
	    co,
	    bzap,
	    O,
	    P,
	    neut,
	    E,
	    (0| 0),
	    Q).

zaimrzecz(I, A, K, nic, E, F/G, na) :-
	optional(L,
		 [],
		 A,
		 J,
		 spójnik(i(B, C), _, ni, po),
		 { D=i(B, C)
		 },
		 { D=ni
		 }),
	rekcja_pusta(H),
	register(fno(E,
		     F/G,
		     3,
		     H,
		     co,
		     bzap,
		     N,
		     nie(O),
		     neut,
		     D,
		     (0| 0),
		     P),
		 I,
		 J,
		 no5,
		 
		 [ K/zaimrzecz(nic, E, F/G, na)
		 | L
		 ],
		 M),
	fno(I,
	    J,
	    M,
	    E,
	    F/G,
	    3,
	    H,
	    co,
	    bzap,
	    N,
	    nie(O),
	    neut,
	    D,
	    (0| 0),
	    P).

zaimrzecz(I, A, K, nikt, E, F/G, na) :-
	optional(L,
		 [],
		 A,
		 J,
		 spójnik(i(B, C), _, ni, po),
		 { D=i(B, C)
		 },
		 { D=ni
		 }),
	rekcja_pusta(H),
	register(fno(E,
		     F/G,
		     3,
		     H,
		     kto,
		     bzap,
		     N,
		     nie(O),
		     neut,
		     D,
		     (0| 0),
		     P),
		 I,
		 J,
		 no6,
		 
		 [ K/zaimrzecz(nikt, E, F/G, na)
		 | L
		 ],
		 M),
	fno(I,
	    J,
	    M,
	    E,
	    F/G,
	    3,
	    H,
	    kto,
	    bzap,
	    N,
	    nie(O),
	    neut,
	    D,
	    (0| 0),
	    P).

zaimrzecz(I, A, K, to, E, F/G, na) :-
	optional(L,
		 [],
		 A,
		 J,
		 spójnik(i(B, C), _, ni, po),
		 { D=i(B, C)
		 },
		 { D=ni
		 }),
	rekcja_pusta(H),
	register(fno(E,
		     F/G,
		     3,
		     H,
		     rzecz,
		     bzap,
		     N,
		     O,
		     neut,
		     D,
		     (0| 0),
		     P),
		 I,
		 J,
		 no7,
		 [K/zaimrzecz(to, E, F/G, na)|L],
		 M),
	fno(I,
	    J,
	    M,
	    E,
	    F/G,
	    3,
	    H,
	    rzecz,
	    bzap,
	    N,
	    O,
	    neut,
	    D,
	    (0| 0),
	    P).

zaimrzecz(K, D, M, A, H, B/C, na) :-
	równe(A, co.kto),
	równe(J, pyt.pz.wz(A, B/C)),
	optional(N,
		 [],
		 D,
		 L,
		 spójnik(i(E, F), _, ni, po),
		 { G=i(E, F)
		 },
		 { G=ni
		 }),
	rekcja_pusta(I),
	register(fno(H,
		     B/C,
		     3,
		     I,
		     A,
		     bzap,
		     P,
		     Q,
		     J,
		     G,
		     (0| 0),
		     R),
		 K,
		 L,
		 no8,
		 
		 [ M/zaimrzecz(A, H, B/C, na)
		 | N
		 ],
		 O),
	fno(K,
	    L,
	    O,
	    H,
	    B/C,
	    3,
	    I,
	    A,
	    bzap,
	    P,
	    Q,
	    J,
	    G,
	    (0| 0),
	    R).

zaimrzecz(B, C, D, to, A, E/poj, na) :-
	\+ member(A, [mian, miej, wol]),
	register(korelat(A, ni, G),
		 B,
		 C,
		 kor2,
		 [D/zaimrzecz(to, A, E/poj, na)],
		 F),
	korelat(B, C, F, A, ni, G).

zaimprzym(J, A, L, E, F, G/H, na) :-
	optional(M,
		 [],
		 A,
		 K,
		 spójnik(i(B, C), _, ni, po),
		 { D=i(B, C)
		 },
		 { D=ni
		 }),
	member(E, [który, jaki]),
	rekcja_pusta(I),
	register(fno(F,
		     G/H,
		     3,
		     I,
		     E,
		     bzap,
		     O,
		     P,
		     wz(E, G/H),
		     D,
		     (0| 0),
		     Q),
		 J,
		 K,
		 no11,
		 
		 [ L/zaimprzym(E, F, G/H, na)
		 | M
		 ],
		 N),
	fno(J,
	    K,
	    N,
	    F,
	    G/H,
	    3,
	    I,
	    E,
	    bzap,
	    O,
	    P,
	    wz(E, G/H),
	    D,
	    (0| 0),
	    Q).

zaimprzym(I, C, K, A, G, B, na) :-
	równe(A, [czyj, jaki, który]),
	równe(H, pyt.pz.wz(A, B)),
	optional(L,
		 [],
		 C,
		 J,
		 spójnik(i(D, E), _, ni, po),
		 { F=i(D, E)
		 },
		 { F=ni
		 }),
	register(fpt(G,
		     B,
		     row,
		     wym([], N, [[]]),
		     jaki,
		     bzap,
		     O,
		     H,
		     F,
		     (0| 0),
		     P),
		 I,
		 J,
		 pt2,
		 [K/zaimprzym(A, G, B, na)|L],
		 M),
	fpt(I,
	    J,
	    M,
	    G,
	    B,
	    row,
	    wym([], N, [[]]),
	    jaki,
	    bzap,
	    O,
	    H,
	    F,
	    (0| 0),
	    P).

zaimprzym(G, A, I, taki, E, F, na) :-
	optional(J,
		 [],
		 A,
		 H,
		 spójnik(i(B, C), _, ni, po),
		 { D=i(B, C)
		 },
		 { D=ni
		 }),
	register(fpt(E,
		     F,
		     row,
		     wym([], L, [[]]),
		     przym,
		     tk,
		     M,
		     neut,
		     D,
		     (0| 0),
		     N),
		 G,
		 H,
		 pt3,
		 [I/zaimprzym(taki, E, F, na)|J],
		 K),
	fpt(G,
	    H,
	    K,
	    E,
	    F,
	    row,
	    wym([], L, [[]]),
	    przym,
	    tk,
	    M,
	    neut,
	    D,
	    (0| 0),
	    N).

zaimprzym(G, A, I, jakiś, E, F, na) :-
	optional(J,
		 [],
		 A,
		 H,
		 spójnik(i(B, C), _, ni, po),
		 { D=i(B, C)
		 },
		 { D=ni
		 }),
	register(fpt(E,
		     F,
		     row,
		     wym([], L, [[]]),
		     przym,
		     bzap,
		     M,
		     neut,
		     D,
		     (0| 0),
		     N),
		 G,
		 H,
		 pt4,
		 [I/zaimprzym(jakiś, E, F, na)|J],
		 K),
	fpt(G,
	    H,
	    K,
	    E,
	    F,
	    row,
	    wym([], L, [[]]),
	    przym,
	    bzap,
	    M,
	    neut,
	    D,
	    (0| 0),
	    N).

zaimprzym(J, C, L, A, G, B, na) :-
	member(A/H/I,
	       
	       [ taki/tk/neut,
		 jaki/bzap/pyt,
		 jaki/bzap/pz,
		 jaki/bzap/wz(jaki, B),
		 jakiś/bzap/neut
	       ]),
	optional(M,
		 [],
		 C,
		 K,
		 spójnik(i(D, E), _, ni, po),
		 { F=i(D, E)
		 },
		 { F=ni
		 }),
	register(modjaki(G,
			 B,
			 H,
			 I,
			 F,
			 (0| 0),
			 O),
		 J,
		 K,
		 mj1,
		 [L/zaimprzym(A, G, B, na)|M],
		 N),
	modjaki(J,
		K,
		N,
		G,
		B,
		H,
		I,
		F,
		(0| 0),
		O).

flicz(I, J, K, A, B/C, uzg, E, F, G, H, na) :-
	rekcja_pusta(D),
	register(fno(A,
		     B/C,
		     M,
		     D,
		     uzg,
		     E,
		     N,
		     O,
		     F,
		     G,
		     H,
		     P),
		 I,
		 J,
		 nol1,
		 
		 [ K/flicz(A, B/C, uzg, E, F, G, H, na)
		 ],
		 L),
	fno(I,
	    J,
	    L,
	    A,
	    B/C,
	    M,
	    D,
	    uzg,
	    E,
	    N,
	    O,
	    F,
	    G,
	    H,
	    P).

flicz(I, J, K, A, B/C, nuzg, E, F, G, H, na) :-
	różne(A, mian),
	rekcja_pusta(D),
	register(fno(A,
		     B/C,
		     M,
		     D,
		     nuzg,
		     E,
		     N,
		     O,
		     F,
		     G,
		     H,
		     P),
		 I,
		 J,
		 nol2,
		 
		 [ K/flicz(A, B/C, nuzg, E, F, G, H, na)
		 ],
		 L),
	fno(I,
	    J,
	    L,
	    A,
	    B/C,
	    M,
	    D,
	    nuzg,
	    E,
	    N,
	    O,
	    F,
	    G,
	    H,
	    P).

flicz(F, G, H, mian, I/J, nuzg, B, C, D, E, na) :-
	rekcja_pusta(A),
	register(fno(mian,
		     r(mn(n), nmo(np(n)))/poj,
		     3,
		     A,
		     nuzg,
		     B,
		     L,
		     M,
		     C,
		     D,
		     E,
		     N),
		 F,
		 G,
		 nol3,
		 
		 [ H/flicz(mian, I/J, nuzg, B, C, D, E, na)
		 ],
		 K),
	fno(F,
	    G,
	    K,
	    mian,
	    r(mn(n), nmo(np(n)))/poj,
	    3,
	    A,
	    nuzg,
	    B,
	    L,
	    M,
	    C,
	    D,
	    E,
	    N).

flicz(U, D, W, A, B/C, uzg, J, F, H, L, na) :-
	goal(fno(A,
		 B/C,
		 N,
		 O,
		 E,
		 K,
		 Y,
		 Q,
		 G,
		 I,
		 M,
		 po),
	     D,
	     V,
	     X),
	różne(E, uzg.nuzg.egz),
	obldest(R, F, G),
	oblink(S, H, I),
	oblzap(P, [J, K]),
	oblpk(T, [L, M]),
	register(fno(A,
		     B/C,
		     N,
		     O,
		     uzg,
		     P,
		     A1,
		     Q,
		     R,
		     S,
		     T,
		     B1),
		 U,
		 V,
		 nol4,
		 
		 [ W/flicz(A, B/C, uzg, J, F, H, L, na),
		   D,
		   X/fno(A, B/C, N, O, E, K, Y, Q, G, I, M, po)
		 ],
		 Z),
	fno(U,
	    V,
	    Z,
	    A,
	    B/C,
	    N,
	    O,
	    uzg,
	    P,
	    A1,
	    Q,
	    R,
	    S,
	    T,
	    B1).

flicz(U, C, W, D, A/B, nuzg, J, F, H, L, na) :-
	goal(fno(dop,
		 A/B,
		 N,
		 O,
		 E,
		 K,
		 Y,
		 Q,
		 G,
		 I,
		 M,
		 po),
	     C,
	     V,
	     X),
	różne(D, mian),
	różne(E, uzg.nuzg.egz),
	obldest(R, F, G),
	oblink(S, H, I),
	oblzap(P, [J, K]),
	oblpk(T, [L, M]),
	register(fno(D,
		     A/B,
		     N,
		     O,
		     nuzg,
		     P,
		     A1,
		     Q,
		     R,
		     S,
		     T,
		     B1),
		 U,
		 V,
		 nol6,
		 
		 [ W/flicz(D, A/B, nuzg, J, F, H, L, na),
		   C,
		   X/fno(dop, A/B, N, O, E, K, Y, Q, G, I, M, po)
		 ],
		 Z),
	fno(U,
	    V,
	    Z,
	    D,
	    A/B,
	    N,
	    O,
	    nuzg,
	    P,
	    A1,
	    Q,
	    R,
	    S,
	    T,
	    B1).

flicz(S, C, U, mian, A/B, nuzg, I, E, G, K, na) :-
	goal(fno(dop,
		 A/B,
		 W,
		 M,
		 D,
		 J,
		 X,
		 O,
		 F,
		 H,
		 L,
		 po),
	     C,
	     T,
	     V),
	różne(D, uzg.nuzg.egz),
	obldest(P, E, F),
	oblink(Q, G, H),
	oblzap(N, [I, J]),
	oblpk(R, [K, L]),
	register(fno(mian,
		     r(mn(n), nmo(np(n)))/poj,
		     3,
		     M,
		     nuzg,
		     N,
		     Z,
		     O,
		     P,
		     Q,
		     R,
		     A1),
		 S,
		 T,
		 nol8,
		 
		 [ U/flicz(mian, A/B, nuzg, I, E, G, K, na),
		   C,
		   V/fno(dop, A/B, W, M, D, J, X, O, F, H, L, po)
		 ],
		 Y),
	fno(S,
	    T,
	    Y,
	    mian,
	    r(mn(n), nmo(np(n)))/poj,
	    3,
	    M,
	    nuzg,
	    N,
	    Z,
	    O,
	    P,
	    Q,
	    R,
	    A1).

flicz(T, B, V, N, O, P, Q, L, ni, M, A) :-
	var(A),
	A=na,
	do_sequence_of(W,
		       [],
		       B,
		       U,
		       [modpart(flicz, E, C, ni, D, po)/ (obldest_iter(F, C, I), sprawdz_pk_iter(G, D, J), conajmniej1(H, _, K))/[E]/[]/[]/ ([F, G, H]/[])/ ([I, J, K]/[])]/[L, M, 0]/[R, S, 1]),
	register(flicz(N,
		       O,
		       P,
		       Q,
		       R,
		       Y,
		       S,
		       na),
		 T,
		 U,
		 lim2,
		 
		 [ V/flicz(N, O, P, Q, L, ni, M, A)
		 | W
		 ],
		 X),
	flicz(T,
	      U,
	      X,
	      N,
	      O,
	      P,
	      Q,
	      R,
	      Y,
	      S,
	      na).

przyimek(K, B, M, C, A, na) :-
	goal(fno(A,
		 O/P,
		 Q,
		 wym([], R, S),
		 E,
		 F,
		 pre,
		 G,
		 H,
		 I,
		 D,
		 po),
	     B,
	     L,
	     N),
	różne(C, temu),
	oblpk(J, [ (0| p), D]),
	register(fpm(C,
		     A,
		     E,
		     F,
		     G,
		     H,
		     I,
		     J,
		     U),
		 K,
		 L,
		 pm1,
		 
		 [ M/przyimek(C, A, na),
		   B,
		   N/fno(A, O/P, Q, wym([], R, S), E, F, pre, G, H, I, D, po)
		 ],
		 T),
	fpm(K,
	    L,
	    T,
	    C,
	    A,
	    E,
	    F,
	    G,
	    H,
	    I,
	    J,
	    U).

przyimek(K, B, M, D, A, na) :-
	goal(fpt(A,
		 O/P,
		 Q,
		 wym([], R, S),
		 E,
		 F,
		 G,
		 H,
		 I,
		 C,
		 po),
	     B,
	     L,
	     N),
	oblpk(J, [ (0| p), C]),
	register(fpmpt(D,
		       A,
		       E,
		       F,
		       G,
		       H,
		       I,
		       J,
		       U),
		 K,
		 L,
		 pma1,
		 
		 [ M/przyimek(D, A, na),
		   B,
		   N/fpt(A, O/P, Q, wym([], R, S), E, F, G, H, I, C, po)
		 ],
		 T),
	fpmpt(K,
	      L,
	      T,
	      D,
	      A,
	      E,
	      F,
	      G,
	      H,
	      I,
	      J,
	      U).

przyimek(K, C, M, A, B, na) :-
	(   równe(A, [z, za])
	->  B=bier
	;   równe(B, [dop, bier])
	),
	goal(fpt(pop,
		 O/P,
		 Q,
		 wym([], R, S),
		 E,
		 F,
		 G,
		 H,
		 I,
		 D,
		 po),
	     C,
	     L,
	     N),
	oblpk(J, [ (0| p), D]),
	register(fpmpt(A,
		       pop,
		       E,
		       F,
		       G,
		       H,
		       I,
		       J,
		       U),
		 K,
		 L,
		 pma2,
		 
		 [ M/przyimek(A, B, na),
		   C,
		   N/fpt(pop, O/P, Q, wym([], R, S), E, F, G, H, I, D, po)
		 ],
		 T),
	fpmpt(K,
	      L,
	      T,
	      A,
	      pop,
	      E,
	      F,
	      G,
	      H,
	      I,
	      J,
	      U).

przyimek(B, A, D, mimo, dop, na) :-
	goal(terminal(morf(F, że, comp)), A, C, E),
	register(spójnik(po, chociaż, ni, H),
		 B,
		 C,
		 spoj34,
		 
		 [ D/przyimek(mimo, dop, na),
		   A,
		   E/terminal(morf(F, że, comp))
		 ],
		 G),
	spójnik(B, C, G, po, chociaż, ni, H).

przyimek(B, A, D, podczas, dop, na) :-
	goal(terminal(morf(F, gdy, comp)), A, C, E),
	register(spójnik(po, podczas, ni, H),
		 B,
		 C,
		 spoj40,
		 
		 [ D/przyimek(podczas, dop, na),
		   A,
		   E/terminal(morf(F, gdy, comp))
		 ],
		 G),
	spójnik(B, C, G, po, podczas, ni, H).

przyimek(F, A, H, I, C, po) :-
	goal(przec(K, po), A, B, J),
	goal(spójnik(rc, M, ni, na), B, D, L),
	goal(przyimek(E, C, po), D, G, N),
	register(przyimek(E, C, P),
		 F,
		 G,
		 pimr1,
		 
		 [ H/przyimek(I, C, po),
		   A,
		   J/przec(K, po),
		   B,
		   L/spójnik(rc, M, ni, na),
		   D,
		   N/przyimek(E, C, po)
		 ],
		 O),
	przyimek(F, G, O, E, C, P).

przyimek(I, A, K, L, M, po) :-
	do_sequence_of(N,
		       
		       [ B,
			 E/spójnik(szk, C, ni, na),
			 D,
			 H/przyimek(F, G, po)
		       ],
		       A,
		       B,
		       [[spójnik(sz, przec, ni, po), przyimek(_, _, po)]/true/[]/[]/[]/ ([]/[])/ ([]/[])]/[]/[]),
	goal(spójnik(szk, C, ni, na), B, D, E),
	goal(przyimek(F, G, po), D, J, H),
	register(przyimek(F, G, P),
		 I,
		 J,
		 pims3,
		 [K/przyimek(L, M, po)|N],
		 O),
	przyimek(I, J, O, F, G, P).

przyimek(D, B, F, C, A, na) :-
	goal(zaimrzecz(to, A, H/poj, po), B, E, G),
	register(korelat(C/A, ni, J),
		 D,
		 E,
		 kor1,
		 
		 [ F/przyimek(C, A, na),
		   B,
		   G/zaimrzecz(to, A, H/poj, po)
		 ],
		 I),
	korelat(D, E, I, C/A, ni, J).

formaprzym(I, A, K, E, F, G, H, na) :-
	optional(L,
		 [],
		 A,
		 J,
		 spójnik(i(B, C), _, ni, po),
		 { D=i(B, C)
		 },
		 { D=ni
		 }),
	register(fpt(E,
		     F,
		     G,
		     H,
		     przym,
		     bzap,
		     N,
		     neut,
		     D,
		     (0| 0),
		     O),
		 I,
		 J,
		 pt1,
		 
		 [ K/formaprzym(E, F, G, H, na)
		 | L
		 ],
		 M),
	fpt(I,
	    J,
	    M,
	    E,
	    F,
	    G,
	    H,
	    przym,
	    bzap,
	    N,
	    neut,
	    D,
	    (0| 0),
	    O).

modjaki(U2, C, W2, A, B, Y, Z, A1, B1, po) :-
	do_sequence_of(X2,
		       
		       [ D,
			 J1/fpt(A, B, C1, D1, E1, F1, X, G1, H1, I1, na)
		       | P1
		       ],
		       C,
		       D,
		       [fps(_, _, _, E, F, G, po)/ (oblzap_iter(H, P, L), obldest_iter(I, E, M), oblink_iter(J, F, N), sprawdz_pk_iter(K, G, O))/[]/[]/[]/ ([H, I, J, K]/[])/ ([L, M, N, O]/[]), fpm(_, _, _, P, _, E, F, G, po)/ (oblzap_iter(H, P, L), obldest_iter(I, E, M), oblink_iter(J, F, N), sprawdz_pk_iter(K, G, O))/[]/[]/[]/ ([H, I, J, K]/[])/ ([L, M, N, O]/[]), fw(Q, R, S, T, U, post, tak, E, F, G, po)/ (oblzap_iter(H, P, L), obldest_iter(I, E, M), oblink_iter(J, F, N), sprawdz_pk_iter(K, G, O), zroblistę_iter(V, Q, W))/[R, S, T, U]/[[]]/[O1]/ ([H, I, J, K]/[V])/ ([L, M, N, O]/[W]), modpart(fpt, X, E, F, G, po)/ (oblzap_iter(H, P, L), obldest_iter(I, E, M), oblink_iter(J, F, N), sprawdz_pk_iter(K, G, O))/[X]/[]/[]/ ([H, I, J, K]/[])/ ([L, M, N, O]/[]), modjaki(A, B, P, E, F, G, po)/ (oblzap_iter(H, P, L), obldest_iter(I, E, M), oblink_iter(J, F, N), sprawdz_pk_iter(K, G, O))/[A, B]/[]/[]/ ([H, I, J, K]/[])/ ([L, M, N, O]/[])]/[Y, Z, A1, B1]/[K1, L1, M1, N1]),
	goal(fpt(A,
		 B,
		 C1,
		 D1,
		 E1,
		 F1,
		 X,
		 G1,
		 H1,
		 I1,
		 na),
	     D,
	     Q1,
	     J1),
	D1=wym(_, _, [_|_]),
	oblzap_iter(K1, F1, L2),
	obldest_iter(L1, G1, M2),
	oblink_iter(M1, H1, N2),
	sprawdz_pk_iter(N1, I1, O2),
	wyjmijl(O1, D1, I2),
	do_sequence_of(P1,
		       [],
		       Q1,
		       V2,
		       [fps(_, _, _, R1, S1, T1, po)/ (oblzap_iter(U1, C2, Y1), obldest_iter(V1, R1, Z1), oblink_iter(W1, S1, A2), sprawdz_pk_iter(X1, T1, B2))/[]/[]/[]/ ([U1, V1, W1, X1]/[])/ ([Y1, Z1, A2, B2]/[]), fpm(_, _, _, C2, _, R1, S1, T1, po)/ (oblzap_iter(U1, C2, Y1), obldest_iter(V1, R1, Z1), oblink_iter(W1, S1, A2), sprawdz_pk_iter(X1, T1, B2))/[]/[]/[]/ ([U1, V1, W1, X1]/[])/ ([Y1, Z1, A2, B2]/[]), fw(D2, E2, F2, G2, H2, post, tak, R1, S1, T1, po)/ (oblzap_iter(U1, C2, Y1), obldest_iter(V1, R1, Z1), oblink_iter(W1, S1, A2), sprawdz_pk_iter(X1, T1, B2), oblwym_iter(J2, D2, K2))/[E2, F2, G2, H2]/[I2]/[P2]/ ([U1, V1, W1, X1]/[J2])/ ([Y1, Z1, A2, B2]/[K2]), modpart(fpt, X, R1, S1, T1, po)/ (oblzap_iter(U1, C2, Y1), obldest_iter(V1, R1, Z1), oblink_iter(W1, S1, A2), sprawdz_pk_iter(X1, T1, B2))/[X]/[]/[]/ ([U1, V1, W1, X1]/[])/ ([Y1, Z1, A2, B2]/[]), modjaki(A, B, C2, R1, S1, T1, po)/ (oblzap_iter(U1, C2, Y1), obldest_iter(V1, R1, Z1), oblink_iter(W1, S1, A2), sprawdz_pk_iter(X1, T1, B2))/[A, B]/[]/[]/ ([U1, V1, W1, X1]/[])/ ([Y1, Z1, A2, B2]/[])]/[L2, M2, N2, O2]/[Q2, R2, S2, T2]),
	wymagania_zamknij(P2),
	register(fpt(A,
		     B,
		     C1,
		     wym(Z2, A3, bw),
		     E1,
		     Q2,
		     X,
		     R2,
		     S2,
		     T2,
		     B3),
		 U2,
		 V2,
		 ptm5,
		 
		 [ W2/modjaki(A, B, Y, Z, A1, B1, po)
		 | X2
		 ],
		 Y2),
	fpt(U2,
	    V2,
	    Y2,
	    A,
	    B,
	    C1,
	    wym(Z2, A3, bw),
	    E1,
	    Q2,
	    X,
	    R2,
	    S2,
	    T2,
	    B3).

formalicz(G, H, I, B, C/D, E, A, na) :-
	obl_kl_licz(A, F),
	register(flicz(B,
		       C/D,
		       E,
		       bzap,
		       F,
		       ni,
		       (0| 0),
		       K),
		 G,
		 H,
		 licz1,
		 
		 [ I/formalicz(B, C/D, E, A, na)
		 ],
		 J),
	flicz(G,
	      H,
	      J,
	      B,
	      C/D,
	      E,
	      bzap,
	      F,
	      ni,
	      (0| 0),
	      K).

formalicz(K, D, M, A, B/C, N, F, po) :-
	optional(O,
		 
		 [ E,
		   J/formalicz(A, B/C, H, I, na)
		 ],
		 D,
		 E,
		 formalicz(A, B/C, _, G, po),
		 { troj_licz(F, G)
		 },
		 { G=F
		 }),
	goal(formalicz(A, B/C, H, I, na),
	     E,
	     L,
	     J),
	troj_licz(G, I),
	register(flicz(A,
		       B/C,
		       H,
		       bzap,
		       neut,
		       ni,
		       (0| 0),
		       Q),
		 K,
		 L,
		 licz2,
		 
		 [ M/formalicz(A, B/C, N, F, po)
		 | O
		 ],
		 P),
	flicz(K,
	      L,
	      P,
	      A,
	      B/C,
	      H,
	      bzap,
	      neut,
	      ni,
	      (0| 0),
	      Q).

formaprzys(I, A, K, E, F, G, H, na) :-
	optional(L,
		 [],
		 A,
		 J,
		 spójnik(i(B, C), _, ni, po),
		 { D=i(B, C)
		 },
		 { D=ni
		 }),
	register(fps(E, F, G, H, D, (0| 0), N),
		 I,
		 J,
		 ps1,
		 
		 [ K/formaprzys(E, F, G, H, na)
		 | L
		 ],
		 M),
	fps(I,
	    J,
	    M,
	    E,
	    F,
	    G,
	    H,
	    D,
	    (0| 0),
	    N).

korelat(K, A, M, D, I, po) :-
	goal(fzd(C, nk, E, F, G, H, ni, B, na),
	     A,
	     L,
	     N),
	oblpk(J, [ (0| 0), B]),
	register(fzd(C,
		     D,
		     E,
		     F,
		     G,
		     H,
		     I,
		     J,
		     P),
		 K,
		 L,
		 zdk1,
		 
		 [ M/korelat(D, I, po),
		   A,
		   N/fzd(C, nk, E, F, G, H, ni, B, na)
		 ],
		 O),
	fzd(K,
	    L,
	    O,
	    C,
	    D,
	    E,
	    F,
	    G,
	    H,
	    I,
	    J,
	    P).

korelat(E, A, G, B, ni, na) :-
	goal(spójnik(i(C, D), I, ni, po),
	     A,
	     F,
	     H),
	register(korelat(B, i(C, D), K),
		 E,
		 F,
		 kor3,
		 
		 [ G/korelat(B, ni, na),
		   A,
		   H/spójnik(i(C, D), I, ni, po)
		 ],
		 J),
	korelat(E, F, J, B, i(C, D), K).

zaimwzg(_, _, _, _, _, _, _, _) :-
	fail.

zaimprzym(C, D, E, jaki, A, B) :-
	register(zaimwzg(przym, A, B, G, H),
		 C,
		 D,
		 zaim44n,
		 [E/zaimprzym(jaki, A, B)],
		 F),
	zaimwzg(C, D, F, przym, A, B, G, H).

zaimprzym(E, F, G, ten, A, r(B, nmo(C))/D) :-
	register(zaimno(rzecz,
			A,
			r(B, nmo(C))/D,
			I,
			co),
		 E,
		 F,
		 zaim73,
		 
		 [ G/zaimprzym(ten, A, r(B, nmo(C))/D)
		 ],
		 H),
	zaimno(E,
	       F,
	       H,
	       rzecz,
	       A,
	       r(B, nmo(C))/D,
	       I,
	       co).

zaimprzym(B, C, D, ten, A, r(mn(m(zy)), mo)/poj) :-
	register(zaimno(rzecz, A, r(mn(m(zy)), mo)/poj, F, kto),
		 B,
		 C,
		 zaim73k,
		 [D/zaimprzym(ten, A, r(mn(m(zy)), mo)/poj)],
		 E),
	zaimno(B,
	       C,
	       E,
	       rzecz,
	       A,
	       r(mn(m(zy)), mo)/poj,
	       F,
	       kto).

zaimprzym(C, D, E, ten, A, B) :-
	register(zaimno(przym, A, B, G, H),
		 C,
		 D,
		 zaim73x,
		 [E/zaimprzym(ten, A, B)],
		 F),
	zaimno(C, D, F, przym, A, B, G, H).

zaimno(_, _, _, _, _, _, _, _) :-
	fail.

przyzlo(H, A, J, K, E/D, G, na) :-
	goal(terminal(morf(M, być, bedzie:C:B:imperf)),
	     A,
	     I,
	     L),
	osoba(B, F),
	liczba(C, D),
	register(formaczas(os,
			   nd,
			   przy,
			   ozn,
			   E/D,
			   F,
			   G,
			   tak,
			   O),
		 H,
		 I,
		 n_cz7,
		 
		 [ J/przyzlo(K, E/D, G, na),
		   A,
		   L/terminal(morf(M, być, bedzie:C:B:imperf))
		 ],
		 N),
	formaczas(H,
		  I,
		  N,
		  os,
		  nd,
		  przy,
		  ozn,
		  E/D,
		  F,
		  G,
		  tak,
		  O).

przyzlo(I, A, K, L, F/E, H, na) :-
	goal(partykuła(nie, po), A, B, M),
	goal(terminal(morf(O, być, bedzie:D:C:imperf)),
	     B,
	     J,
	     N),
	osoba(C, G),
	liczba(D, E),
	register(formaczas(os,
			   nd,
			   przy,
			   ozn,
			   F/E,
			   G,
			   H,
			   nie(Q),
			   R),
		 I,
		 J,
		 n_cz38,
		 
		 [ K/przyzlo(L, F/E, H, na),
		   A,
		   M/partykuła(nie, po),
		   B,
		   N/terminal(morf(O, być, bedzie:D:C:imperf))
		 ],
		 P),
	formaczas(I,
		  J,
		  P,
		  os,
		  nd,
		  przy,
		  ozn,
		  F/E,
		  G,
		  H,
		  nie(Q),
		  R).

przyzlo(I, A, K, s, F/E, H, na) :-
	goal(terminal(morf(M, się, qub)), A, B, L),
	goal(terminal(morf(O, być, bedzie:D:C:imperf)),
	     B,
	     J,
	     N),
	osoba(C, G),
	liczba(D, E),
	register(formaczas1(n,
			    os,
			    nd,
			    przy,
			    ozn,
			    F/E,
			    G,
			    H,
			    Q),
		 I,
		 J,
		 n_cz9,
		 
		 [ K/przyzlo(s, F/E, H, na),
		   A,
		   L/terminal(morf(M, się, qub)),
		   B,
		   N/terminal(morf(O, być, bedzie:D:C:imperf))
		 ],
		 P),
	formaczas1(I,
		   J,
		   P,
		   n,
		   os,
		   nd,
		   przy,
		   ozn,
		   F/E,
		   G,
		   H,
		   Q).

formaczas1(_, _, _, _, _, _, _, _, _, _, _, _) :-
	fail.

condaglt(L, A, N, E, J, na) :-
	goal(terminal(morf(P, G, praet:D:F:B)),
	     A,
	     M,
	     O),
	asagl(B, C, nagl),
	aspekt(C, H),
	liczba(D, E),
	rodzaj(F, I),
	rekcja_finitywna(G, K),
	register(formaczas(os,
			   H,
			   R,
			   war,
			   I/E,
			   J,
			   K,
			   tak,
			   S),
		 L,
		 M,
		 n_cz13,
		 
		 [ N/condaglt(E, J, na),
		   A,
		   O/terminal(morf(P, G, praet:D:F:B))
		 ],
		 Q),
	formaczas(L,
		  M,
		  Q,
		  os,
		  H,
		  R,
		  war,
		  I/E,
		  J,
		  K,
		  tak,
		  S).

condaglt(N, A, P, F, L, na) :-
	goal(terminal(morf(R, się, qub)), A, B, Q),
	goal(terminal(morf(T, H, praet:E:G:C)),
	     B,
	     O,
	     S),
	asagl(C, D, nagl),
	aspekt(D, J),
	liczba(E, F),
	rodzaj(G, K),
	rekcja_finitywna(H, I),
	wyjmijwymaganie(sie, I, M),
	register(formaczas1(n,
			    os,
			    J,
			    V,
			    war,
			    K/F,
			    L,
			    M,
			    W),
		 N,
		 O,
		 n_cz15,
		 
		 [ P/condaglt(F, L, na),
		   A,
		   Q/terminal(morf(R, się, qub)),
		   B,
		   S/terminal(morf(T, H, praet:E:G:C))
		 ],
		 U),
	formaczas1(N,
		   O,
		   U,
		   n,
		   os,
		   J,
		   V,
		   war,
		   K/F,
		   L,
		   M,
		   W).

condaglt(C, D, E, B, A, na) :-
	register(posiłk(by(A), G/B, neut, ni, (0| 0), H),
		 C,
		 D,
		 po3,
		 [E/condaglt(B, A, na)],
		 F),
	posiłk(C,
	       D,
	       F,
	       by(A),
	       G/B,
	       neut,
	       ni,
	       (0| 0),
	       H).

znakkonca(_, _, _, _, _) :-
	fail.