:-style_check(-singleton).
grammar_no(1532334804).
:- 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(przec, A) :- !,
	A\=sp:sz:przec2,
	A\=sp:sz:wykrz,
	A\=bc(_).

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.

sprawdź_realizacje_fpm(_, [], []) :- !.

sprawdź_realizacje_fpm(A, [B|D], [C|E]) :- !,
	realizuje(xp(A), prepnp(B, C), _),
	sprawdź_realizacje_fpm(A, D, E).

sprawdź_realizacje_fpm(A, B, C) :-
	realizuje(xp(A), prepnp(B, C), _).

dopuszczalna_koordynacja([advp(_), xp(_), or, infp(perf), infp(imperf), np(accgen), np(dat), np(gen), np(nom), np(inst), cp(aż), cp(gdy), cp(jak), cp(jakoby), cp(jeśli), cp(kiedy), cp(int), cp(że), cp(żeby), cp(żeby2), prepnp(dla, gen), prepnp(do, gen), prepnp(ku, dat), prepnp(na, acc), prepnp(na, loc), prepnp('na polu', gen), prepnp('na temat', gen), prepnp(nad, inst), prepnp(o, acc), prepnp(o, loc), prepnp(od, gen), prepnp(po, acc), prepnp(po, loc), prepnp('po stronie', gen), prepnp(pod, acc), prepnp('pod względem', gen), prepnp(przeciw, dat), prepnp(przed, inst), prepnp(przez, acc), prepnp(przy, loc), prepnp(u, gen), prepnp(w, acc), prepnp(w, loc), prepnp('w dziedzinie', gen), prepnp('w kwestii', gen), prepnp('w sprawie', gen), prepnp(według, gen), prepnp(wskutek, gen), prepnp(z, gen), prepnp(z, inst), prepnp('z powodu', gen), prepnp(za, acc), prepnp(za, inst), ncp(accgen, gdy), ncp(accgen, int), ncp(accgen, jak), ncp(accgen, jakoby), ncp(accgen, jeśli), ncp(accgen, kiedy), ncp(accgen, że), ncp(accgen, żeby), ncp(accgen, żeby2), ncp(dat, jak), ncp(dat, jakoby), ncp(dat, int), ncp(dat, że), ncp(dat, żeby), ncp(dat, żeby2), ncp(gen, aż), ncp(gen, gdy), ncp(gen, jak), ncp(gen, jakoby), ncp(gen, kiedy), ncp(gen, int), ncp(gen, że), ncp(gen, żeby), ncp(gen, żeby2), ncp(nom, gdy), ncp(nom, int), ncp(nom, jak), ncp(nom, jakoby), ncp(nom, jeśli), ncp(nom, kiedy), ncp(nom, że), ncp(nom, żeby), ncp(nom, żeby2), ncp(inst, jak), ncp(inst, int), ncp(inst, że), ncp(inst, żeby), prepncp(dla, gen, int), prepncp(dla, gen, żeby), prepncp(do, gen, jak), prepncp(do, gen, int), prepncp(do, gen, że), prepncp(do, gen, żeby), prepncp(do, gen, żeby2), prepncp(ku, dat, że), prepncp(ku, dat, żeby), prepncp(na, acc, aż), prepncp(na, acc, gdy), prepncp(na, acc, jak), prepncp(na, acc, jakby), prepncp(na, acc, kiedy), prepncp(na, acc, int), prepncp(na, acc, że), prepncp(na, acc, żeby), prepncp(na, acc, żeby2), prepncp(na, loc, jak), prepncp(na, loc, int), prepncp(na, loc, że), prepncp(na, loc, żeby), prepncp(na, loc, żeby2), prepncp(na, str, int), prepncp(na, str, że), prepncp(nad, inst, jak), prepncp(nad, inst, int), prepncp(nad, inst, że), prepncp(nad, inst, żeby), prepncp(o, acc, jakoby), prepncp(o, acc, int), prepncp(o, acc, że), prepncp(o, acc, żeby), prepncp(o, acc, żeby2), prepncp(o, loc, jak), prepncp(o, loc, jakoby), prepncp(o, loc, int), prepncp(o, loc, że), prepncp(o, loc, żeby), prepncp(o, loc, żeby2), prepncp(od, gen, jakoby), prepncp(od, gen, int), prepncp(od, gen, że), prepncp(od, gen, żeby), prepncp(po, loc, jak), prepncp(po, loc, int), prepncp(po, loc, że), prepncp(przeciw, dat, gdy), prepncp(przeciw, dat, jak), prepncp(przeciw, dat, jakoby), prepncp(przeciw, dat, kiedy), prepncp(przeciw, dat, int), prepncp(przeciw, dat, że), prepncp(przeciw, dat, żeby), prepncp(przed, inst, int), prepncp(przed, inst, że), prepncp(przed, inst, żeby), prepncp(przez, acc, int), prepncp(przez, acc, że), prepncp(przy, loc, jak), prepncp(przy, loc, int), prepncp(przy, loc, że), prepncp(przy, loc, żeby), prepncp(w, acc, jak), prepncp(w, acc, int), prepncp(w, acc, że), prepncp(w, acc, żeby), prepncp(w, acc, żeby2), prepncp(w, loc, jak), prepncp(w, loc, int), prepncp(w, loc, że), prepncp(w, loc, żeby), prepncp(z, gen, jak), prepncp(z, gen, int), prepncp(z, gen, że), prepncp(z, gen, żeby), prepncp(z, inst, jak), prepncp(z, inst, jakby), prepncp(z, inst, int), prepncp(z, inst, że), prepncp(z, inst, żeby), prepncp(z, inst, żeby2), prepncp(za, acc, int), prepncp(za, acc, że), prepncp(za, acc, żeby), prepncp(za, inst, gdy), prepncp(za, inst, jak), prepncp(za, inst, kiedy), prepncp(za, inst, int), prepncp(za, inst, rel), prepncp(za, inst, że), prepncp(za, inst, żeby), prepncp(za, str, int)]).

dopuszczalna_koordynacja([prepnp(wokół, gen), prepncp(wokół, gen, int), prepncp(wokół, gen, że), prepncp(wokół, gen, żeby)]).

dopuszczalna_koordynacja([prepnp(wobec, gen), prepncp(wobec, gen, int), prepncp(wobec, gen, że)]).

dopuszczalna_koordynacja([prepnp(poza, acc), prepncp(poza, acc, int), prepncp(poza, acc, że)]).

dopuszczalna_koordynacja([prepnp(pod, inst), prepncp(pod, inst, że), prepncp(pod, inst, żeby)]).

dopuszczalna_koordynacja([prepnp(koło, gen), prepncp(koło, gen, żeby)]).

dopuszczalna_koordynacja([prepnp('co do', gen), prepncp('co do', gen, jakoby), prepncp('co do', gen, int), prepncp('co do', gen, że), prepncp('co do', gen, żeby)]).

dopuszczalna_koordynacja([prepnp(bez, gen), prepncp(bez, gen, że), prepncp(bez, gen, żeby)]).

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

dopuszczalna_koordynacja(subj(A), subj([A])/subj(B)) :-
	dopuszczalna_koordynacja(B),
	member(A, B).

dopuszczalna_koordynacja(A, [A]/B) :-
	dopuszczalna_koordynacja(B),
	member(A, B).

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

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

sprawdz_rodzaj_koord_subj(subj(_), B, A) :- !,
	(   eqsame(A)
	*-> true
	;   B=post
	).

sprawdz_rodzaj_koord_subj(_, _, _).

eqsame([]) :- !.

eqsame([_]) :- !.

eqsame([A, B|C]) :-
	A=@=B,
	eqsame([B|C]).

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, gen) :-
	równe(A, nom'.'acc), !.

sprawdz_kl_noa(co, A, A) :-
	różne(A, nom'.'acc), !.

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), _, bzap) :- !,
	false.

obl_kl_licz(pyt, pyt, bzap).

obl_kl_licz(pyt, pz, bzap) :- !.

obl_kl_licz(tyle, neut, tyle) :- !.

obl_kl_licz(neut, neut, bzap) :- !.

obl_kl_licz(t(_), neut, bzap).

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(tyle, tyle) :- !.

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(P1, B, R1, D1, G1, H1, I1, J1, K1, L1, A, N1, A1, po) :-
	tylko_neut_pyt(A),
	do_sequence_of(S1,
		       
		       [ 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,
	     Q1,
	     Z),
	oblpk(O1, [A1|B1]),
	obldest_iter(C1, Y, M1),
	sprawdź_wyróżniki_w_szeregu(O, [D1|E1]),
	(   różne(sp:sz:przec, [D1|E1])
	*-> F1=O
	;   O=przec,
	    length(E1, 1),
	    F1=przec2
	),
	(   O\=przec
	;   H\=sp:sz:_
	;   H=sp:sz:i
	;   H=sp:sz:przec
	),
	register(zdanie(sp:sz:F1,
			G1,
			H1,
			I1,
			J1,
			K1,
			L1,
			M1,
			N1,
			O1,
			U1),
		 P1,
		 Q1,
		 s3,
		 
		 [ R1/zdanie(D1, G1, H1, I1, J1, K1, L1, A, N1, A1, po)
		 | S1
		 ],
		 T1),
	zdanie(P1,
	       Q1,
	       T1,
	       sp:sz:F1,
	       G1,
	       H1,
	       I1,
	       J1,
	       K1,
	       L1,
	       M1,
	       N1,
	       O1,
	       U1).

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

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

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

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

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

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

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

spójnik(C2, B, E2, sz, A, ni, na) :-
	\+ member(A, [przec, lub]),
	goal(fno(G2,
		 D,
		 N1/O1,
		 P1,
		 wym([], H2, I2),
		 Q1,
		 E,
		 R1,
		 F,
		 C,
		 A2,
		 K1,
		 po),
	     B,
	     G,
	     F2),
	tylko_neut_pyt(C),
	do_sequence_of(J2,
		       
		       [ H,
			 X/przec(O, po),
			 W,
			 Z/spójnik(szk, A, ni, na),
			 Y,
			 J1/fno(A1, D, B1/C1, D1, wym([], E1, F1), G1, E, H1, F, I1, 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]/[L1, C, []]/[[O, (0| 0), P], M1, S1]/ ([]/[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(A1,
		 D,
		 B1/C1,
		 D1,
		 wym([], E1, F1),
		 G1,
		 E,
		 H1,
		 F,
		 I1,
		 ni,
		 P,
		 po),
	     Y,
	     D2,
	     J1),
	oblpk(B2, [K1|L1]),
	obldest_fno_iter(M1, I1, Z1),
	oblparam_fno_koor(A,
			  T1/U1/V1/X1/Y1/W1,
			  N1/O1/P1/Q1/R1,
			  B1/C1/D1/G1/H1,
			  S1),
	register(fno(A,
		     D,
		     T1/U1,
		     V1,
		     W1,
		     X1,
		     E,
		     Y1,
		     F,
		     Z1,
		     A2,
		     B2,
		     L2),
		 C2,
		 D2,
		 nos1,
		 
		 [ E2/spójnik(sz, A, ni, na),
		   B,
		   F2/fno(G2, D, N1/O1, P1, wym([], H2, I2), Q1, E, R1, F, C, A2, K1, po)
		 | J2
		 ],
		 K2),
	fno(C2,
	    D2,
	    K2,
	    A,
	    D,
	    T1/U1,
	    V1,
	    W1,
	    X1,
	    E,
	    Y1,
	    F,
	    Z1,
	    A2,
	    B2,
	    L2).

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

spójnik(R1, B, T1, sz, A, ni, po) :-
	\+ member(A, [przec, lub]),
	goal(fpm(O,
		 V1,
		 P,
		 D,
		 E,
		 F,
		 C,
		 P1,
		 I1,
		 po),
	     B,
	     G,
	     U1),
	tylko_neut_pyt(C),
	sprawdz_kl_nie_sz(D),
	do_sequence_of(W1,
		       
		       [ H,
			 Z/przec(Q, po),
			 Y,
			 B1/spójnik(szk, A, ni, na),
			 A1,
			 H1/fpm(C1, D1, E1, F1, E, F, G1, 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]/[J1, C, [O/P]]/[[Q, (0| 0), R], K1, L1]/ ([]/[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,
		 F1,
		 E,
		 F,
		 G1,
		 ni,
		 R,
		 po),
	     A1,
	     S1,
	     H1),
	sprawdz_kl_nie_sz(F1),
	oblpk(Q1, [I1|J1]),
	obldest_fno_iter(K1, G1, O1),
	obl_pmp([C1/E1|L1], M1, N1),
	register(fpm(M1,
		     A,
		     N1,
		     sz,
		     E,
		     F,
		     O1,
		     P1,
		     Q1,
		     Y1),
		 R1,
		 S1,
		 pms1,
		 
		 [ T1/spójnik(sz, A, ni, po),
		   B,
		   U1/fpm(O, V1, P, D, E, F, C, P1, I1, po)
		 | W1
		 ],
		 X1),
	fpm(R1,
	    S1,
	    X1,
	    M1,
	    A,
	    N1,
	    sz,
	    E,
	    F,
	    O1,
	    P1,
	    Q1,
	    Y1).

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

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

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

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

fno(J, K, L, C, A, D, M, E, N, O, pre, B, G, H, I, na) :-
	member(A/B, [acc/tak, gen/nie(_)]),
	lex_dla_np(F, C, D),
	register(fw(np(accgen)/E,
		    F,
		    Q,
		    R,
		    S,
		    T,
		    U,
		    B,
		    G,
		    H,
		    I,
		    V),
		 J,
		 K,
		 wy4x,
		 
		 [ L/fno(C, A, D, M, E, N, O, pre, B, G, H, I, na)
		 ],
		 P),
	fw(J,
	   K,
	   P,
	   np(accgen)/E,
	   F,
	   Q,
	   R,
	   S,
	   T,
	   U,
	   B,
	   G,
	   H,
	   I,
	   V).

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

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

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

fno(I, J, K, A, B, D, L, wym([], M, N), O, P, pre, C, F, G, H, na) :-
	member(A, [to, co, coś, nic, wszystko]),
	member(B/C, [acc/tak, gen/nie(_)]),
	lex_dla_np(E, A, D),
	register(fw(nonch,
		    E,
		    R,
		    S,
		    T,
		    U,
		    V,
		    C,
		    F,
		    G,
		    H,
		    W),
		 I,
		 J,
		 wy5n,
		 
		 [ K/fno(A, B, D, L, wym([], M, N), O, P, pre, C, F, G, H, na)
		 ],
		 Q),
	fw(I,
	   J,
	   Q,
	   nonch,
	   E,
	   R,
	   S,
	   T,
	   U,
	   V,
	   C,
	   F,
	   G,
	   H,
	   W).

fno(J, K, L, A, nom, B, D, wym([], M, N), O, P, E, F, G, H, I, na) :-
	member(A, [to, co, coś, nic, wszystko]),
	lex_dla_np(C, A, B),
	register(fw(subj(nonch),
		    C,
		    R,
		    S,
		    B,
		    D,
		    E,
		    F,
		    G,
		    H,
		    I,
		    T),
		 J,
		 K,
		 wy3n,
		 
		 [ L/fno(A, nom, B, D, wym([], M, N), O, P, E, F, G, H, I, na)
		 ],
		 Q),
	fw(J,
	   K,
	   Q,
	   subj(nonch),
	   C,
	   R,
	   S,
	   B,
	   D,
	   E,
	   F,
	   G,
	   H,
	   I,
	   T).

fno(H, I, J, K, B, L, M, wym([], N, O), P, Q, pre, C, E, F, G, na) :-
	realizuje(xp(D), np(A), _),
	member(A/B/C,
	       
	       [ accgen/acc/_,
		 accgen/gen/nie(_),
		 B/B/_
	       ]),
	register(fw(xp(D),
		    lex,
		    S,
		    T,
		    U,
		    V,
		    W,
		    C,
		    E,
		    F,
		    G,
		    X),
		 H,
		 I,
		 wy13,
		 
		 [ J/fno(K, B, L, M, wym([], N, O), P, Q, pre, C, E, F, G, na)
		 ],
		 R),
	fw(H,
	   I,
	   R,
	   xp(D),
	   lex,
	   S,
	   T,
	   U,
	   V,
	   W,
	   C,
	   E,
	   F,
	   G,
	   X).

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

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

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

fno(E2, D, G2, X1, C, G/H, Y1, A, B, R1, A2, I, S1, T1, U1, na) :-
	wymagania_czyste(_, A),
	sprawdz_kl_noa(B, C, F),
	do_sequence_of(H2,
		       [],
		       D,
		       F2,
		       [[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(_, gen, _, 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), najwyżej(B1, _, C1))/[I]/[2]/[_]/ ([P, Q, R, S, T]/[B1])/ ([U, V, W, X, Y]/[C1]), fzd(D1, nk, E1, F1, G1, _, 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(H1, D1, I1))/[E1, F1, G1]/[G/H/B/V1]/[_]/ ([P, Q, R, S, T]/[H1])/ ([U, V, W, X, Y]/[I1]), fw(J1, K1, L1, M1, N1, O1, 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(P1, J1/K1, Q1))/[L1, M1, N1, O1, I]/[A]/[W1]/ ([P, Q, R, S, T]/[P1])/ ([U, V, W, X, Y]/[Q1]), 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]/[])]/[R1, S1, T1, U1, 0]/[V1, B2, C2, D2, 1]),
	wymagania_oznacz_użyte(W1, Z1),
	register(fno(X1,
		     C,
		     G/H,
		     Y1,
		     Z1,
		     B,
		     V1,
		     A2,
		     I,
		     B2,
		     C2,
		     D2,
		     J2),
		 E2,
		 F2,
		 noa1,
		 
		 [ G2/fno(X1, C, G/H, Y1, A, B, R1, A2, I, S1, T1, U1, na)
		 | H2
		 ],
		 I2),
	fno(E2,
	    F2,
	    I2,
	    X1,
	    C,
	    G/H,
	    Y1,
	    Z1,
	    B,
	    V1,
	    A2,
	    I,
	    B2,
	    C2,
	    D2,
	    J2).

fno(V3, B, X3, Y3, gen, Z3, 3, wym([], A4, B4), C4, G1, pre, A, H1, I1, J1, po) :-
	do_sequence_of(D4,
		       
		       [ C,
			 U1/fno(K1, L1, E/F, M1, N1, O1, P1, Q1, A, R1, S1, T1, na)
		       | B2
		       ],
		       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(_, gen, _, 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(V1/V), najwyżej(W, _, X))/[A]/[1]/[T2]/ ([N, O, P, Q]/[W])/ ([R, S, T, U]/[X]), fw(Y, Z, A1, B1, C1, D1, 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(E1, Y/Z, F1))/[A1, B1, C1, D1, A]/[[]]/[A2]/ ([N, O, P, Q]/[E1])/ ([R, S, T, U]/[F1]), 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]/[])]/[G1, H1, I1, J1]/[W1, X1, Y1, Z1]),
	goal(fno(K1,
		 L1,
		 E/F,
		 M1,
		 N1,
		 O1,
		 P1,
		 Q1,
		 A,
		 R1,
		 S1,
		 T1,
		 na),
	     C,
	     C2,
	     U1),
	wymagania_czyste(_, N1),
	sprawdz_kl_noa(O1, L1, M),
	sprawdz_kl_nod_head(V1, O1),
	oblzap_iter(W1, P1, L3),
	obldest_iter(X1, R1, M3),
	oblink_iter(Y1, S1, N3),
	sprawdz_pk_iter(Z1, T1, O3),
	wyjmijl(A2, N1, I3),
	do_sequence_of(B2,
		       [],
		       C2,
		       W3,
		       [[optional(przec(D2, po), {}, {D2= (bp| p)}), fpt(M, E/F, _, wym([], _, _), _, F2, A, G2, H2, I2, po), optional(przec(E2, po), {}, {E2= (p| bp)})]/ (oblzap_iter(K2, F2, O2), obldest_iter(L2, G2, P2), oblink_iter(M2, H2, Q2), sprawdz_pk_iter(N2, J2, R2), sprawdz_fpt_noa(D2/I2/E2/J2))/[M, E, F, A]/[]/[]/ ([K2, L2, M2, N2]/[])/ ([O2, P2, Q2, R2]/[]), fpm(_, _, _, _, F2, A, G2, H2, J2, po)/ (oblzap_iter(K2, F2, O2), obldest_iter(L2, G2, P2), oblink_iter(M2, H2, Q2), sprawdz_pk_iter(N2, J2, R2))/[A]/[]/[]/ ([K2, L2, M2, N2]/[])/ ([O2, P2, Q2, R2]/[]), fno(_, gen, _, 3, wym([], _, _), S2, F2, pre, A, G2, H2, J2, po)/ (oblzap_iter(K2, F2, O2), obldest_iter(L2, G2, P2), oblink_iter(M2, H2, Q2), sprawdz_pk_iter(N2, J2, R2), sprawdz_kl_nod(O1/S2), najwyżej(U2, _, V2))/[A]/[T2]/[_]/ ([K2, L2, M2, N2]/[U2])/ ([O2, P2, Q2, R2]/[V2]), fzd(W2, nk, X2, Y2, Z2, _, ni, J2, po)/ (oblzap_iter(K2, F2, O2), obldest_iter(L2, G2, P2), oblink_iter(M2, H2, Q2), sprawdz_pk_iter(N2, J2, R2), sprawdz_fzd_noz(A3, W2, B3))/[X2, Y2, Z2]/[E/F/O1/P3]/[_]/ ([K2, L2, M2, N2]/[A3])/ ([O2, P2, Q2, R2]/[B3]), fw(C3, D3, E3, F3, G3, H3, post, A, G2, ni, J2, po)/ (oblzap_iter(K2, F2, O2), obldest_iter(L2, G2, P2), oblink_iter(M2, H2, Q2), sprawdz_pk_iter(N2, J2, R2), oblwym_iter(J3, C3/D3, K3))/[E3, F3, G3, H3, A]/[I3]/[Q3]/ ([K2, L2, M2, N2]/[J3])/ ([O2, P2, Q2, R2]/[K3]), modpart(fno, A, G2, ni, J2, po)/ (oblzap_iter(K2, F2, O2), obldest_iter(L2, G2, P2), oblink_iter(M2, H2, Q2), sprawdz_pk_iter(N2, J2, R2))/[A]/[]/[]/ ([K2, L2, M2, N2]/[])/ ([O2, P2, Q2, R2]/[])]/[L3, M3, N3, O3]/[P3, S3, T3, U3]),
	wymagania_oznacz_użyte(Q3, R3),
	register(fno(K1,
		     L1,
		     E/F,
		     M1,
		     R3,
		     O1,
		     P3,
		     Q1,
		     A,
		     S3,
		     T3,
		     U3,
		     F4),
		 V3,
		 W3,
		 nod2,
		 
		 [ X3/fno(Y3, gen, Z3, 3, wym([], A4, B4), C4, G1, pre, A, H1, I1, J1, po)
		 | D4
		 ],
		 E4),
	fno(V3,
	    W3,
	    E4,
	    K1,
	    L1,
	    E/F,
	    M1,
	    R3,
	    O1,
	    P3,
	    Q1,
	    A,
	    S3,
	    T3,
	    U3,
	    F4).

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

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

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

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

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

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

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

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

fno(A2, D, C2, D2, A, L1/M1, N1, wym([], E2, F2), O1, B, P1, C, M, Y1, I1, po) :-
	do_sequence_of(G2,
		       
		       [ E,
			 X/spójnik(szk, F, ni, na),
			 W,
			 H1/fno(Y, A, Z/A1, B1, wym([], C1, D1), E1, B, F1, C, G1, 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]/[J1, M, [], 0]/[[ (0| 0), N], K1, Q1, 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(Y,
		 A,
		 Z/A1,
		 B1,
		 wym([], C1, D1),
		 E1,
		 B,
		 F1,
		 C,
		 G1,
		 ni,
		 N,
		 po),
	     W,
	     B2,
	     H1),
	oblpk(Z1, [I1|J1]),
	obldest_fno_iter(K1, G1, X1),
	oblparam_fno_koor(F,
			  R1/S1/T1/V1/W1/U1,
			  L1/M1/N1/O1/P1,
			  Z/A1/B1/E1/F1,
			  Q1),
	register(fno(F,
		     A,
		     R1/S1,
		     T1,
		     U1,
		     V1,
		     B,
		     W1,
		     C,
		     X1,
		     Y1,
		     Z1,
		     I2),
		 A2,
		 B2,
		 nos2,
		 
		 [ C2/fno(D2, A, L1/M1, N1, wym([], E2, F2), O1, B, P1, C, M, Y1, I1, po)
		 | G2
		 ],
		 H2),
	fno(A2,
	    B2,
	    H2,
	    F,
	    A,
	    R1/S1,
	    T1,
	    U1,
	    V1,
	    B,
	    W1,
	    C,
	    X1,
	    Y1,
	    Z1,
	    I2).

fno(Y1, D, A2, B2, A, J1/K1, L1, wym([], C2, D2), M1, B, N1, C, K, W1, G1, po) :-
	do_sequence_of(E2,
		       
		       [ E,
			 U/spójnik(szk, S, ni, na),
			 T,
			 F1/fno(W, A, X/Y, Z, wym([], A1, B1), C1, B, D1, C, E1, 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]/[H1, K, []]/[[V, L], I1, O1]/ ([]/[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(W,
		 A,
		 X/Y,
		 Z,
		 wym([], A1, B1),
		 C1,
		 B,
		 D1,
		 C,
		 E1,
		 ni,
		 L,
		 po),
	     T,
	     Z1,
	     F1),
	oblpk(X1, [G1|H1]),
	obldest_fno_iter(I1, E1, V1),
	oblparam_fno_koor(S,
			  P1/Q1/R1/T1/U1/S1,
			  J1/K1/L1/M1/N1,
			  X/Y/Z/C1/D1,
			  O1),
	register(fno(S,
		     A,
		     P1/Q1,
		     R1,
		     S1,
		     T1,
		     B,
		     U1,
		     C,
		     V1,
		     W1,
		     X1,
		     G2),
		 Y1,
		 Z1,
		 nos3,
		 
		 [ A2/fno(B2, A, J1/K1, L1, wym([], C2, D2), M1, B, N1, C, K, W1, G1, po)
		 | E2
		 ],
		 F2),
	fno(Y1,
	    Z1,
	    F2,
	    S,
	    A,
	    P1/Q1,
	    R1,
	    S1,
	    T1,
	    B,
	    U1,
	    C,
	    V1,
	    W1,
	    X1,
	    G2).

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

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

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

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

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

fw(L, M, N, A, B, C, D, E, F, G, H, I, J, K, na) :-
	A\=subj(_),
	A\=_/_,
	register(ξ(A,
		   B,
		   C,
		   D,
		   E,
		   F,
		   G,
		   H,
		   I,
		   J,
		   K,
		   P),
		 L,
		 M,
		 x1,
		 
		 [ N/fw(A, B, C, D, E, F, G, H, I, J, K, na)
		 ],
		 O),
	ξ(L,
	  M,
	  O,
	  A,
	  B,
	  C,
	  D,
	  E,
	  F,
	  G,
	  H,
	  I,
	  J,
	  K,
	  P).

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

fw(W3, B, Y3, E1, F1, Z3, A4, B4, C4, pre, A, I1, J1, K1, po) :-
	do_sequence_of(D4,
		       
		       [ C,
			 V1/fno(L1, M1, E/F, N1, O1, P1, Q1, R1, A, S1, T1, U1, na)
		       | C2
		       ],
		       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(_, gen, _, 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(W1/V), najwyżej(W, _, X))/[A]/[2]/[U2]/ ([N, O, P, Q]/[W])/ ([R, S, T, U]/[X]), fw(Y, Z, A1, B1, C1, D1, 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(G1, Y/Z, H1))/[A1, B1, C1, D1, A]/[[E1/F1]]/[B2]/ ([N, O, P, Q]/[G1])/ ([R, S, T, U]/[H1]), 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, I1, J1, K1]/[X1, Y1, Z1, A2]),
	goal(fno(L1,
		 M1,
		 E/F,
		 N1,
		 O1,
		 P1,
		 Q1,
		 R1,
		 A,
		 S1,
		 T1,
		 U1,
		 na),
	     C,
	     D2,
	     V1),
	wymagania_czyste(_, O1),
	sprawdz_kl_noa(P1, M1, M),
	sprawdz_kl_nod_head(W1, P1),
	oblzap_iter(X1, Q1, M3),
	obldest_iter(Y1, S1, N3),
	oblink_iter(Z1, T1, O3),
	sprawdz_pk_iter(A2, U1, P3),
	wyjmijl(B2, O1, J3),
	do_sequence_of(C2,
		       [],
		       D2,
		       X3,
		       [[optional(przec(E2, po), {}, {E2= (bp| p)}), fpt(M, E/F, _, wym([], _, _), _, G2, A, H2, I2, J2, po), optional(przec(F2, po), {}, {F2= (p| bp)})]/ (oblzap_iter(L2, G2, P2), obldest_iter(M2, H2, Q2), oblink_iter(N2, I2, R2), sprawdz_pk_iter(O2, K2, S2), sprawdz_fpt_noa(E2/J2/F2/K2))/[M, E, F, A]/[]/[]/ ([L2, M2, N2, O2]/[])/ ([P2, Q2, R2, S2]/[]), fpm(_, _, _, _, G2, A, H2, I2, K2, po)/ (oblzap_iter(L2, G2, P2), obldest_iter(M2, H2, Q2), oblink_iter(N2, I2, R2), sprawdz_pk_iter(O2, K2, S2))/[A]/[]/[]/ ([L2, M2, N2, O2]/[])/ ([P2, Q2, R2, S2]/[]), fno(_, gen, _, 3, wym([], _, _), T2, G2, pre, A, H2, I2, K2, po)/ (oblzap_iter(L2, G2, P2), obldest_iter(M2, H2, Q2), oblink_iter(N2, I2, R2), sprawdz_pk_iter(O2, K2, S2), sprawdz_kl_nod(P1/T2), najwyżej(V2, _, W2))/[A]/[U2]/[_]/ ([L2, M2, N2, O2]/[V2])/ ([P2, Q2, R2, S2]/[W2]), fzd(X2, nk, Y2, Z2, A3, _, ni, K2, po)/ (oblzap_iter(L2, G2, P2), obldest_iter(M2, H2, Q2), oblink_iter(N2, I2, R2), sprawdz_pk_iter(O2, K2, S2), sprawdz_fzd_noz(B3, X2, C3))/[Y2, Z2, A3]/[E/F/P1/Q3]/[_]/ ([L2, M2, N2, O2]/[B3])/ ([P2, Q2, R2, S2]/[C3]), fw(D3, E3, F3, G3, H3, I3, post, A, H2, ni, K2, po)/ (oblzap_iter(L2, G2, P2), obldest_iter(M2, H2, Q2), oblink_iter(N2, I2, R2), sprawdz_pk_iter(O2, K2, S2), oblwym_iter(K3, D3/E3, L3))/[F3, G3, H3, I3, A]/[J3]/[R3]/ ([L2, M2, N2, O2]/[K3])/ ([P2, Q2, R2, S2]/[L3]), modpart(fno, A, H2, ni, K2, po)/ (oblzap_iter(L2, G2, P2), obldest_iter(M2, H2, Q2), oblink_iter(N2, I2, R2), sprawdz_pk_iter(O2, K2, S2))/[A]/[]/[]/ ([L2, M2, N2, O2]/[])/ ([P2, Q2, R2, S2]/[])]/[M3, N3, O3, P3]/[Q3, T3, U3, V3]),
	wymagania_oznacz_użyte(R3, S3),
	register(fno(L1,
		     M1,
		     E/F,
		     N1,
		     S3,
		     P1,
		     Q3,
		     R1,
		     A,
		     T3,
		     U3,
		     V3,
		     F4),
		 W3,
		 X3,
		 now2,
		 
		 [ Y3/fw(E1, F1, Z3, A4, B4, C4, pre, A, I1, J1, K1, po)
		 | D4
		 ],
		 E4),
	fno(W3,
	    X3,
	    E4,
	    L1,
	    M1,
	    E/F,
	    N1,
	    S3,
	    P1,
	    Q3,
	    R1,
	    A,
	    T3,
	    U3,
	    V3,
	    F4).

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

fl(I3, B, K3, D, E, A, F, G, D1, E1, F1, po) :-
	do_sequence_of(L3,
		       
		       [ C,
			 Q1/ff(G1, H1, I1, J1, A, K1, L1, M1, N1, O1, P1, na)
		       | V1
		       ],
		       B,
		       C,
		       [fw(K, L, 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), zróblistę_ξ_iter(Q, K/L, V))/[D, E, A, F, G]/[[]/nil]/[U1/U2]/ ([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]/[P2]/ ([M, N, O, P]/[X])/ ([R, S, T, U]/[Y]), ξ(Z, A1, 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), wykryjξ(B1, Z/A1, C1))/[D, E, A, F, G]/[nil]/[D2]/ ([M, N, O, P]/[B1])/ ([R, S, T, U]/[C1]), 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]/[])]/[D1, E1, F1, bezpo]/[R1, S1, T1, A3]),
	goal(ff(G1,
		H1,
		I1,
		J1,
		A,
		K1,
		L1,
		M1,
		N1,
		O1,
		P1,
		na),
	     C,
	     W1,
	     Q1),
	obldest_iter(R1, N1, X2),
	oblink_iter(S1, O1, Y2),
	sprawdz_pk_iter(T1, P1, Z2),
	wyjmijl(U1, L1, C2),
	do_sequence_of(V1,
		       [],
		       W1,
		       J3,
		       [fw(A2, B2, D, E, A, F, post, G, X1, Y1, Z1, po)/ (obldest_iter(E2, X1, J2), oblink_iter(F2, Y1, K2), sprawdz_pk_iter(G2, Z1, L2), sprawdz_post_posiłk(H2, O2, M2), oblwym_ξ_iter(I2, A2/B2, N2))/[D, E, A, F, G]/[C2/D2]/[C3/nil]/ ([E2, F2, G2, H2]/[I2])/ ([J2, K2, L2, M2]/[N2]), fl(D, E, A, F, G, X1, Y1, Z1, po)/ (obldest_iter(E2, X1, J2), oblink_iter(F2, Y1, K2), sprawdz_pk_iter(G2, Z1, L2), sprawdz_post_posiłk(H2, O2, M2), najwyżej3(Q2, _, R2))/[D, E, A, F, G]/[P2]/[_]/ ([E2, F2, G2, H2]/[Q2])/ ([J2, K2, L2, M2]/[R2]), ξ(S2, T2, D, E, A, F, post, G, X1, Y1, Z1, po)/ (obldest_iter(E2, X1, J2), oblink_iter(F2, Y1, K2), sprawdz_pk_iter(G2, Z1, L2), sprawdz_post_posiłk(H2, O2, M2), zrealizujξ(V2, S2/T2, W2))/[D, E, A, F, G]/[U2]/[nil]/ ([E2, F2, G2, H2]/[V2])/ ([J2, K2, L2, M2]/[W2]), posiłk(O2, A, X1, Y1, Z1, po)/ (obldest_iter(E2, X1, J2), oblink_iter(F2, Y1, K2), sprawdz_pk_iter(G2, Z1, L2), sprawdz_post_posiłk(H2, O2, M2))/[A]/[]/[]/ ([E2, F2, G2, H2]/[])/ ([J2, K2, L2, M2]/[])]/[X2, Y2, Z2, pierw(A3)]/[F3, G3, H3, B3]),
	oblposiłk(B3,
		  G1/H1/I1/J1/K1/M1,
		  D3/D/E/E3/F/G),
	wymagania_zamknij(C3),
	wyklucz_podmiot_bezokolicznika(D3, L1),
	register(zdanie(D3,
			D,
			E,
			E3,
			A,
			F,
			G,
			F3,
			G3,
			H3,
			N3),
		 I3,
		 J3,
		 ze3,
		 
		 [ K3/fl(D, E, A, F, G, D1, E1, F1, po)
		 | L3
		 ],
		 M3),
	zdanie(I3,
	       J3,
	       M3,
	       D3,
	       D,
	       E,
	       E3,
	       A,
	       F,
	       G,
	       F3,
	       G3,
	       H3,
	       N3).

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

fl(E2, E, G2, A, B, C, D, G, T, C2, U, po) :-
	do_sequence_of(H2,
		       
		       [ F,
			 B1/fwe(V, A, B, W, C, D, X, Y, Z, ni, A1, na)
		       | G1
		       ],
		       E,
		       F,
		       [fw(J, K, 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/K, Q))/[A, B, C, D, G]/[[]]/[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]/[T1]/ ([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, W1),
	sprawdz_pk_iter(E1, A1, X1),
	wyjmijl(F1, C1, M1),
	do_sequence_of(G1,
		       [],
		       H1,
		       F2,
		       [fw(K1, L1, A, B, C, D, post, G, I1, ni, J1, po)/ (obldest_iter(N1, I1, Q1), sprawdz_pk_iter(O1, J1, R1), oblwym_iter(P1, K1/L1, S1))/[A, B, C, D, G]/[M1]/[Y1]/ ([N1, O1]/[P1])/ ([Q1, R1]/[S1]), fl(A, B, C, D, G, I1, ni, J1, po)/ (obldest_iter(N1, I1, Q1), sprawdz_pk_iter(O1, J1, R1), najwyżej3(U1, _, V1))/[A, B, C, D, G]/[T1]/[_]/ ([N1, O1]/[U1])/ ([Q1, R1]/[V1])]/[W1, X1]/[B2, D2]),
	wymagania_oznacz_użyte(Y1, Z1),
	obl_neg_fwe(V, A2, Y, G),
	register(fwe(V,
		     A,
		     B,
		     W,
		     C,
		     D,
		     Z1,
		     A2,
		     B2,
		     C2,
		     D2,
		     J2),
		 E2,
		 F2,
		 wew3,
		 
		 [ G2/fl(A, B, C, D, G, T, C2, U, po)
		 | H2
		 ],
		 I2),
	fwe(E2,
	    F2,
	    I2,
	    V,
	    A,
	    B,
	    W,
	    C,
	    D,
	    Z1,
	    A2,
	    B2,
	    C2,
	    D2,
	    J2).

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

ξ(A3, B, C3, Z1, A2, D, E, A, F, pre, G, Z, A1, B1, po) :-
	do_sequence_of(D3,
		       
		       [ C,
			 M1/ff(C1, D1, E1, F1, A, G1, H1, I1, J1, K1, L1, na)
		       | R1
		       ],
		       B,
		       C,
		       [fw(K, L, 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/L, V))/[D, E, A, F, G]/[[]]/[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]/[M2]/ ([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, S2]),
	goal(ff(C1,
		D1,
		E1,
		F1,
		A,
		G1,
		H1,
		I1,
		J1,
		K1,
		L1,
		na),
	     C,
	     S1,
	     M1),
	obldest_iter(N1, J1, P2),
	oblink_iter(O1, K1, Q2),
	sprawdz_pk_iter(P1, L1, R2),
	wyjmijl(Q1, H1, Y1),
	do_sequence_of(R1,
		       [],
		       S1,
		       B3,
		       [fw(W1, X1, D, E, A, F, post, G, T1, U1, V1, po)/ (obldest_iter(B2, T1, G2), oblink_iter(C2, U1, H2), sprawdz_pk_iter(D2, V1, I2), sprawdz_post_posiłk(E2, L2, J2), oblwym_ξ_iter(F2, W1/X1, K2))/[D, E, A, F, G]/[Y1/ (Z1/A2)]/[U2/nil]/ ([B2, C2, D2, E2]/[F2])/ ([G2, H2, I2, J2]/[K2]), fl(D, E, A, F, G, T1, U1, V1, po)/ (obldest_iter(B2, T1, G2), oblink_iter(C2, U1, H2), sprawdz_pk_iter(D2, V1, I2), sprawdz_post_posiłk(E2, L2, J2), najwyżej3(N2, _, O2))/[D, E, A, F, G]/[M2]/[_]/ ([B2, C2, D2, E2]/[N2])/ ([G2, H2, I2, J2]/[O2]), posiłk(L2, A, T1, U1, V1, po)/ (obldest_iter(B2, T1, G2), oblink_iter(C2, U1, H2), sprawdz_pk_iter(D2, V1, I2), sprawdz_post_posiłk(E2, L2, J2))/[A]/[]/[]/ ([B2, C2, D2, E2]/[])/ ([G2, H2, I2, J2]/[])]/[P2, Q2, R2, pierw(S2)]/[X2, Y2, Z2, T2]),
	oblposiłk(T2,
		  C1/D1/E1/F1/G1/I1,
		  V2/D/E/W2/F/G),
	wymagania_zamknij(U2),
	wyklucz_podmiot_bezokolicznika(V2, H1),
	register(zdanie(V2,
			D,
			E,
			W2,
			A,
			F,
			G,
			X2,
			Y2,
			Z2,
			F3),
		 A3,
		 B3,
		 ze5,
		 
		 [ C3/ξ(Z1, A2, D, E, A, F, pre, G, Z, A1, B1, po)
		 | D3
		 ],
		 E3),
	zdanie(A3,
	       B3,
	       E3,
	       V2,
	       D,
	       E,
	       W2,
	       A,
	       F,
	       G,
	       X2,
	       Y2,
	       Z2,
	       F3).

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, I, J, K, C, D, na) :-
	realizuje(xp(B), cp(A), _),
	register(fw(xp(B),
		    lex,
		    M,
		    N,
		    O,
		    P,
		    Q,
		    R,
		    S,
		    C,
		    D,
		    T),
		 E,
		 F,
		 wy14,
		 
		 [ G/fzd(A, nk, H, I, J, K, C, D, na)
		 ],
		 L),
	fw(E,
	   F,
	   L,
	   xp(B),
	   lex,
	   M,
	   N,
	   O,
	   P,
	   Q,
	   R,
	   S,
	   C,
	   D,
	   T).

fzd(G, H, I, C, A/B, J, K, L, M, E, F, na) :-
	realizuje(xp(D), prepncp(A, B, C), _),
	register(fw(xp(D),
		    lex,
		    O,
		    P,
		    Q,
		    R,
		    S,
		    T,
		    U,
		    E,
		    F,
		    V),
		 G,
		 H,
		 wy15,
		 
		 [ I/fzd(C, A/B, J, K, L, M, E, F, na)
		 ],
		 N),
	fw(G,
	   H,
	   N,
	   xp(D),
	   lex,
	   O,
	   P,
	   Q,
	   R,
	   S,
	   T,
	   U,
	   E,
	   F,
	   V).

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fpm(J, K, L, A, C, B, M, N, F, G, H, I, na) :-
	realizuje(comprepnp(D),
		  lex(prepnp(A, B), C, _),
		  _),
	realizuje(xp(E), comprepnp(D), _),
	register(fw(xp(E),
		    lex,
		    P,
		    Q,
		    R,
		    S,
		    T,
		    F,
		    G,
		    H,
		    I,
		    U),
		 J,
		 K,
		 wy12,
		 
		 [ L/fpm(A, C, B, M, N, F, G, H, I, na)
		 ],
		 O),
	fw(J,
	   K,
	   O,
	   xp(E),
	   lex,
	   P,
	   Q,
	   R,
	   S,
	   T,
	   F,
	   G,
	   H,
	   I,
	   U).

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

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

fpm(V3, B, X3, Y3, Z3, A4, B4, G1, A, H1, I1, J1, po) :-
	do_sequence_of(C4,
		       
		       [ C,
			 U1/fno(K1, L1, E/F, M1, N1, O1, P1, Q1, A, R1, S1, T1, na)
		       | B2
		       ],
		       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(_, gen, _, 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(V1/V), najwyżej(W, _, X))/[A]/[2]/[T2]/ ([N, O, P, Q]/[W])/ ([R, S, T, U]/[X]), fw(Y, Z, A1, B1, C1, D1, 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(E1, Y/Z, F1))/[A1, B1, C1, D1, A]/[[]]/[A2]/ ([N, O, P, Q]/[E1])/ ([R, S, T, U]/[F1]), 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]/[])]/[G1, H1, I1, J1]/[W1, X1, Y1, Z1]),
	goal(fno(K1,
		 L1,
		 E/F,
		 M1,
		 N1,
		 O1,
		 P1,
		 Q1,
		 A,
		 R1,
		 S1,
		 T1,
		 na),
	     C,
	     C2,
	     U1),
	wymagania_czyste(_, N1),
	sprawdz_kl_noa(O1, L1, M),
	sprawdz_kl_nod_head(V1, O1),
	oblzap_iter(W1, P1, L3),
	obldest_iter(X1, R1, M3),
	oblink_iter(Y1, S1, N3),
	sprawdz_pk_iter(Z1, T1, O3),
	wyjmijl(A2, N1, I3),
	do_sequence_of(B2,
		       [],
		       C2,
		       W3,
		       [[optional(przec(D2, po), {}, {D2= (bp| p)}), fpt(M, E/F, _, wym([], _, _), _, F2, A, G2, H2, I2, po), optional(przec(E2, po), {}, {E2= (p| bp)})]/ (oblzap_iter(K2, F2, O2), obldest_iter(L2, G2, P2), oblink_iter(M2, H2, Q2), sprawdz_pk_iter(N2, J2, R2), sprawdz_fpt_noa(D2/I2/E2/J2))/[M, E, F, A]/[]/[]/ ([K2, L2, M2, N2]/[])/ ([O2, P2, Q2, R2]/[]), fpm(_, _, _, _, F2, A, G2, H2, J2, po)/ (oblzap_iter(K2, F2, O2), obldest_iter(L2, G2, P2), oblink_iter(M2, H2, Q2), sprawdz_pk_iter(N2, J2, R2))/[A]/[]/[]/ ([K2, L2, M2, N2]/[])/ ([O2, P2, Q2, R2]/[]), fno(_, gen, _, 3, wym([], _, _), S2, F2, pre, A, G2, H2, J2, po)/ (oblzap_iter(K2, F2, O2), obldest_iter(L2, G2, P2), oblink_iter(M2, H2, Q2), sprawdz_pk_iter(N2, J2, R2), sprawdz_kl_nod(O1/S2), najwyżej(U2, _, V2))/[A]/[T2]/[_]/ ([K2, L2, M2, N2]/[U2])/ ([O2, P2, Q2, R2]/[V2]), fzd(W2, nk, X2, Y2, Z2, _, ni, J2, po)/ (oblzap_iter(K2, F2, O2), obldest_iter(L2, G2, P2), oblink_iter(M2, H2, Q2), sprawdz_pk_iter(N2, J2, R2), sprawdz_fzd_noz(A3, W2, B3))/[X2, Y2, Z2]/[E/F/O1/P3]/[_]/ ([K2, L2, M2, N2]/[A3])/ ([O2, P2, Q2, R2]/[B3]), fw(C3, D3, E3, F3, G3, H3, post, A, G2, ni, J2, po)/ (oblzap_iter(K2, F2, O2), obldest_iter(L2, G2, P2), oblink_iter(M2, H2, Q2), sprawdz_pk_iter(N2, J2, R2), oblwym_iter(J3, C3/D3, K3))/[E3, F3, G3, H3, A]/[I3]/[Q3]/ ([K2, L2, M2, N2]/[J3])/ ([O2, P2, Q2, R2]/[K3]), modpart(fno, A, G2, ni, J2, po)/ (oblzap_iter(K2, F2, O2), obldest_iter(L2, G2, P2), oblink_iter(M2, H2, Q2), sprawdz_pk_iter(N2, J2, R2))/[A]/[]/[]/ ([K2, L2, M2, N2]/[])/ ([O2, P2, Q2, R2]/[])]/[L3, M3, N3, O3]/[P3, S3, T3, U3]),
	wymagania_oznacz_użyte(Q3, R3),
	register(fno(K1,
		     L1,
		     E/F,
		     M1,
		     R3,
		     O1,
		     P3,
		     Q1,
		     A,
		     S3,
		     T3,
		     U3,
		     E4),
		 V3,
		 W3,
		 nop2,
		 
		 [ X3/fpm(Y3, Z3, A4, B4, G1, A, H1, I1, J1, po)
		 | C4
		 ],
		 D4),
	fno(V3,
	    W3,
	    D4,
	    K1,
	    L1,
	    E/F,
	    M1,
	    R3,
	    O1,
	    P3,
	    Q1,
	    A,
	    S3,
	    T3,
	    U3,
	    E4).

fpm(Z, B, B1, S, T, U, A, V, C, P, Q, R, na) :-
	A\= (mod),
	do_sequence_of(C1,
		       [],
		       B,
		       A1,
		       [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]/[W, X, Y, 1]),
	register(fpm(S,
		     T,
		     U,
		     (mod),
		     V,
		     C,
		     W,
		     X,
		     Y,
		     E1),
		 Z,
		 A1,
		 pm4,
		 
		 [ B1/fpm(S, T, U, A, V, C, P, Q, R, na)
		 | C1
		 ],
		 D1),
	fpm(Z,
	    A1,
	    D1,
	    S,
	    T,
	    U,
	    (mod),
	    V,
	    C,
	    W,
	    X,
	    Y,
	    E1).

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

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

fpm(P1, D, R1, N, S1, O, A, B, C, M, N1, G1, po) :-
	sprawdz_kl_nie_sz(A),
	do_sequence_of(T1,
		       
		       [ E,
			 Z/spójnik(szk, F, ni, na),
			 Y,
			 F1/fpm(A1, B1, C1, D1, B, C, E1, 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]/[H1, M, [N/O], 0]/[[ (0| 0), P], I1, J1, 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,
		 D1,
		 B,
		 C,
		 E1,
		 ni,
		 P,
		 po),
	     Y,
	     Q1,
	     F1),
	sprawdz_kl_nie_sz(D1),
	oblpk(O1, [G1|H1]),
	obldest_fno_iter(I1, E1, M1),
	obl_pmp([A1/C1|J1], K1, L1),
	register(fpm(K1,
		     F,
		     L1,
		     sz,
		     B,
		     C,
		     M1,
		     N1,
		     O1,
		     V1),
		 P1,
		 Q1,
		 pms2,
		 
		 [ R1/fpm(N, S1, O, A, B, C, M, N1, G1, po)
		 | T1
		 ],
		 U1),
	fpm(P1,
	    Q1,
	    U1,
	    K1,
	    F,
	    L1,
	    sz,
	    B,
	    C,
	    M1,
	    N1,
	    O1,
	    V1).

fpm(N1, D, P1, L, Q1, M, A, B, C, K, L1, E1, po) :-
	sprawdz_kl_nie_sz(A),
	do_sequence_of(R1,
		       
		       [ E,
			 W/spójnik(szk, U, ni, na),
			 V,
			 D1/fpm(Y, Z, A1, B1, B, C, C1, 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]/[F1, K, [L/M]]/[[X, N], G1, H1]/ ([]/[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,
		 B1,
		 B,
		 C,
		 C1,
		 ni,
		 N,
		 po),
	     V,
	     O1,
	     D1),
	sprawdz_kl_nie_sz(B1),
	oblpk(M1, [E1|F1]),
	obldest_fno_iter(G1, C1, K1),
	obl_pmp([Y/A1|H1], I1, J1),
	register(fpm(I1,
		     U,
		     J1,
		     sz,
		     B,
		     C,
		     K1,
		     L1,
		     M1,
		     T1),
		 N1,
		 O1,
		 pmsz3,
		 
		 [ P1/fpm(L, Q1, M, A, B, C, K, L1, E1, po)
		 | R1
		 ],
		 S1),
	fpm(N1,
	    O1,
	    S1,
	    I1,
	    U,
	    J1,
	    sz,
	    B,
	    C,
	    K1,
	    L1,
	    M1,
	    T1).

fpm(X2, A, Z2, A3, B3, C3, D3, Z, E3, A1, B1, C1, po) :-
	do_sequence_of(F3,
		       
		       [ B,
			 K1/fpt(X, Y, D1, E1, F1, G1, W, H1, I1, J1, na)
		       | Q1
		       ],
		       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, T, 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/P, V))/[Q, R, S, T]/[[]]/[P1]/ ([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, C1]/[L1, M1, N1, O1]),
	goal(fpt(X,
		 Y,
		 D1,
		 E1,
		 F1,
		 G1,
		 W,
		 H1,
		 I1,
		 J1,
		 na),
	     B,
	     R1,
	     K1),
	wymagania_czyste(_, E1),
	oblzap_iter(L1, G1, N2),
	obldest_iter(M1, H1, O2),
	oblink_iter(N1, I1, P2),
	sprawdz_pk_iter(O1, J1, Q2),
	wyjmijl(P1, E1, K2),
	do_sequence_of(Q1,
		       [],
		       R1,
		       Y2,
		       [fps(_, _, _, _, S1, T1, U1, po)/ (oblzap_iter(V1, D2, Z1), obldest_iter(W1, S1, A2), oblink_iter(X1, T1, B2), sprawdz_pk_iter(Y1, U1, C2))/[]/[]/[]/ ([V1, W1, X1, Y1]/[])/ ([Z1, A2, B2, C2]/[]), fpm(_, _, _, _, D2, _, S1, T1, U1, po)/ (oblzap_iter(V1, D2, Z1), obldest_iter(W1, S1, A2), oblink_iter(X1, T1, B2), sprawdz_pk_iter(Y1, U1, C2))/[]/[]/[]/ ([V1, W1, X1, Y1]/[])/ ([Z1, A2, B2, C2]/[]), fw(E2, F2, G2, H2, I2, J2, post, tak, S1, T1, U1, po)/ (oblzap_iter(V1, D2, Z1), obldest_iter(W1, S1, A2), oblink_iter(X1, T1, B2), sprawdz_pk_iter(Y1, U1, C2), oblwym_iter(L2, E2/F2, M2))/[G2, H2, I2, J2]/[K2]/[R2]/ ([V1, W1, X1, Y1]/[L2])/ ([Z1, A2, B2, C2]/[M2]), modpart(fpt, W, S1, T1, U1, po)/ (oblzap_iter(V1, D2, Z1), obldest_iter(W1, S1, A2), oblink_iter(X1, T1, B2), sprawdz_pk_iter(Y1, U1, C2))/[W]/[]/[]/ ([V1, W1, X1, Y1]/[])/ ([Z1, A2, B2, C2]/[]), modjaki(X, Y, D2, S1, T1, U1, po)/ (oblzap_iter(V1, D2, Z1), obldest_iter(W1, S1, A2), oblink_iter(X1, T1, B2), sprawdz_pk_iter(Y1, U1, C2))/[X, Y]/[]/[]/ ([V1, W1, X1, Y1]/[])/ ([Z1, A2, B2, C2]/[])]/[N2, O2, P2, Q2]/[T2, U2, V2, W2]),
	wymagania_oznacz_użyte(R2, S2),
	register(fpt(X,
		     Y,
		     D1,
		     S2,
		     F1,
		     T2,
		     W,
		     U2,
		     V2,
		     W2,
		     H3),
		 X2,
		 Y2,
		 ptm2,
		 
		 [ Z2/fpm(A3, B3, C3, D3, Z, E3, A1, B1, C1, po)
		 | F3
		 ],
		 G3),
	fpt(X2,
	    Y2,
	    G3,
	    X,
	    Y,
	    D1,
	    S2,
	    F1,
	    T2,
	    W,
	    U2,
	    V2,
	    W2,
	    H3).

fpm(S1, B, U1, V1, W1, X1, Y1, Z1, A, N, O, P, po) :-
	do_sequence_of(A2,
		       
		       [ C,
			 W/fps(Q, R, S, A, T, U, V, na)
		       | A1
		       ],
		       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]/[X, Y, Z]),
	goal(fps(Q,
		 R,
		 S,
		 A,
		 T,
		 U,
		 V,
		 na),
	     C,
	     B1,
	     W),
	S\= (mod),
	obldest_iter(X, T, M1),
	oblink_iter(Y, U, N1),
	sprawdz_pk_iter(Z, V, O1),
	do_sequence_of(A1,
		       [],
		       B1,
		       T1,
		       [fpm(_, _, _, L1, _, A, C1, D1, E1, po)/ (obldest_iter(F1, C1, I1), oblink_iter(G1, D1, J1), sprawdz_pk_iter(H1, E1, K1))/[A]/[]/[]/ ([F1, G1, H1]/[])/ ([I1, J1, K1]/[]), fps(_, _, L1, A, C1, D1, E1, po)/ (obldest_iter(F1, C1, I1), oblink_iter(G1, D1, J1), sprawdz_pk_iter(H1, E1, K1))/[A]/[]/[]/ ([F1, G1, H1]/[])/ ([I1, J1, K1]/[]), modpart(fpt, A, C1, D1, E1, po)/ (obldest_iter(F1, C1, I1), oblink_iter(G1, D1, J1), sprawdz_pk_iter(H1, E1, K1))/[A]/[]/[]/ ([F1, G1, H1]/[])/ ([I1, J1, K1]/[])]/[M1, N1, O1]/[P1, Q1, R1]),
	register(fps(Q,
		     R,
		     (mod),
		     A,
		     P1,
		     Q1,
		     R1,
		     C2),
		 S1,
		 T1,
		 psm2,
		 
		 [ U1/fpm(V1, W1, X1, Y1, Z1, A, N, O, P, po)
		 | A2
		 ],
		 B2),
	fps(S1,
	    T1,
	    B2,
	    Q,
	    R,
	    (mod),
	    A,
	    P1,
	    Q1,
	    R1,
	    C2).

fpmpt(G, H, I, A, B, J, K, C, D, E, F, na) :-
	register(fw(prepadjp(A, B),
		    lex,
		    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),
	   lex,
	   M,
	   N,
	   O,
	   P,
	   Q,
	   C,
	   D,
	   E,
	   F,
	   R).

fpmpt(E, F, G, H, postp, I, J, A, B, C, D, na) :-
	register(fl(L,
		    M,
		    N,
		    O,
		    A,
		    B,
		    C,
		    D,
		    P),
		 E,
		 F,
		 lu14,
		 
		 [ G/fpmpt(H, postp, 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,
		    się,
		    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,
	   się,
	   F,
	   G,
	   H,
	   I,
	   J,
	   K,
	   neut,
	   ni,
	   (0| 0),
	   L).

terminal(A, B, C, morf(D, się, qub)) :-
	register(fw(subj(np(nom)),
		    się,
		    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(nom)),
	   się,
	   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, acc),
	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(D, B, F, morf(G, w, prep:A:H)) :-
	przypadki(A, acc),
	goal(terminal(morf(J, ciemno, adv:pos)), B, E, I),
	member(C, [fno, fin]),
	register(modpart(C, L, neut, ni, (0| 0), M),
		 D,
		 E,
		 mp10,
		 
		 [ F/terminal(morf(G, w, prep:A:H)),
		   B,
		   I/terminal(morf(J, ciemno, adv:pos))
		 ],
		 K),
	modpart(D,
		E,
		K,
		C,
		L,
		neut,
		ni,
		(0| 0),
		M).

terminal(E, B, G, morf(H, co, prep:A)) :-
	przypadki(A, acc),
	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(C, A, E, morf(F, być, inf:imperf)) :-
	goal(terminal(morf(H, może, qub)), A, D, G),
	member(B, [fin, fpt]),
	register(modpart(B, J, neut, ni, (0| 0), K),
		 C,
		 D,
		 mp11,
		 
		 [ E/terminal(morf(F, być, inf:imperf)),
		   A,
		   G/terminal(morf(H, może, qub))
		 ],
		 I),
	modpart(C,
		D,
		I,
		B,
		J,
		neut,
		ni,
		(0| 0),
		K).

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(D, E, F/G, H, N),
		 I,
		 J,
		 n_rz1,
		 
		 [ K/terminal(morf(L, D, subst:A:B:C))
		 ],
		 M),
	formarzecz(I,
		   J,
		   M,
		   D,
		   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(D, E, F/G, H, N),
		 I,
		 J,
		 n_rz2,
		 
		 [ K/terminal(morf(L, D, depr:A:B:C))
		 ],
		 M),
	formarzecz(I,
		   J,
		   M,
		   D,
		   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(D, 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,
		   D,
		   E,
		   F/G,
		   H,
		   P).

terminal(E, F, G, morf(H, B, siebie:A)) :-
	przypadki(A, C),
	rekcja_pusta(D),
	register(formarzecz(B,
			    C,
			    J/K,
			    D,
			    L),
		 E,
		 F,
		 n_rz4,
		 [G/terminal(morf(H, B, siebie:A))],
		 I),
	formarzecz(E,
		   F,
		   I,
		   B,
		   C,
		   J/K,
		   D,
		   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(D,
			    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,
		   D,
		   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(A,
			    H,
			    I/J,
			    K,
			    R),
		 L,
		 M,
		 n_rz6,
		 
		 [ N/terminal(morf(O, A, brev:B))
		 | P
		 ],
		 Q),
	formarzecz(L,
		   M,
		   Q,
		   A,
		   H,
		   I/J,
		   K,
		   R).

terminal(H, D, J, morf(B, A, brev:C)) :-
	slowskr(A, B, C, E, ini),
	member(F, [nom, gen, dat, acc, inst, loc]),
	optional(K,
		 [],
		 D,
		 I,
		 terminal(morf('.', _, interp)),
		 { E\=kon
		 },
		 { E\=nkon
		 }),
	rekcja_zablokowana(G),
	register(formarzecz(A, F, M/poj, G, N),
		 H,
		 I,
		 n_rz7,
		 
		 [ J/terminal(morf(B, A, brev:C))
		 | K
		 ],
		 L),
	formarzecz(H,
		   I,
		   L,
		   A,
		   F,
		   M/poj,
		   G,
		   N).

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

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

terminal(J, K, L, morf(M, E, ppron3:A:B:C:D:N)) :-
	liczba(A, H),
	przypadki(B, F),
	rodzaj(C, G),
	osoba(D, I),
	register(zaimos(E, F, G/H, I, P),
		 J,
		 K,
		 n_zo3,
		 
		 [ L/terminal(morf(M, E, ppron3:A:B:C:D:N))
		 ],
		 O),
	zaimos(J,
	       K,
	       O,
	       E,
	       F,
	       G/H,
	       I,
	       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(D, B, F, morf(G, A, conj)) :-
	równe(A, [ale, lecz]),
	goal(terminal(morf(I, C, conj)), B, E, H),
	równe(C, [i, również, także]),
	register(spójnik(rp, nietylko, ni, K),
		 D,
		 E,
		 sr4c,
		 
		 [ F/terminal(morf(G, A, conj)),
		   B,
		   H/terminal(morf(I, C, conj))
		 ],
		 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(E, A, G, morf(H, jak, conj)) :-
	goal(terminal(morf(J, B, C)), A, F, I),
	równe(D, [tak, zarówno]),
	równe(B, [i, też]),
	member(C, [qub, conj]),
	register(spójnik(rp, D, ni, L),
		 E,
		 F,
		 sr6,
		 
		 [ G/terminal(morf(H, jak, conj)),
		   A,
		   I/terminal(morf(J, B, C))
		 ],
		 K),
	spójnik(E, F, K, rp, D, ni, L).

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(D, B, F, morf(G, A, conj)) :-
	równe(A, [a, ale, lecz]),
	goal(terminal(morf(I, C, conj)), B, E, H),
	równe(C, [i, nawet, również, także]),
	register(spójnik(rc, alei, ni, K),
		 D,
		 E,
		 sr11c,
		 
		 [ F/terminal(morf(G, A, conj)),
		   B,
		   H/terminal(morf(I, C, conj))
		 ],
		 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(D, E, F, morf(G, B, A)) :-
	member(A, [conj, comp]),
	równe(C, [pc, i(p, więc)]),
	równe(B, [przeto, więc, zatem]),
	register(spójnik(C, więc, ni, I),
		 D,
		 E,
		 spoj28,
		 [F/terminal(morf(G, B, A))],
		 H),
	spójnik(D, E, H, C, więc, ni, I).

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

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(D, A, F, morf(G, a, conj)) :-
	goal(terminal(morf(I, C, B)), A, E, H),
	member(B, [conj, comp]),
	member(C, [przeto, więc, zatem]),
	register(spójnik(rc, więc, ni, K),
		 D,
		 E,
		 spoj48,
		 
		 [ F/terminal(morf(G, a, conj)),
		   A,
		   H/terminal(morf(I, C, B))
		 ],
		 J),
	spójnik(D, E, J, rc, więc, ni, K).

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

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(L, A, N, morf(O, nie, qub)) :-
	goal(terminal(morf(Q,
			   F,
			   adj:B:C:D:E)),
	     A,
	     M,
	     P),
	liczba(B, I),
	przypadki(C, G),
	rodzaj(D, H),
	stopien(E, J),
	rekcja_przymiotnikowa(F, K),
	register(formaprzym(G,
			    H/I,
			    J,
			    K,
			    S),
		 L,
		 M,
		 n_pt1n,
		 
		 [ N/terminal(morf(O, nie, qub)),
		   A,
		   P/terminal(morf(Q, F, adj:B:C:D:E))
		 ],
		 R),
	formaprzym(L,
		   M,
		   R,
		   G,
		   H/I,
		   J,
		   K,
		   S).

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(postp, H/I, row, A, J),
		 B,
		 C,
		 n_pt7,
		 [D/terminal(morf(E, F, adjp))],
		 G),
	formaprzym(B,
		   C,
		   G,
		   postp,
		   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(nom, B/poj, row, C, I),
		 D,
		 E,
		 n_pt5,
		 [F/terminal(morf(G, A, adjc))],
		 H),
	formaprzym(D,
		   E,
		   H,
		   nom,
		   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/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/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/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/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(D, E, F, morf(G, B, adv:A)) :-
	stopien(A, C),
	register(formaprzys(B, C, przys, I, neut, J),
		 D,
		 E,
		 eps1,
		 [F/terminal(morf(G, B, adv:A))],
		 H),
	formaprzys(D,
		   E,
		   H,
		   B,
		   C,
		   przys,
		   I,
		   neut,
		   J).

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

terminal(E, A, G, morf(H, nie, qub)) :-
	goal(terminal(morf(J, C, adv:B)),
	     A,
	     F,
	     I),
	stopien(B, D),
	register(formaprzys(C, D, przys, L, neut, M),
		 E,
		 F,
		 eps1n,
		 
		 [ G/terminal(morf(H, nie, qub)),
		   A,
		   I/terminal(morf(J, C, adv:B))
		 ],
		 K),
	formaprzys(E,
		   F,
		   K,
		   C,
		   D,
		   przys,
		   L,
		   neut,
		   M).

terminal(C, A, E, morf(F, nie, qub)) :-
	goal(terminal(morf(H, B, adv)), A, D, G),
	register(formaprzys(B, row, przys, J, neut, K),
		 C,
		 D,
		 eps2n,
		 
		 [ E/terminal(morf(F, nie, qub)),
		   A,
		   G/terminal(morf(H, B, adv))
		 ],
		 I),
	formaprzys(C,
		   D,
		   I,
		   B,
		   row,
		   przys,
		   J,
		   neut,
		   K).

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

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

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

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

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

terminal(E, B, G, morf(H, na, prep:A)) :-
	przypadki(A, acc),
	goal(terminal(morf(J, C, adv:com)), B, F, I),
	member(C, [długo, poważnie]),
	format(atom(D), 'na_~a', C),
	register(formaprzys(D, wyz, przys, L, neut, M),
		 E,
		 F,
		 eps10c,
		 
		 [ G/terminal(morf(H, na, prep:A)),
		   B,
		   I/terminal(morf(J, C, adv:com))
		 ],
		 K),
	formaprzys(E,
		   F,
		   K,
		   D,
		   wyz,
		   przys,
		   L,
		   neut,
		   M).

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

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

terminal(B, A, D, morf(E, i, conj)) :-
	goal(terminal(morf(G, tak, padv)), A, C, F),
	register(formaprzys(i_tak, 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,
		   i_tak,
		   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(jak_zwykle, 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,
		   jak_zwykle,
		   row,
		   przys,
		   I,
		   neut,
		   J).

terminal(D, B, F, morf(G, za, prep:A)) :-
	przypadki(A, acc),
	goal(terminal(morf(I, C, adv)), B, E, H),
	member(C, [darmo]),
	register(formaprzys('za darmo', 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,
		   'za darmo',
		   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(E, co, prep:acc)) :-
	goal(terminal(morf(G, do, prep:gen)), A, C, F),
	register(przyimek('co do', gen, I),
		 B,
		 C,
		 jel3a,
		 
		 [ D/terminal(morf(E, co, prep:acc)),
		   A,
		   F/terminal(morf(G, do, prep:gen))
		 ],
		 H),
	przyimek(B, C, H, 'co do', gen, I).

terminal(D, B, F, morf(G, na, prep:A)) :-
	przypadki(A, acc),
	goal(terminal(morf(I, temat, subst:sg:C:m3)),
	     B,
	     E,
	     H),
	przypadki(C, acc),
	register(przyimek('na temat', gen, K),
		 D,
		 E,
		 jel3b,
		 
		 [ F/terminal(morf(G, na, prep:A)),
		   B,
		   H/terminal(morf(I, temat, subst:sg:C:m3))
		 ],
		 J),
	przyimek(D, E, J, 'na temat', gen, K).

terminal(C, B, E, morf(F, w, prep:A:nwok)) :-
	przypadki(A, loc),
	goal(terminal(morf(H, sprawa, subst:sg:I:f)),
	     B,
	     D,
	     G),
	przypadki(A, loc),
	register(przyimek('w sprawie', gen, K),
		 C,
		 D,
		 jel3c,
		 
		 [ E/terminal(morf(F, w, prep:A:nwok)),
		   B,
		   G/terminal(morf(H, sprawa, subst:sg:I:f))
		 ],
		 J),
	przyimek(C, D, J, 'w sprawie', gen, K).

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

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

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

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

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

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(B, A, D, morf(?, E, interp)) :-
	goal(terminal(morf(?, G, interp)), A, C, F),
	register(znakkonca(pyt, I),
		 B,
		 C,
		 int21,
		 
		 [ D/terminal(morf(?, E, interp)),
		   A,
		   F/terminal(morf(?, G, interp))
		 ],
		 H),
	znakkonca(B, C, H, pyt, 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(znakkonca(pyt, L),
		 C,
		 D,
		 int22,
		 
		 [ E/terminal(morf(?, F, interp)),
		   A,
		   G/terminal(morf(?, H, interp)),
		   B,
		   I/terminal(morf(?, J, interp))
		 ],
		 K),
	znakkonca(C, D, K, pyt, L).

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, [nom, inst]),
	member(B, [A, pred]),
	register(fw(adjp(B),
		    lex,
		    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),
	   lex,
	   Q,
	   R,
	   S,
	   T,
	   U,
	   C,
	   D,
	   E,
	   F,
	   V).

fpt(G, H, I, A, J, K, B, L, M, C, D, E, F, na) :-
	member(A, [nom, inst]),
	register(fw(adjp(pred)/B,
		    lex,
		    O,
		    P,
		    Q,
		    R,
		    S,
		    C,
		    D,
		    E,
		    F,
		    T),
		 G,
		 H,
		 wya1x,
		 
		 [ I/fpt(A, J, K, B, L, M, C, D, E, F, na)
		 ],
		 N),
	fw(G,
	   H,
	   N,
	   adjp(pred)/B,
	   lex,
	   O,
	   P,
	   Q,
	   R,
	   S,
	   C,
	   D,
	   E,
	   F,
	   T).

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

fpt(D, E, F, acc, G, H, wym([], I, J), K, L, tak, A, B, C, na) :-
	register(fw(adjp(accgen),
		    lex,
		    N,
		    O,
		    P,
		    Q,
		    R,
		    tak,
		    A,
		    B,
		    C,
		    S),
		 D,
		 E,
		 wya3,
		 
		 [ F/fpt(acc, G, H, wym([], I, J), K, L, tak, A, B, C, na)
		 ],
		 M),
	fw(D,
	   E,
	   M,
	   adjp(accgen),
	   lex,
	   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, [nom, gen, dat, acc, inst]),
	(   A=nom
	*-> _=_
	;   true
	),
	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(J, K, L, C, D/E, M, wym([], F, N), O, A, G, B, H, I, na) :-
	member(A, [bzap, tk]),
	member(B, [neut, pyt]),
	register(fno(przym,
		     C,
		     D/E,
		     3,
		     wym(Q, F, [[]]),
		     przym,
		     A,
		     R,
		     G,
		     B,
		     H,
		     I,
		     S),
		 J,
		 K,
		 no9,
		 
		 [ L/fpt(C, D/E, M, wym([], F, N), O, A, G, B, H, I, na)
		 ],
		 P),
	fno(J,
	    K,
	    P,
	    przym,
	    C,
	    D/E,
	    3,
	    wym(Q, F, [[]]),
	    przym,
	    A,
	    R,
	    G,
	    B,
	    H,
	    I,
	    S).

fpt(V3, D, X3, G, A/B, Y3, wym([], Z3, A4), B4, G1, C, H1, I1, J1, po) :-
	do_sequence_of(C4,
		       
		       [ E,
			 U1/fno(K1, L1, A/B, M1, N1, O1, P1, Q1, C, R1, S1, T1, na)
		       | B2
		       ],
		       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(_, gen, _, 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(V1/V), najwyżej(W, _, X))/[C]/[2]/[T2]/ ([N, O, P, Q]/[W])/ ([R, S, T, U]/[X]), fw(Y, Z, A1, B1, C1, D1, 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(E1, Y/Z, F1))/[A1, B1, C1, D1, C]/[[]]/[A2]/ ([N, O, P, Q]/[E1])/ ([R, S, T, U]/[F1]), 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]/[])]/[G1, H1, I1, J1]/[W1, X1, Y1, Z1]),
	goal(fno(K1,
		 L1,
		 A/B,
		 M1,
		 N1,
		 O1,
		 P1,
		 Q1,
		 C,
		 R1,
		 S1,
		 T1,
		 na),
	     E,
	     C2,
	     U1),
	wymagania_czyste(_, N1),
	sprawdz_kl_noa(O1, L1, G),
	sprawdz_kl_nod_head(V1, O1),
	oblzap_iter(W1, P1, L3),
	obldest_iter(X1, R1, M3),
	oblink_iter(Y1, S1, N3),
	sprawdz_pk_iter(Z1, T1, O3),
	wyjmijl(A2, N1, I3),
	do_sequence_of(B2,
		       [],
		       C2,
		       W3,
		       [[optional(przec(D2, po), {}, {D2= (bp| p)}), fpt(G, A/B, _, wym([], _, _), _, F2, C, G2, H2, I2, po), optional(przec(E2, po), {}, {E2= (p| bp)})]/ (oblzap_iter(K2, F2, O2), obldest_iter(L2, G2, P2), oblink_iter(M2, H2, Q2), sprawdz_pk_iter(N2, J2, R2), sprawdz_fpt_noa(D2/I2/E2/J2))/[G, A, B, C]/[]/[]/ ([K2, L2, M2, N2]/[])/ ([O2, P2, Q2, R2]/[]), fpm(_, _, _, _, F2, C, G2, H2, J2, po)/ (oblzap_iter(K2, F2, O2), obldest_iter(L2, G2, P2), oblink_iter(M2, H2, Q2), sprawdz_pk_iter(N2, J2, R2))/[C]/[]/[]/ ([K2, L2, M2, N2]/[])/ ([O2, P2, Q2, R2]/[]), fno(_, gen, _, 3, wym([], _, _), S2, F2, pre, C, G2, H2, J2, po)/ (oblzap_iter(K2, F2, O2), obldest_iter(L2, G2, P2), oblink_iter(M2, H2, Q2), sprawdz_pk_iter(N2, J2, R2), sprawdz_kl_nod(O1/S2), najwyżej(U2, _, V2))/[C]/[T2]/[_]/ ([K2, L2, M2, N2]/[U2])/ ([O2, P2, Q2, R2]/[V2]), fzd(W2, nk, X2, Y2, Z2, _, ni, J2, po)/ (oblzap_iter(K2, F2, O2), obldest_iter(L2, G2, P2), oblink_iter(M2, H2, Q2), sprawdz_pk_iter(N2, J2, R2), sprawdz_fzd_noz(A3, W2, B3))/[X2, Y2, Z2]/[A/B/O1/P3]/[_]/ ([K2, L2, M2, N2]/[A3])/ ([O2, P2, Q2, R2]/[B3]), fw(C3, D3, E3, F3, G3, H3, post, C, G2, ni, J2, po)/ (oblzap_iter(K2, F2, O2), obldest_iter(L2, G2, P2), oblink_iter(M2, H2, Q2), sprawdz_pk_iter(N2, J2, R2), oblwym_iter(J3, C3/D3, K3))/[E3, F3, G3, H3, C]/[I3]/[Q3]/ ([K2, L2, M2, N2]/[J3])/ ([O2, P2, Q2, R2]/[K3]), modpart(fno, C, G2, ni, J2, po)/ (oblzap_iter(K2, F2, O2), obldest_iter(L2, G2, P2), oblink_iter(M2, H2, Q2), sprawdz_pk_iter(N2, J2, R2))/[C]/[]/[]/ ([K2, L2, M2, N2]/[])/ ([O2, P2, Q2, R2]/[])]/[L3, M3, N3, O3]/[P3, S3, T3, U3]),
	wymagania_oznacz_użyte(Q3, R3),
	register(fno(K1,
		     L1,
		     A/B,
		     M1,
		     R3,
		     O1,
		     P3,
		     Q1,
		     C,
		     S3,
		     T3,
		     U3,
		     E4),
		 V3,
		 W3,
		 noa2,
		 
		 [ X3/fpt(G, A/B, Y3, wym([], Z3, A4), B4, G1, C, H1, I1, J1, po)
		 | C4
		 ],
		 D4),
	fno(V3,
	    W3,
	    D4,
	    K1,
	    L1,
	    A/B,
	    M1,
	    R3,
	    O1,
	    P3,
	    Q1,
	    C,
	    S3,
	    T3,
	    U3,
	    E4).

fpt(R, C, T, gen, A/B, U, wym([], V, W), X, H, M, D, F, J, po) :-
	goal(flicz(nom,
		   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(A1,
		     nom,
		     r(mn(n), nmo(np(n)))/poj,
		     3,
		     L,
		     B1,
		     nuzg,
		     C1,
		     M,
		     N,
		     O,
		     P,
		     Q),
		 R,
		 S,
		 nol10,
		 
		 [ T/fpt(gen, A/B, U, wym([], V, W), X, H, M, D, F, J, po),
		   C,
		   Y/flicz(nom, A/B, nuzg, I, E, G, K, na)
		 ],
		 Z),
	fno(R,
	    S,
	    Z,
	    A1,
	    nom,
	    r(mn(n), nmo(np(n)))/poj,
	    3,
	    L,
	    B1,
	    nuzg,
	    C1,
	    M,
	    N,
	    O,
	    P,
	    Q).

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

fpt(R, C, T, nom, A/B, U, wym([], V, W), X, H, N, D, F, J, po) :-
	goal(flicz(nom,
		   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(A1,
		     nom,
		     r(mn(n), nmo(np(n)))/poj,
		     3,
		     L,
		     nuzg,
		     M,
		     B1,
		     N,
		     O,
		     P,
		     Q,
		     C1),
		 R,
		 S,
		 nol12,
		 
		 [ T/fpt(nom, A/B, U, wym([], V, W), X, H, N, D, F, J, po),
		   C,
		   Y/flicz(nom, A/B, nuzg, I, E, G, K, na)
		 ],
		 Z),
	fno(R,
	    S,
	    Z,
	    A1,
	    nom,
	    r(mn(n), nmo(np(n)))/poj,
	    3,
	    L,
	    nuzg,
	    M,
	    B1,
	    N,
	    O,
	    P,
	    Q,
	    C1).

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

fpt(O1, B, Q1, A1, B1, H1, A, J1, C1, Z, D1, E1, F1, na) :-
	wymagania_czyste(_, A),
	do_sequence_of(R1,
		       [],
		       B,
		       P1,
		       [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, W, 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(X, R/S, Y))/[T, U, V, W]/[A]/[G1]/ ([F, G, H, I, J]/[X])/ ([K, L, M, N, O]/[Y]), modpart(fpt, Z, 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]/[]/[]/ ([F, G, H, I, J]/[])/ ([K, L, M, N, O]/[]), modjaki(A1, B1, 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))/[A1, B1]/[]/[]/ ([F, G, H, I, J]/[])/ ([K, L, M, N, O]/[])]/[C1, D1, E1, F1, 0]/[K1, L1, M1, N1, 1]),
	wymagania_oznacz_użyte(G1, I1),
	register(fpt(A1,
		     B1,
		     H1,
		     I1,
		     J1,
		     K1,
		     Z,
		     L1,
		     M1,
		     N1,
		     T1),
		 O1,
		 P1,
		 pts1,
		 
		 [ Q1/fpt(A1, B1, H1, A, J1, C1, Z, D1, E1, F1, na)
		 | R1
		 ],
		 S1),
	fpt(O1,
	    P1,
	    S1,
	    A1,
	    B1,
	    H1,
	    I1,
	    J1,
	    K1,
	    Z,
	    L1,
	    M1,
	    N1,
	    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(J, K, L, A, B, M, F, G, H, I, na) :-
	lex_dla_advp(E, A, B),
	realizuje(advp(C), A, _),
	member(D, [xp(C), advp(C)]),
	D\=xp(misc),
	register(fw(D,
		    E,
		    O,
		    P,
		    Q,
		    R,
		    S,
		    F,
		    G,
		    H,
		    I,
		    T),
		 J,
		 K,
		 wy9,
		 
		 [ L/fps(A, B, M, F, G, H, I, na)
		 ],
		 N),
	fw(J,
	   K,
	   N,
	   D,
	   E,
	   O,
	   P,
	   Q,
	   R,
	   S,
	   F,
	   G,
	   H,
	   I,
	   T).

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

fps(R1, B, T1, U1, V1, W1, A, N, O, P, po) :-
	do_sequence_of(X1,
		       
		       [ C,
			 Y/fpm(Q, R, S, T, U, A, V, W, X, na)
		       | C1
		       ],
		       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]/[Z, A1, B1]),
	goal(fpm(Q,
		 R,
		 S,
		 T,
		 U,
		 A,
		 V,
		 W,
		 X,
		 na),
	     C,
	     D1,
	     Y),
	T\= (mod),
	obldest_iter(Z, V, M1),
	oblink_iter(A1, W, _),
	sprawdz_pk_iter(B1, X, N1),
	do_sequence_of(C1,
		       [],
		       D1,
		       S1,
		       [fps(_, _, _, A, F, E1, F1, po)/ (obldest_iter(G1, F, J1), oblink_iter(H1, E1, K1), sprawdz_pk_iter(I1, F1, L1))/[A]/[]/[]/ ([G1, H1, I1]/[])/ ([J1, K1, L1]/[]), modpart(fpm, A, F, E1, F1, po)/ (obldest_iter(G1, F, J1), oblink_iter(H1, E1, K1), sprawdz_pk_iter(I1, F1, L1))/[A]/[]/[]/ ([G1, H1, I1]/[])/ ([J1, K1, L1]/[])]/[M1, A1, N1]/[O1, P1, Q1]),
	register(fpm(Q,
		     R,
		     S,
		     (mod),
		     U,
		     A,
		     O1,
		     P1,
		     Q1,
		     Z1),
		 R1,
		 S1,
		 pm5,
		 
		 [ T1/fps(U1, V1, W1, A, N, O, P, po)
		 | X1
		 ],
		 Y1),
	fpm(R1,
	    S1,
	    Y1,
	    Q,
	    R,
	    S,
	    (mod),
	    U,
	    A,
	    O1,
	    P1,
	    Q1,
	    Z1).

fps(W2, A, Y2, Z2, A3, B3, C3, Z, A1, B1, po) :-
	do_sequence_of(D3,
		       
		       [ 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, T, 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/P, V))/[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),
	wymagania_czyste(_, D1),
	oblzap_iter(K1, F1, M2),
	obldest_iter(L1, G1, N2),
	oblink_iter(M1, H1, O2),
	sprawdz_pk_iter(N1, I1, P2),
	wyjmijl(O1, D1, J2),
	do_sequence_of(P1,
		       [],
		       Q1,
		       X2,
		       [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, I2, 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(K2, D2/E2, L2))/[F2, G2, H2, I2]/[J2]/[Q2]/ ([U1, V1, W1, X1]/[K2])/ ([Y1, Z1, A2, B2]/[L2]), 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]/[])]/[M2, N2, O2, P2]/[S2, T2, U2, V2]),
	wymagania_oznacz_użyte(Q2, R2),
	register(fpt(X,
		     Y,
		     C1,
		     R2,
		     E1,
		     S2,
		     W,
		     T2,
		     U2,
		     V2,
		     F3),
		 W2,
		 X2,
		 pts2,
		 
		 [ Y2/fps(Z2, A3, B3, C3, Z, A1, B1, po)
		 | D3
		 ],
		 E3),
	fpt(W2,
	    X2,
	    E3,
	    X,
	    Y,
	    C1,
	    R2,
	    E1,
	    S2,
	    W,
	    T2,
	    U2,
	    V2,
	    F3).

fps(Y, B, A1, T, U, A, C, Q, R, S, na) :-
	A\= (mod),
	do_sequence_of(B1,
		       [],
		       B,
		       Z,
		       [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]/[V, W, X, 1]),
	register(fps(T,
		     U,
		     (mod),
		     C,
		     V,
		     W,
		     X,
		     D1),
		 Y,
		 Z,
		 psm1,
		 
		 [ A1/fps(T, U, A, C, Q, R, S, na)
		 | B1
		 ],
		 C1),
	fps(Y,
	    Z,
	    C1,
	    T,
	    U,
	    (mod),
	    C,
	    V,
	    W,
	    X,
	    D1).

fps(S1, B, U1, V1, W1, X1, A, N, O, P, po) :-
	do_sequence_of(Y1,
		       
		       [ C,
			 W/fps(Q, R, S, A, T, U, V, na)
		       | A1
		       ],
		       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]/[X, Y, Z]),
	goal(fps(Q,
		 R,
		 S,
		 A,
		 T,
		 U,
		 V,
		 na),
	     C,
	     B1,
	     W),
	S\= (mod),
	obldest_iter(X, T, M1),
	oblink_iter(Y, U, N1),
	sprawdz_pk_iter(Z, V, O1),
	do_sequence_of(A1,
		       [],
		       B1,
		       T1,
		       [fpm(_, _, _, L1, _, A, C1, D1, E1, po)/ (obldest_iter(F1, C1, I1), oblink_iter(G1, D1, J1), sprawdz_pk_iter(H1, E1, K1))/[A]/[]/[]/ ([F1, G1, H1]/[])/ ([I1, J1, K1]/[]), fps(_, _, L1, A, C1, D1, E1, po)/ (obldest_iter(F1, C1, I1), oblink_iter(G1, D1, J1), sprawdz_pk_iter(H1, E1, K1))/[A]/[]/[]/ ([F1, G1, H1]/[])/ ([I1, J1, K1]/[]), modpart(fpt, A, C1, D1, E1, po)/ (obldest_iter(F1, C1, I1), oblink_iter(G1, D1, J1), sprawdz_pk_iter(H1, E1, K1))/[A]/[]/[]/ ([F1, G1, H1]/[])/ ([I1, J1, K1]/[])]/[M1, N1, O1]/[P1, Q1, R1]),
	register(fps(Q,
		     R,
		     (mod),
		     A,
		     P1,
		     Q1,
		     R1,
		     A2),
		 S1,
		 T1,
		 psm4,
		 
		 [ U1/fps(V1, W1, X1, A, N, O, P, po)
		 | Y1
		 ],
		 Z1),
	fps(S1,
	    T1,
	    Z1,
	    Q,
	    R,
	    (mod),
	    A,
	    P1,
	    Q1,
	    R1,
	    A2).

fps(G1, B, I1, J1, C1, A1, A, G, E1, X, po) :-
	do_sequence_of(K1,
		       
		       [ C,
			 R/spójnik(szk, P, ni, na),
			 Q,
			 W/fps(T, U, I, A, V, 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]/[Y, G, B1]/[[S, H], Z, [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, U, I, A, V, ni, H, po),
	     Q,
	     H1,
	     W),
	oblpk(F1, [X|Y]),
	obldest_fno_iter(Z, V, D1),
	różne(sp:sz:P, [A1|B1]),
	różne(sp:sz:przec, [A1|B1]),
	(   P\=przec
	;   I\=sp:sz:_
	),
	register(fps(P,
		     C1,
		     sp:sz:P,
		     A,
		     D1,
		     E1,
		     F1,
		     M1),
		 G1,
		 H1,
		 pss3,
		 
		 [ I1/fps(J1, C1, A1, A, G, E1, X, po)
		 | K1
		 ],
		 L1),
	fps(G1,
	    H1,
	    L1,
	    P,
	    C1,
	    sp:sz:P,
	    A,
	    D1,
	    E1,
	    F1,
	    M1).

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,
		    lex,
		    B1,
		    C1,
		    D1,
		    E1,
		    post,
		    F1,
		    neut,
		    ni,
		    V,
		    G1),
		 W,
		 X,
		 wyor3,
		 [Y/dwukropek(po)|Z],
		 A1),
	fw(W,
	   X,
	   A1,
	   or,
	   lex,
	   B1,
	   C1,
	   D1,
	   E1,
	   post,
	   F1,
	   neut,
	   ni,
	   V,
	   G1).

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

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

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

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

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

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, [nom, gen, dat, acc, inst]),
	(   B=nom
	*-> _=_
	;   true
	),
	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(Q, A, S, H, po) :-
	goal(zdanie(D,
		    K,
		    L,
		    M,
		    U,
		    V,
		    N,
		    E,
		    O,
		    I,
		    na),
	     A,
	     B,
	     T),
	optional(W,
		 [],
		 B,
		 R,
		 przec(C, po),
		 {},
		 { C= (p| bp)
		 }),
	D\=bc(_),
	równe(J/E,
	      [wz(F, G)/wz(F, G), int/pz]),
	oblpk(P, [H, I, C]),
	register(fzd(J,
		     nk,
		     K,
		     L,
		     M,
		     N,
		     O,
		     P,
		     Y),
		 Q,
		 R,
		 zd1,
		 
		 [ S/przec(H, po),
		   A,
		   T/zdanie(D, K, L, M, U, V, N, E, O, I, na)
		 | W
		 ],
		 X),
	fzd(Q,
	    R,
	    X,
	    J,
	    nk,
	    K,
	    L,
	    M,
	    N,
	    O,
	    P,
	    Y).

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

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

modpart(W2, B, Y2, fpt, A, Z, A1, B1, po) :-
	do_sequence_of(Z2,
		       
		       [ C,
			 J1/fpt(X, Y, C1, D1, E1, F1, A, G1, H1, I1, na)
		       | P1
		       ],
		       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, U, 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(V, P/Q, W))/[R, S, T, U]/[[]]/[O1]/ ([G, H, I, J]/[V])/ ([K, L, M, N]/[W]), 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(X, Y, 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))/[X, Y]/[]/[]/ ([G, H, I, J]/[])/ ([K, L, M, N]/[])]/[_, Z, A1, B1]/[K1, L1, M1, N1]),
	goal(fpt(X,
		 Y,
		 C1,
		 D1,
		 E1,
		 F1,
		 A,
		 G1,
		 H1,
		 I1,
		 na),
	     C,
	     Q1,
	     J1),
	wymagania_czyste(_, D1),
	oblzap_iter(K1, F1, M2),
	obldest_iter(L1, G1, N2),
	oblink_iter(M1, H1, O2),
	sprawdz_pk_iter(N1, I1, P2),
	wyjmijl(O1, D1, J2),
	do_sequence_of(P1,
		       [],
		       Q1,
		       X2,
		       [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, I2, 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(K2, D2/E2, L2))/[F2, G2, H2, I2]/[J2]/[Q2]/ ([U1, V1, W1, X1]/[K2])/ ([Y1, Z1, A2, B2]/[L2]), modpart(fpt, A, 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]/[]/[]/ ([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]/[])]/[M2, N2, O2, P2]/[S2, T2, U2, V2]),
	wymagania_oznacz_użyte(Q2, R2),
	register(fpt(X,
		     Y,
		     C1,
		     R2,
		     E1,
		     S2,
		     A,
		     T2,
		     U2,
		     V2,
		     B3),
		 W2,
		 X2,
		 ptm3,
		 
		 [ Y2/modpart(fpt, A, Z, A1, B1, po)
		 | Z2
		 ],
		 A3),
	fpt(W2,
	    X2,
	    A3,
	    X,
	    Y,
	    C1,
	    R2,
	    E1,
	    S2,
	    A,
	    T2,
	    U2,
	    V2,
	    B3).

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(S1, B, U1, fpt, A, N, O, P, po) :-
	do_sequence_of(V1,
		       
		       [ C,
			 W/fps(Q, R, S, A, T, U, V, na)
		       | A1
		       ],
		       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]/[X, Y, Z]),
	goal(fps(Q,
		 R,
		 S,
		 A,
		 T,
		 U,
		 V,
		 na),
	     C,
	     B1,
	     W),
	S\= (mod),
	obldest_iter(X, T, M1),
	oblink_iter(Y, U, N1),
	sprawdz_pk_iter(Z, V, O1),
	do_sequence_of(A1,
		       [],
		       B1,
		       T1,
		       [fpm(_, _, _, L1, _, A, C1, D1, E1, po)/ (obldest_iter(F1, C1, I1), oblink_iter(G1, D1, J1), sprawdz_pk_iter(H1, E1, K1))/[A]/[]/[]/ ([F1, G1, H1]/[])/ ([I1, J1, K1]/[]), fps(_, _, L1, A, C1, D1, E1, po)/ (obldest_iter(F1, C1, I1), oblink_iter(G1, D1, J1), sprawdz_pk_iter(H1, E1, K1))/[A]/[]/[]/ ([F1, G1, H1]/[])/ ([I1, J1, K1]/[]), modpart(fpt, A, C1, D1, E1, po)/ (obldest_iter(F1, C1, I1), oblink_iter(G1, D1, J1), sprawdz_pk_iter(H1, E1, K1))/[A]/[]/[]/ ([F1, G1, H1]/[])/ ([I1, J1, K1]/[])]/[M1, N1, O1]/[P1, Q1, R1]),
	register(fps(Q,
		     R,
		     (mod),
		     A,
		     P1,
		     Q1,
		     R1,
		     X1),
		 S1,
		 T1,
		 psm3,
		 
		 [ U1/modpart(fpt, A, N, O, P, po)
		 | V1
		 ],
		 W1),
	fps(S1,
	    T1,
	    W1,
	    Q,
	    R,
	    (mod),
	    A,
	    P1,
	    Q1,
	    R1,
	    X1).

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

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

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(A,
		     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,
	    A,
	    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(A,
		     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,
	    A,
	    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(nic,
		     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,
	    nic,
	    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(nikt,
		     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,
	    nikt,
	    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(to,
		     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,
	    to,
	    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(A,
		     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,
	    A,
	    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, [nom, loc, voc]),
	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(E,
		     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,
	    E,
	    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(licz,
		     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,
	    licz,
	    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, nom),
	rekcja_pusta(D),
	register(fno(licz,
		     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,
	    licz,
	    A,
	    B/C,
	    M,
	    D,
	    nuzg,
	    E,
	    N,
	    O,
	    F,
	    G,
	    H,
	    P).

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

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

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

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

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

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=acc
	;   równe(B, [gen, acc])
	),
	goal(fpt(postp,
		 O/P,
		 Q,
		 wym([], R, S),
		 E,
		 F,
		 G,
		 H,
		 I,
		 D,
		 po),
	     C,
	     L,
	     N),
	oblpk(J, [ (0| p), D]),
	register(fpmpt(A,
		       postp,
		       E,
		       F,
		       G,
		       H,
		       I,
		       J,
		       U),
		 K,
		 L,
		 pma2,
		 
		 [ M/przyimek(A, B, na),
		   C,
		   N/fpt(postp, O/P, Q, wym([], R, S), E, F, G, H, I, D, po)
		 ],
		 T),
	fpmpt(K,
	      L,
	      T,
	      A,
	      postp,
	      E,
	      F,
	      G,
	      H,
	      I,
	      J,
	      U).

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

przyimek(B, A, D, podczas, gen, na) :-
	goal(terminal(morf(F, gdy, comp)), A, C, E),
	register(spójnik(po, podczas, ni, H),
		 B,
		 C,
		 spoj40,
		 
		 [ D/przyimek(podczas, gen, 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(X2, C, Z2, A, B, Z, A1, B1, C1, po) :-
	do_sequence_of(A3,
		       
		       [ D,
			 K1/fpt(A, B, D1, E1, F1, G1, Y, H1, I1, J1, na)
		       | Q1
		       ],
		       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, V, 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(W, Q/R, X))/[S, T, U, V]/[[]]/[P1]/ ([H, I, J, K]/[W])/ ([L, M, N, O]/[X]), modpart(fpt, Y, 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))/[Y]/[]/[]/ ([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]/[])]/[Z, A1, B1, C1]/[L1, M1, N1, O1]),
	goal(fpt(A,
		 B,
		 D1,
		 E1,
		 F1,
		 G1,
		 Y,
		 H1,
		 I1,
		 J1,
		 na),
	     D,
	     R1,
	     K1),
	wymagania_czyste(_, E1),
	oblzap_iter(L1, G1, N2),
	obldest_iter(M1, H1, O2),
	oblink_iter(N1, I1, P2),
	sprawdz_pk_iter(O1, J1, Q2),
	wyjmijl(P1, E1, K2),
	do_sequence_of(Q1,
		       [],
		       R1,
		       Y2,
		       [fps(_, _, _, _, S1, T1, U1, po)/ (oblzap_iter(V1, D2, Z1), obldest_iter(W1, S1, A2), oblink_iter(X1, T1, B2), sprawdz_pk_iter(Y1, U1, C2))/[]/[]/[]/ ([V1, W1, X1, Y1]/[])/ ([Z1, A2, B2, C2]/[]), fpm(_, _, _, _, D2, _, S1, T1, U1, po)/ (oblzap_iter(V1, D2, Z1), obldest_iter(W1, S1, A2), oblink_iter(X1, T1, B2), sprawdz_pk_iter(Y1, U1, C2))/[]/[]/[]/ ([V1, W1, X1, Y1]/[])/ ([Z1, A2, B2, C2]/[]), fw(E2, F2, G2, H2, I2, J2, post, tak, S1, T1, U1, po)/ (oblzap_iter(V1, D2, Z1), obldest_iter(W1, S1, A2), oblink_iter(X1, T1, B2), sprawdz_pk_iter(Y1, U1, C2), oblwym_iter(L2, E2/F2, M2))/[G2, H2, I2, J2]/[K2]/[R2]/ ([V1, W1, X1, Y1]/[L2])/ ([Z1, A2, B2, C2]/[M2]), modpart(fpt, Y, S1, T1, U1, po)/ (oblzap_iter(V1, D2, Z1), obldest_iter(W1, S1, A2), oblink_iter(X1, T1, B2), sprawdz_pk_iter(Y1, U1, C2))/[Y]/[]/[]/ ([V1, W1, X1, Y1]/[])/ ([Z1, A2, B2, C2]/[]), modjaki(A, B, D2, S1, T1, U1, po)/ (oblzap_iter(V1, D2, Z1), obldest_iter(W1, S1, A2), oblink_iter(X1, T1, B2), sprawdz_pk_iter(Y1, U1, C2))/[A, B]/[]/[]/ ([V1, W1, X1, Y1]/[])/ ([Z1, A2, B2, C2]/[])]/[N2, O2, P2, Q2]/[T2, U2, V2, W2]),
	wymagania_oznacz_użyte(R2, S2),
	register(fpt(A,
		     B,
		     D1,
		     S2,
		     F1,
		     T2,
		     Y,
		     U2,
		     V2,
		     W2,
		     C3),
		 X2,
		 Y2,
		 ptm5,
		 
		 [ Z2/modjaki(A, B, Z, A1, B1, C1, po)
		 | A3
		 ],
		 B3),
	fpt(X2,
	    Y2,
	    B3,
	    A,
	    B,
	    D1,
	    S2,
	    F1,
	    T2,
	    Y,
	    U2,
	    V2,
	    W2,
	    C3).

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

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

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/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.

