:-style_check(-singleton).
grammar_no(1452860734).
:- style_check(-singleton).

:- op(100, fy, @).

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

zr(E, A, G, H, I, J, K, L, M, N, O, z(D, B), P) :-
	goal(znakkonca(C), A, F, Q),
	zrowne(B, [C], D),
	register(wypowiedzenie,
		 E,
		 F,
		 w1,
		 
		 [ G/zr(H, I, J, K, L, M, N, O, z(D, B), P),
		   A,
		   Q/znakkonca(C)
		 ],
		 R),
	wypowiedzenie(E, F, R).

zr(L, M, N, C, D, E, F, G, H, I, J, z(B, A), O) :-
	zrowne(A, [npt], B),
	K=[p, px, pxx],
	register(ze(C,
		    D,
		    E,
		    F,
		    G,
		    H,
		    Q,
		    I,
		    J,
		    z(R, K),
		    S,
		    @ @ @ @0),
		 L,
		 M,
		 e15,
		 
		 [ N/zr(C, D, E, F, G, H, I, J, z(B, A), O)
		 ],
		 P),
	ze(L,
	   M,
	   P,
	   C,
	   D,
	   E,
	   F,
	   G,
	   H,
	   Q,
	   I,
	   J,
	   z(R, K),
	   S,
	   @ @ @ @0).

zr(L, M, N, A, B, C, D, E, F, G, H, z(I, J), @K) :-
	register(ze(A,
		    B,
		    C,
		    D,
		    E,
		    F,
		    P,
		    G,
		    H,
		    z(I, J),
		    Q,
		    K),
		 L,
		 M,
		 e19,
		 
		 [ N/zr(A, B, C, D, E, F, G, H, z(I, J), @K)
		 ],
		 O),
	ze(L,
	   M,
	   O,
	   A,
	   B,
	   C,
	   D,
	   E,
	   F,
	   P,
	   G,
	   H,
	   z(I, J),
	   Q,
	   K).

zr(I, J, K, L, D, E, F, M, N, G, H, z(B, A), O) :-
	zrowne(A, [co, jaki, kto, który, pz], C),
	rowne(B, C),
	register(fzde(B, D, E, F, G, H),
		 I,
		 J,
		 zd44,
		 
		 [ K/zr(L, D, E, F, M, N, G, H, z(B, A), O)
		 ],
		 P),
	fzde(I,
	     J,
	     P,
	     B,
	     D,
	     E,
	     F,
	     G,
	     H).

zr(H, I, J, K, C, D, E, L, M, F, G, z(B, A), N) :-
	zrowne(A, [pz], B),
	register(fzde(mie1, C, D, E, F, G),
		 H,
		 I,
		 zd46,
		 
		 [ J/zr(K, C, D, E, L, M, F, G, z(B, A), N)
		 ],
		 O),
	fzde(H,
	     I,
	     O,
	     mie1,
	     C,
	     D,
	     E,
	     F,
	     G).

zsz(K, L, M, A, B, C, D, E, F, G, H, I, @J) :-
	register(zr(A,
		    B,
		    C,
		    D,
		    E,
		    F,
		    G,
		    H,
		    I,
		    J),
		 K,
		 L,
		 r1,
		 
		 [ M/zsz(A, B, C, D, E, F, G, H, I, @J)
		 ],
		 N),
	zr(K,
	   L,
	   N,
	   A,
	   B,
	   C,
	   D,
	   E,
	   F,
	   G,
	   H,
	   I,
	   J).

zsz(Q, B, S, G, H, I, J, K, L, M, N, z(npp(O), A), T) :-
	oblnp(A, P),
	goal(przec, B, C, U),
	goal(spoj(rc, W, ni), C, D, V),
	goal(zsz(Y,
		 Z,
		 A1,
		 B1,
		 C1,
		 D1,
		 E1,
		 ni,
		 z(F, E),
		 F1),
	     D,
	     R,
	     X),
	zrowne(E, [p], F),
	register(zr(G,
		    H,
		    I,
		    J,
		    K,
		    L,
		    M,
		    N,
		    z(O, P),
		    @ @ @ @0),
		 Q,
		 R,
		 r2,
		 
		 [ S/zsz(G, H, I, J, K, L, M, N, z(npp(O), A), T),
		   B,
		   U/przec,
		   C,
		   V/spoj(rc, W, ni),
		   D,
		   X/zsz(Y, Z, A1, B1, C1, D1, E1, ni, z(F, E), F1)
		 ],
		 G1),
	zr(Q,
	   R,
	   G1,
	   G,
	   H,
	   I,
	   J,
	   K,
	   L,
	   M,
	   N,
	   z(O, P),
	   @ @ @ @0).

zsz(Q, B, S, G, H, I, J, K, L, M, N, z(npp(O), A), T) :-
	oblnp(A, P),
	goal(przec, B, C, U),
	goal(zsz(W,
		 X,
		 Y,
		 Z,
		 A1,
		 B1,
		 C1,
		 F,
		 z(E, D),
		 D1),
	     C,
	     R,
	     V),
	zrowne(D, [p], E),
	rowne(F, [natomiast, zaś]),
	register(zr(G,
		    H,
		    I,
		    J,
		    K,
		    L,
		    M,
		    N,
		    z(O, P),
		    @ @ @ @0),
		 Q,
		 R,
		 r3,
		 
		 [ S/zsz(G, H, I, J, K, L, M, N, z(npp(O), A), T),
		   B,
		   U/przec,
		   C,
		   V/zsz(W, X, Y, Z, A1, B1, C1, F, z(E, D), D1)
		 ],
		 E1),
	zr(Q,
	   R,
	   E1,
	   G,
	   H,
	   I,
	   J,
	   K,
	   L,
	   M,
	   N,
	   z(O, P),
	   @ @ @ @0).

zsz(T, B, V, K, L, M, N, O, P, I, R, z(D, A), W) :-
	zrowne(A,
	       
	       [ aż1,
		 bo,
		 bowiem,
		 chociaż,
		 czy,
		 jak,
		 jeśli,
		 np,
		 npt,
		 podczas,
		 ponieważ,
		 że
	       ],
	       G),
	goal(przec, B, C, X),
	goal(spoj(rc, H, ni), C, E, Y),
	goal(zsz(A1,
		 B1,
		 C1,
		 D1,
		 E1,
		 F1,
		 J,
		 ni,
		 z(D, F),
		 G1),
	     E,
	     U,
	     Z),
	zrowne(F, G, S),
	oblneg(H, Q, I, J),
	register(zr(K,
		    L,
		    M,
		    N,
		    O,
		    P,
		    Q,
		    R,
		    z(D, S),
		    @ @ @ @0),
		 T,
		 U,
		 r5,
		 
		 [ V/zsz(K, L, M, N, O, P, I, R, z(D, A), W),
		   B,
		   X/przec,
		   C,
		   Y/spoj(rc, H, ni),
		   E,
		   Z/zsz(A1, B1, C1, D1, E1, F1, J, ni, z(D, F), G1)
		 ],
		 H1),
	zr(T,
	   U,
	   H1,
	   K,
	   L,
	   M,
	   N,
	   O,
	   P,
	   Q,
	   R,
	   z(D, S),
	   @ @ @ @0).

zsz(S, B, U, J, K, L, M, N, O, H, Q, z(C, A), V) :-
	zrowne(A,
	       
	       [ aż1,
		 bo,
		 bowiem,
		 chociaż,
		 czy,
		 jak,
		 jeśli,
		 np,
		 npt,
		 podczas,
		 ponieważ,
		 że
	       ],
	       F),
	goal(przec, B, D, W),
	goal(zsz(Y,
		 Z,
		 A1,
		 B1,
		 C1,
		 D1,
		 I,
		 G,
		 z(C, E),
		 E1),
	     D,
	     T,
	     X),
	zrowne(E, F, R),
	rowne(G, [natomiast, zaś]),
	oblneg(_, P, H, I),
	register(zr(J,
		    K,
		    L,
		    M,
		    N,
		    O,
		    P,
		    Q,
		    z(C, R),
		    @ @ @ @0),
		 S,
		 T,
		 r6,
		 
		 [ U/zsz(J, K, L, M, N, O, H, Q, z(C, A), V),
		   B,
		   W/przec,
		   D,
		   X/zsz(Y, Z, A1, B1, C1, D1, I, G, z(C, E), E1)
		 ],
		 F1),
	zr(S,
	   T,
	   F1,
	   J,
	   K,
	   L,
	   M,
	   N,
	   O,
	   P,
	   Q,
	   z(C, R),
	   @ @ @ @0).

zsz(T, B, V, D, L, M, N, O, P, J, R, z(E, A), W) :-
	zrowne(A, [byxx, choćby, czyżby, gdyby, jakby, jakoby, żeby], H),
	goal(przec, B, C, X),
	goal(spoj(rc, I, ni), C, F, Y),
	goal(zsz(D,
		 A1,
		 B1,
		 C1,
		 D1,
		 3,
		 K,
		 ni,
		 z(E, G),
		 E1),
	     F,
	     U,
	     Z),
	zrowne(G, H, S),
	oblneg(I, Q, J, K),
	register(zr(D,
		    L,
		    M,
		    N,
		    O,
		    P,
		    Q,
		    R,
		    z(E, S),
		    @ @ @ @0),
		 T,
		 U,
		 r8,
		 
		 [ V/zsz(D, L, M, N, O, P, J, R, z(E, A), W),
		   B,
		   X/przec,
		   C,
		   Y/spoj(rc, I, ni),
		   F,
		   Z/zsz(D, A1, B1, C1, D1, 3, K, ni, z(E, G), E1)
		 ],
		 F1),
	zr(T,
	   U,
	   F1,
	   D,
	   L,
	   M,
	   N,
	   O,
	   P,
	   Q,
	   R,
	   z(E, S),
	   @ @ @ @0).

zsz(S, B, U, C, K, L, M, N, O, I, Q, z(D, A), V) :-
	zrowne(A, [byxx, choćby, czyżby, gdyby, jakby, jakoby, żeby], G),
	goal(przec, B, E, W),
	goal(zsz(C,
		 Y,
		 Z,
		 A1,
		 B1,
		 3,
		 J,
		 H,
		 z(D, F),
		 C1),
	     E,
	     T,
	     X),
	zrowne(F, G, R),
	rowne(H, [natomiast, zaś]),
	oblneg(_, P, I, J),
	register(zr(C,
		    K,
		    L,
		    M,
		    N,
		    O,
		    P,
		    Q,
		    z(D, R),
		    @ @ @ @0),
		 S,
		 T,
		 r9,
		 
		 [ U/zsz(C, K, L, M, N, O, I, Q, z(D, A), V),
		   B,
		   W/przec,
		   E,
		   X/zsz(C, Y, Z, A1, B1, 3, J, H, z(D, F), C1)
		 ],
		 D1),
	zr(S,
	   T,
	   D1,
	   C,
	   K,
	   L,
	   M,
	   N,
	   O,
	   P,
	   Q,
	   z(D, R),
	   @ @ @ @0).

zsz(T, B, V, M, N, D, E, O, P, K, R, z(F, A), W) :-
	zrowne(A,
	       [aż1xx, boxx, dopóki, gdyxx, npxx, npxxt, zanim, zanimxx],
	       I),
	goal(przec, B, C, X),
	goal(spoj(rc, J, ni), C, G, Y),
	goal(zsz(A1,
		 B1,
		 D,
		 E,
		 C1,
		 D1,
		 L,
		 ni,
		 z(F, H),
		 E1),
	     G,
	     U,
	     Z),
	zrowne(H, I, S),
	oblneg(J, Q, K, L),
	register(zr(M,
		    N,
		    D,
		    E,
		    O,
		    P,
		    Q,
		    R,
		    z(F, S),
		    @ @ @ @0),
		 T,
		 U,
		 r11,
		 
		 [ V/zsz(M, N, D, E, O, P, K, R, z(F, A), W),
		   B,
		   X/przec,
		   C,
		   Y/spoj(rc, J, ni),
		   G,
		   Z/zsz(A1, B1, D, E, C1, D1, L, ni, z(F, H), E1)
		 ],
		 F1),
	zr(T,
	   U,
	   F1,
	   M,
	   N,
	   D,
	   E,
	   O,
	   P,
	   Q,
	   R,
	   z(F, S),
	   @ @ @ @0).

zsz(S, B, U, L, M, C, D, N, O, J, Q, z(E, A), V) :-
	zrowne(A,
	       [aż1xx, boxx, dopóki, gdyxx, npxx, npxxt, zanim, zanimxx],
	       H),
	goal(przec, B, F, W),
	goal(zsz(Y,
		 Z,
		 C,
		 D,
		 A1,
		 B1,
		 K,
		 I,
		 z(E, G),
		 C1),
	     F,
	     T,
	     X),
	zrowne(G, H, R),
	rowne(I, [natomiast, zaś]),
	oblneg(_, P, J, K),
	register(zr(L,
		    M,
		    C,
		    D,
		    N,
		    O,
		    P,
		    Q,
		    z(E, R),
		    @ @ @ @0),
		 S,
		 T,
		 r12,
		 
		 [ U/zsz(L, M, C, D, N, O, J, Q, z(E, A), V),
		   B,
		   W/przec,
		   F,
		   X/zsz(Y, Z, C, D, A1, B1, K, I, z(E, G), C1)
		 ],
		 D1),
	zr(S,
	   T,
	   D1,
	   L,
	   M,
	   C,
	   D,
	   N,
	   O,
	   P,
	   Q,
	   z(E, R),
	   @ @ @ @0).

zsz(T, B, V, M, N, D, E, O, P, K, R, z(F, A), W) :-
	zrowne(A, [aż2, box, gdyx, npx, npxt], I),
	goal(przec, B, C, X),
	goal(spoj(rc, J, ni), C, G, Y),
	goal(zsz(A1,
		 B1,
		 D,
		 E,
		 C1,
		 D1,
		 L,
		 ni,
		 z(F, H),
		 E1),
	     G,
	     U,
	     Z),
	zrowne(H, I, S),
	oblneg(J, Q, K, L),
	register(zr(M,
		    N,
		    D,
		    E,
		    O,
		    P,
		    Q,
		    R,
		    z(F, S),
		    @ @ @ @0),
		 T,
		 U,
		 r14,
		 
		 [ V/zsz(M, N, D, E, O, P, K, R, z(F, A), W),
		   B,
		   X/przec,
		   C,
		   Y/spoj(rc, J, ni),
		   G,
		   Z/zsz(A1, B1, D, E, C1, D1, L, ni, z(F, H), E1)
		 ],
		 F1),
	zr(T,
	   U,
	   F1,
	   M,
	   N,
	   D,
	   E,
	   O,
	   P,
	   Q,
	   R,
	   z(F, S),
	   @ @ @ @0).

zsz(S, B, U, L, M, C, D, N, O, J, Q, z(E, A), V) :-
	zrowne(A, [aż2, box, gdyx, npx, npxt], H),
	goal(przec, B, F, W),
	goal(zsz(Y,
		 Z,
		 C,
		 D,
		 A1,
		 B1,
		 K,
		 I,
		 z(E, G),
		 C1),
	     F,
	     T,
	     X),
	zrowne(G, H, R),
	rowne(I, [natomiast, zaś]),
	oblneg(_, P, J, K),
	register(zr(L,
		    M,
		    C,
		    D,
		    N,
		    O,
		    P,
		    Q,
		    z(E, R),
		    @ @ @ @0),
		 S,
		 T,
		 r15,
		 
		 [ U/zsz(L, M, C, D, N, O, J, Q, z(E, A), V),
		   B,
		   W/przec,
		   F,
		   X/zsz(Y, Z, C, D, A1, B1, K, I, z(E, G), C1)
		 ],
		 D1),
	zr(S,
	   T,
	   D1,
	   L,
	   M,
	   C,
	   D,
	   N,
	   O,
	   P,
	   Q,
	   z(E, R),
	   @ @ @ @0).

spoj(U, A, W, rl, D, S) :-
	goal(zsz(L,
		 M,
		 N,
		 O,
		 P,
		 Q,
		 J,
		 ni,
		 z(F, B),
		 Y),
	     A,
	     C,
	     X),
	zrowne(B,
	       
	       [ aż1,
		 bo,
		 bowiem,
		 chociaż,
		 czy,
		 jak,
		 jeśli,
		 np,
		 npt,
		 podczas,
		 ponieważ,
		 że
	       ],
	       I),
	goal(przec, C, E, Z),
	goal(spoj(rp, D, ni), E, G, A1),
	goal(zsz(C1,
		 D1,
		 E1,
		 F1,
		 G1,
		 H1,
		 K,
		 ni,
		 z(F, H),
		 I1),
	     G,
	     V,
	     B1),
	zrowne(H, I, T),
	oblneg(D, R, J, K),
	register(zr(L,
		    M,
		    N,
		    O,
		    P,
		    Q,
		    R,
		    S,
		    z(F, T),
		    @ @ @ @0),
		 U,
		 V,
		 r4,
		 
		 [ W/spoj(rl, D, S),
		   A,
		   X/zsz(L, M, N, O, P, Q, J, ni, z(F, B), Y),
		   C,
		   Z/przec,
		   E,
		   A1/spoj(rp, D, ni),
		   G,
		   B1/zsz(C1, D1, E1, F1, G1, H1, K, ni, z(F, H), I1)
		 ],
		 J1),
	zr(U,
	   V,
	   J1,
	   L,
	   M,
	   N,
	   O,
	   P,
	   Q,
	   R,
	   S,
	   z(F, T),
	   @ @ @ @0).

spoj(T, A, V, rl, D, R) :-
	goal(zsz(F,
		 M,
		 N,
		 O,
		 P,
		 3,
		 K,
		 ni,
		 z(G, B),
		 X),
	     A,
	     C,
	     W),
	zrowne(B, [byxx, choćby, czyżby, gdyby, jakby, jakoby, żeby], J),
	goal(przec, C, E, Y),
	goal(spoj(rp, D, ni), E, H, Z),
	goal(zsz(F,
		 B1,
		 C1,
		 D1,
		 E1,
		 3,
		 L,
		 ni,
		 z(G, I),
		 F1),
	     H,
	     U,
	     A1),
	zrowne(I, J, S),
	oblneg(D, Q, K, L),
	register(zr(F,
		    M,
		    N,
		    O,
		    P,
		    3,
		    Q,
		    R,
		    z(G, S),
		    @ @ @ @0),
		 T,
		 U,
		 r7,
		 
		 [ V/spoj(rl, D, R),
		   A,
		   W/zsz(F, M, N, O, P, 3, K, ni, z(G, B), X),
		   C,
		   Y/przec,
		   E,
		   Z/spoj(rp, D, ni),
		   H,
		   A1/zsz(F, B1, C1, D1, E1, 3, L, ni, z(G, I), F1)
		 ],
		 G1),
	zr(T,
	   U,
	   G1,
	   F,
	   M,
	   N,
	   O,
	   P,
	   3,
	   Q,
	   R,
	   z(G, S),
	   @ @ @ @0).

spoj(U, A, W, rl, D, S) :-
	goal(zsz(N,
		 O,
		 F,
		 G,
		 P,
		 Q,
		 L,
		 ni,
		 z(H, B),
		 Y),
	     A,
	     C,
	     X),
	zrowne(B,
	       [aż1xx, boxx, dopóki, gdyxx, npxx, npxxt, zanim, zanimxx],
	       K),
	goal(przec, C, E, Z),
	goal(spoj(rp, D, ni), E, I, A1),
	goal(zsz(C1,
		 D1,
		 F,
		 G,
		 E1,
		 F1,
		 M,
		 ni,
		 z(H, J),
		 G1),
	     I,
	     V,
	     B1),
	zrowne(J, K, T),
	oblneg(D, R, L, M),
	register(zr(N,
		    O,
		    F,
		    G,
		    P,
		    Q,
		    R,
		    S,
		    z(H, T),
		    @ @ @ @0),
		 U,
		 V,
		 r10,
		 
		 [ W/spoj(rl, D, S),
		   A,
		   X/zsz(N, O, F, G, P, Q, L, ni, z(H, B), Y),
		   C,
		   Z/przec,
		   E,
		   A1/spoj(rp, D, ni),
		   I,
		   B1/zsz(C1, D1, F, G, E1, F1, M, ni, z(H, J), G1)
		 ],
		 H1),
	zr(U,
	   V,
	   H1,
	   N,
	   O,
	   F,
	   G,
	   P,
	   Q,
	   R,
	   S,
	   z(H, T),
	   @ @ @ @0).

spoj(U, A, W, rl, D, S) :-
	goal(zsz(N,
		 O,
		 F,
		 G,
		 P,
		 Q,
		 L,
		 ni,
		 z(H, B),
		 Y),
	     A,
	     C,
	     X),
	zrowne(B, [aż2, box, gdyx, npx, npxt], K),
	goal(przec, C, E, Z),
	goal(spoj(rp, D, ni), E, I, A1),
	goal(zsz(C1,
		 D1,
		 F,
		 G,
		 E1,
		 F1,
		 M,
		 ni,
		 z(H, J),
		 G1),
	     I,
	     V,
	     B1),
	zrowne(J, K, T),
	oblneg(D, R, L, M),
	register(zr(N,
		    O,
		    F,
		    G,
		    P,
		    Q,
		    R,
		    S,
		    z(H, T),
		    @ @ @ @0),
		 U,
		 V,
		 r13,
		 
		 [ W/spoj(rl, D, S),
		   A,
		   X/zsz(N, O, F, G, P, Q, L, ni, z(H, B), Y),
		   C,
		   Z/przec,
		   E,
		   A1/spoj(rp, D, ni),
		   I,
		   B1/zsz(C1, D1, F, G, E1, F1, M, ni, z(H, J), G1)
		 ],
		 H1),
	zr(U,
	   V,
	   H1,
	   N,
	   O,
	   F,
	   G,
	   P,
	   Q,
	   R,
	   S,
	   z(H, T),
	   @ @ @ @0).

spoj(U, B, W, sz, A, S) :-
	rozne(A, przec),
	goal(zp(L,
		M,
		N,
		O,
		P,
		Q,
		J,
		ni,
		z(F, C),
		Y),
	     B,
	     D,
	     X),
	zrowne(C,
	       
	       [ aż1,
		 bo,
		 bowiem,
		 chociaż,
		 czy,
		 jak,
		 jeśli,
		 np,
		 npt,
		 podczas,
		 ponieważ,
		 pz,
		 że
	       ],
	       I),
	goal(przec, D, E, Z),
	goal(spoj(sz, A, ni), E, G, A1),
	goal(zp(C1,
		D1,
		E1,
		F1,
		G1,
		H1,
		K,
		ni,
		z(F, H),
		I1),
	     G,
	     V,
	     B1),
	zrowne(H, I, T),
	oblneg(A, R, J, K),
	register(zj(L,
		    M,
		    N,
		    O,
		    P,
		    Q,
		    R,
		    S,
		    z(F, T),
		    A,
		    @ @ @ @0),
		 U,
		 V,
		 j4,
		 
		 [ W/spoj(sz, A, S),
		   B,
		   X/zp(L, M, N, O, P, Q, J, ni, z(F, C), Y),
		   D,
		   Z/przec,
		   E,
		   A1/spoj(sz, A, ni),
		   G,
		   B1/zp(C1, D1, E1, F1, G1, H1, K, ni, z(F, H), I1)
		 ],
		 J1),
	zj(U,
	   V,
	   J1,
	   L,
	   M,
	   N,
	   O,
	   P,
	   Q,
	   R,
	   S,
	   z(F, T),
	   A,
	   @ @ @ @0).

spoj(T, B, V, sz, A, R) :-
	rozne(A, przec),
	goal(zp(K,
		L,
		M,
		N,
		O,
		P,
		I,
		ni,
		z(E, C),
		X),
	     B,
	     D,
	     W),
	zrowne(C,
	       
	       [ aż1,
		 bo,
		 bowiem,
		 chociaż,
		 czy,
		 jak,
		 jeśli,
		 np,
		 npt,
		 podczas,
		 ponieważ,
		 pz,
		 że
	       ],
	       H),
	goal(przec, D, F, Y),
	goal(zj(A1,
		B1,
		C1,
		D1,
		E1,
		F1,
		J,
		ni,
		z(E, G),
		A,
		G1),
	     F,
	     U,
	     Z),
	zrowne(G, H, S),
	oblneg(A, Q, I, J),
	register(zj(K,
		    L,
		    M,
		    N,
		    O,
		    P,
		    Q,
		    R,
		    z(E, S),
		    A,
		    @ @ @ @0),
		 T,
		 U,
		 j5,
		 
		 [ V/spoj(sz, A, R),
		   B,
		   W/zp(K, L, M, N, O, P, I, ni, z(E, C), X),
		   D,
		   Y/przec,
		   F,
		   Z/zj(A1, B1, C1, D1, E1, F1, J, ni, z(E, G), A, G1)
		 ],
		 H1),
	zj(T,
	   U,
	   H1,
	   K,
	   L,
	   M,
	   N,
	   O,
	   P,
	   Q,
	   R,
	   z(E, S),
	   A,
	   @ @ @ @0).

spoj(T, B, V, sz, A, R) :-
	rozne(A, przec),
	goal(zp(F,
		M,
		N,
		O,
		P,
		3,
		K,
		ni,
		z(G, C),
		X),
	     B,
	     D,
	     W),
	zrowne(C, [byxx, choćby, czyżby, gdyby, jakby, jakoby, żeby], J),
	goal(przec, D, E, Y),
	goal(spoj(sz, A, ni), E, H, Z),
	goal(zp(F,
		B1,
		C1,
		D1,
		E1,
		3,
		L,
		ni,
		z(G, I),
		F1),
	     H,
	     U,
	     A1),
	zrowne(I, J, S),
	oblneg(A, Q, K, L),
	register(zj(F,
		    M,
		    N,
		    O,
		    P,
		    3,
		    Q,
		    R,
		    z(G, S),
		    A,
		    @ @ @ @0),
		 T,
		 U,
		 j8,
		 
		 [ V/spoj(sz, A, R),
		   B,
		   W/zp(F, M, N, O, P, 3, K, ni, z(G, C), X),
		   D,
		   Y/przec,
		   E,
		   Z/spoj(sz, A, ni),
		   H,
		   A1/zp(F, B1, C1, D1, E1, 3, L, ni, z(G, I), F1)
		 ],
		 G1),
	zj(T,
	   U,
	   G1,
	   F,
	   M,
	   N,
	   O,
	   P,
	   3,
	   Q,
	   R,
	   z(G, S),
	   A,
	   @ @ @ @0).

spoj(T, B, V, sz, A, R) :-
	rozne(A, przec),
	goal(zp(F,
		M,
		N,
		O,
		P,
		3,
		K,
		ni,
		z(G, C),
		X),
	     B,
	     D,
	     W),
	zrowne(C, [byxx, choćby, czyżby, gdyby, jakby, jakoby, żeby], J),
	goal(przec, D, E, Y),
	goal(spoj(sz, A, ni), E, H, Z),
	goal(zj(F,
		B1,
		C1,
		D1,
		E1,
		3,
		L,
		ni,
		z(G, I),
		A,
		F1),
	     H,
	     U,
	     A1),
	zrowne(I, J, S),
	oblneg(A, Q, K, L),
	register(zj(F,
		    M,
		    N,
		    O,
		    P,
		    3,
		    Q,
		    R,
		    z(G, S),
		    A,
		    @ @ @ @0),
		 T,
		 U,
		 j9,
		 
		 [ V/spoj(sz, A, R),
		   B,
		   W/zp(F, M, N, O, P, 3, K, ni, z(G, C), X),
		   D,
		   Y/przec,
		   E,
		   Z/spoj(sz, A, ni),
		   H,
		   A1/zj(F, B1, C1, D1, E1, 3, L, ni, z(G, I), A, F1)
		 ],
		 G1),
	zj(T,
	   U,
	   G1,
	   F,
	   M,
	   N,
	   O,
	   P,
	   3,
	   Q,
	   R,
	   z(G, S),
	   A,
	   @ @ @ @0).

spoj(U, B, W, sz, A, S) :-
	rozne(A, przec),
	goal(zp(N,
		O,
		F,
		G,
		P,
		Q,
		L,
		ni,
		z(H, C),
		Y),
	     B,
	     D,
	     X),
	zrowne(C,
	       [aż1xx, boxx, dopóki, gdyxx, npxx, npxxt, zanim, zanimxx],
	       K),
	goal(przec, D, E, Z),
	goal(spoj(sz, A, ni), E, I, A1),
	goal(zp(C1,
		D1,
		F,
		G,
		E1,
		F1,
		M,
		ni,
		z(H, J),
		G1),
	     I,
	     V,
	     B1),
	zrowne(J, K, T),
	oblneg(A, R, L, M),
	register(zj(N,
		    O,
		    F,
		    G,
		    P,
		    Q,
		    R,
		    S,
		    z(H, T),
		    A,
		    @ @ @ @0),
		 U,
		 V,
		 j12,
		 
		 [ W/spoj(sz, A, S),
		   B,
		   X/zp(N, O, F, G, P, Q, L, ni, z(H, C), Y),
		   D,
		   Z/przec,
		   E,
		   A1/spoj(sz, A, ni),
		   I,
		   B1/zp(C1, D1, F, G, E1, F1, M, ni, z(H, J), G1)
		 ],
		 H1),
	zj(U,
	   V,
	   H1,
	   N,
	   O,
	   F,
	   G,
	   P,
	   Q,
	   R,
	   S,
	   z(H, T),
	   A,
	   @ @ @ @0).

spoj(U, B, W, sz, A, S) :-
	rozne(A, przec),
	goal(zp(N,
		O,
		F,
		G,
		P,
		Q,
		L,
		ni,
		z(H, C),
		Y),
	     B,
	     D,
	     X),
	zrowne(C,
	       [aż1xx, boxx, dopóki, gdyxx, npxx, npxxt, zanim, zanimxx],
	       K),
	goal(przec, D, E, Z),
	goal(spoj(sz, A, ni), E, I, A1),
	goal(zj(C1,
		D1,
		F,
		G,
		E1,
		F1,
		M,
		ni,
		z(H, J),
		A,
		G1),
	     I,
	     V,
	     B1),
	zrowne(J, K, T),
	oblneg(A, R, L, M),
	register(zj(N,
		    O,
		    F,
		    G,
		    P,
		    Q,
		    R,
		    S,
		    z(H, T),
		    A,
		    @ @ @ @0),
		 U,
		 V,
		 j13,
		 
		 [ W/spoj(sz, A, S),
		   B,
		   X/zp(N, O, F, G, P, Q, L, ni, z(H, C), Y),
		   D,
		   Z/przec,
		   E,
		   A1/spoj(sz, A, ni),
		   I,
		   B1/zj(C1, D1, F, G, E1, F1, M, ni, z(H, J), A, G1)
		 ],
		 H1),
	zj(U,
	   V,
	   H1,
	   N,
	   O,
	   F,
	   G,
	   P,
	   Q,
	   R,
	   S,
	   z(H, T),
	   A,
	   @ @ @ @0).

spoj(U, B, W, sz, A, S) :-
	rozne(A, przec),
	goal(zp(M,
		N,
		F,
		O,
		P,
		Q,
		K,
		ni,
		z(G, C),
		Y),
	     B,
	     D,
	     X),
	zrowne(C, [aż2, box, gdy, npx, npxt], J),
	goal(przec, D, E, Z),
	goal(spoj(sz, A, ni), E, H, A1),
	goal(zp(C1,
		D1,
		F,
		E1,
		F1,
		G1,
		L,
		ni,
		z(G, I),
		H1),
	     H,
	     V,
	     B1),
	zrowne(I, J, T),
	oblneg(A, R, K, L),
	register(zj(M,
		    N,
		    F,
		    O,
		    P,
		    Q,
		    R,
		    S,
		    z(G, T),
		    A,
		    @ @ @ @0),
		 U,
		 V,
		 j16,
		 
		 [ W/spoj(sz, A, S),
		   B,
		   X/zp(M, N, F, O, P, Q, K, ni, z(G, C), Y),
		   D,
		   Z/przec,
		   E,
		   A1/spoj(sz, A, ni),
		   H,
		   B1/zp(C1, D1, F, E1, F1, G1, L, ni, z(G, I), H1)
		 ],
		 I1),
	zj(U,
	   V,
	   I1,
	   M,
	   N,
	   F,
	   O,
	   P,
	   Q,
	   R,
	   S,
	   z(G, T),
	   A,
	   @ @ @ @0).

spoj(U, B, W, sz, A, S) :-
	rozne(A, przec),
	goal(zp(M,
		N,
		F,
		O,
		P,
		Q,
		K,
		ni,
		z(G, C),
		Y),
	     B,
	     D,
	     X),
	zrowne(C, [aż2, box, gdy, npx, npxt], J),
	goal(przec, D, E, Z),
	goal(spoj(sz, A, ni), E, H, A1),
	goal(zj(C1,
		D1,
		F,
		E1,
		F1,
		G1,
		L,
		ni,
		z(G, I),
		A,
		H1),
	     H,
	     V,
	     B1),
	zrowne(I, J, T),
	oblneg(A, R, K, L),
	register(zj(M,
		    N,
		    F,
		    O,
		    P,
		    Q,
		    R,
		    S,
		    z(G, T),
		    A,
		    @ @ @ @0),
		 U,
		 V,
		 j17,
		 
		 [ W/spoj(sz, A, S),
		   B,
		   X/zp(M, N, F, O, P, Q, K, ni, z(G, C), Y),
		   D,
		   Z/przec,
		   E,
		   A1/spoj(sz, A, ni),
		   H,
		   B1/zj(C1, D1, F, E1, F1, G1, L, ni, z(G, I), A, H1)
		 ],
		 I1),
	zj(U,
	   V,
	   I1,
	   M,
	   N,
	   F,
	   O,
	   P,
	   Q,
	   R,
	   S,
	   z(G, T),
	   A,
	   @ @ @ @0).

spoj(Q, B, S, pl, A, N) :-
	goal(ze(H,
		I,
		E,
		J,
		K,
		L,
		U,
		M,
		ni,
		z(O, C),
		A,
		V),
	     B,
	     F,
	     T),
	oblzal(C, D, A),
	zrozne(D,
	       
	       [ byxx,
		 choćby,
		 co,
		 czyżby,
		 gdyby,
		 jakby,
		 jaki,
		 jakoby,
		 kto,
		 który,
		 pz,
		 żeby
	       ],
	       P),
	goal(fzd(A, nk, X, E, Y, Z, ni, A1),
	     F,
	     G,
	     W),
	goal(przec, G, R, B1),
	register(zp(H,
		    I,
		    E,
		    J,
		    K,
		    L,
		    M,
		    N,
		    z(O, P),
		    @ @ @ @0),
		 Q,
		 R,
		 p7,
		 
		 [ S/spoj(pl, A, N),
		   B,
		   T/ze(H, I, E, J, K, L, U, M, ni, z(O, C), A, V),
		   F,
		   W/fzd(A, nk, X, E, Y, Z, ni, A1),
		   G,
		   B1/przec
		 ],
		 C1),
	zp(Q,
	   R,
	   C1,
	   H,
	   I,
	   E,
	   J,
	   K,
	   L,
	   M,
	   N,
	   z(O, P),
	   @ @ @ @0).

spoj(P, B, R, pl, A, M) :-
	goal(ze(H,
		I,
		E,
		J,
		K,
		3,
		T,
		L,
		ni,
		z(N, C),
		A,
		U),
	     B,
	     F,
	     S),
	oblzal(C, D, A),
	zrowne(D, [byxx, choćby, czyżby, gdyby, jakby, jakoby, żeby], O),
	goal(fzd(A, nk, W, E, X, Y, ni, Z),
	     F,
	     G,
	     V),
	goal(przec, G, Q, A1),
	register(zp(H,
		    I,
		    E,
		    J,
		    K,
		    3,
		    L,
		    M,
		    z(N, O),
		    @ @ @ @0),
		 P,
		 Q,
		 p8,
		 
		 [ R/spoj(pl, A, M),
		   B,
		   S/ze(H, I, E, J, K, 3, T, L, ni, z(N, C), A, U),
		   F,
		   V/fzd(A, nk, W, E, X, Y, ni, Z),
		   G,
		   A1/przec
		 ],
		 B1),
	zp(P,
	   Q,
	   B1,
	   H,
	   I,
	   E,
	   J,
	   K,
	   3,
	   L,
	   M,
	   z(N, O),
	   @ @ @ @0).

spoj(M, A, O, rl, E, L) :-
	goal(fzdsz(B,
		   C,
		   I,
		   J,
		   K,
		   Q,
		   ni,
		   R),
	     A,
	     D,
	     P),
	rowne(B, [aż1, chociaż, czy, jak, jeśli, podczas, ponieważ, pz, że]),
	rozne(C, nk),
	goal(przec, D, F, S),
	goal(spoj(rp, E, ni), F, G, T),
	goal(fzdsz(B,
		   H,
		   V,
		   W,
		   X,
		   Y,
		   ni,
		   Z),
	     G,
	     N,
	     U),
	rowne(H, [C, bp]),
	register(fzd(B,
		     C,
		     I,
		     J,
		     K,
		     B1,
		     L,
		     @ @ @0),
		 M,
		 N,
		 zd2,
		 
		 [ O/spoj(rl, E, L),
		   A,
		   P/fzdsz(B, C, I, J, K, Q, ni, R),
		   D,
		   S/przec,
		   F,
		   T/spoj(rp, E, ni),
		   G,
		   U/fzdsz(B, H, V, W, X, Y, ni, Z)
		 ],
		 A1),
	fzd(M,
	    N,
	    A1,
	    B,
	    C,
	    I,
	    J,
	    K,
	    B1,
	    L,
	    @ @ @0).

spoj(K, A, M, rl, D, J) :-
	goal(fzdsz(B, bp, I, F, G, O, ni, P),
	     A,
	     C,
	     N),
	rowne(B, [dopóki, zanim]),
	goal(przec, C, E, Q),
	goal(spoj(rp, D, ni), E, H, R),
	goal(fzdsz(B, bp, T, F, G, U, ni, V),
	     H,
	     L,
	     S),
	register(fzd(B,
		     bp,
		     I,
		     F,
		     G,
		     X,
		     J,
		     @ @ @0),
		 K,
		 L,
		 zd4,
		 
		 [ M/spoj(rl, D, J),
		   A,
		   N/fzdsz(B, bp, I, F, G, O, ni, P),
		   C,
		   Q/przec,
		   E,
		   R/spoj(rp, D, ni),
		   H,
		   S/fzdsz(B, bp, T, F, G, U, ni, V)
		 ],
		 W),
	fzd(K,
	    L,
	    W,
	    B,
	    bp,
	    I,
	    F,
	    G,
	    X,
	    J,
	    @ @ @0).

spoj(K, A, M, rl, D, J) :-
	goal(fzdsz(B, bp, H, F, I, O, ni, P),
	     A,
	     C,
	     N),
	rowne(B, [aż2, gdy]),
	goal(przec, C, E, Q),
	goal(spoj(rp, D, ni), E, G, R),
	goal(fzdsz(B, bp, T, F, U, V, ni, W),
	     G,
	     L,
	     S),
	register(fzd(B,
		     bp,
		     H,
		     F,
		     I,
		     Y,
		     J,
		     @ @ @0),
		 K,
		 L,
		 zd6,
		 
		 [ M/spoj(rl, D, J),
		   A,
		   N/fzdsz(B, bp, H, F, I, O, ni, P),
		   C,
		   Q/przec,
		   E,
		   R/spoj(rp, D, ni),
		   G,
		   S/fzdsz(B, bp, T, F, U, V, ni, W)
		 ],
		 X),
	fzd(K,
	    L,
	    X,
	    B,
	    bp,
	    H,
	    F,
	    I,
	    Y,
	    J,
	    @ @ @0).

spoj(K, A, M, rl, D, ni) :-
	goal(fzdsz(B,
		   bp,
		   H,
		   I,
		   J,
		   O,
		   F,
		   P),
	     A,
	     C,
	     N),
	rowne(B, [co, jaki, kto, który]),
	goal(przec, C, E, Q),
	goal(spoj(rp, D, ni), E, G, R),
	goal(fzdsz(B,
		   bp,
		   T,
		   U,
		   V,
		   W,
		   F,
		   X),
	     G,
	     L,
	     S),
	register(fzd(B,
		     bp,
		     H,
		     I,
		     J,
		     Z,
		     F,
		     @ @ @0),
		 K,
		 L,
		 zd8,
		 
		 [ M/spoj(rl, D, ni),
		   A,
		   N/fzdsz(B, bp, H, I, J, O, F, P),
		   C,
		   Q/przec,
		   E,
		   R/spoj(rp, D, ni),
		   G,
		   S/fzdsz(B, bp, T, U, V, W, F, X)
		 ],
		 Y),
	fzd(K,
	    L,
	    Y,
	    B,
	    bp,
	    H,
	    I,
	    J,
	    Z,
	    F,
	    @ @ @0).

spoj(M, B, O, sz, A, L) :-
	rozne(A, [ani, przec]),
	goal(fzdkor(C,
		    D,
		    H,
		    I,
		    J,
		    K,
		    ni,
		    Q),
	     B,
	     E,
	     P),
	rowne(C, [aż1, chociaż, czy, jak, jeśli, podczas, ponieważ, pz, że]),
	rozne(D, nk),
	goal(przec, E, F, R),
	goal(fzdkor(C,
		    G,
		    T,
		    U,
		    V,
		    W,
		    ni,
		    X),
	     F,
	     N,
	     S),
	rowne(G, [D, bp]),
	register(fzdj(C,
		      D,
		      H,
		      I,
		      J,
		      K,
		      L,
		      A,
		      @ @ @0),
		 M,
		 N,
		 zd22,
		 
		 [ O/spoj(sz, A, L),
		   B,
		   P/fzdkor(C, D, H, I, J, K, ni, Q),
		   E,
		   R/przec,
		   F,
		   S/fzdkor(C, G, T, U, V, W, ni, X)
		 ],
		 Y),
	fzdj(M,
	     N,
	     Y,
	     C,
	     D,
	     H,
	     I,
	     J,
	     K,
	     L,
	     A,
	     @ @ @0).

spoj(M, B, O, sz, A, L) :-
	rozne(A, [ani, przec]),
	goal(fzdkor(C,
		    D,
		    H,
		    I,
		    J,
		    K,
		    ni,
		    Q),
	     B,
	     E,
	     P),
	rowne(C, [aż1, chociaż, czy, jak, jeśli, podczas, ponieważ, pz, że]),
	rozne(D, nk),
	goal(przec, E, F, R),
	goal(fzdj(C,
		  G,
		  T,
		  U,
		  V,
		  W,
		  ni,
		  A,
		  X),
	     F,
	     N,
	     S),
	rowne(G, [D, bp]),
	register(fzdj(C,
		      D,
		      H,
		      I,
		      J,
		      K,
		      L,
		      A,
		      @ @ @0),
		 M,
		 N,
		 zd23,
		 
		 [ O/spoj(sz, A, L),
		   B,
		   P/fzdkor(C, D, H, I, J, K, ni, Q),
		   E,
		   R/przec,
		   F,
		   S/fzdj(C, G, T, U, V, W, ni, A, X)
		 ],
		 Y),
	fzdj(M,
	     N,
	     Y,
	     C,
	     D,
	     H,
	     I,
	     J,
	     K,
	     L,
	     A,
	     @ @ @0).

spoj(L, B, N, sz, A, K) :-
	rozne(A, [ani, przec]),
	goal(fzdkor(C, bp, I, F, G, J, ni, P),
	     B,
	     D,
	     O),
	rowne(C, [dopóki, zanim]),
	goal(przec, D, E, Q),
	goal(spoj(sz, A, ni), E, H, R),
	goal(fzdkor(C, bp, T, F, G, U, ni, V),
	     H,
	     M,
	     S),
	register(fzdj(C,
		      bp,
		      I,
		      F,
		      G,
		      J,
		      K,
		      A,
		      @ @ @0),
		 L,
		 M,
		 zd26,
		 
		 [ N/spoj(sz, A, K),
		   B,
		   O/fzdkor(C, bp, I, F, G, J, ni, P),
		   D,
		   Q/przec,
		   E,
		   R/spoj(sz, A, ni),
		   H,
		   S/fzdkor(C, bp, T, F, G, U, ni, V)
		 ],
		 W),
	fzdj(L,
	     M,
	     W,
	     C,
	     bp,
	     I,
	     F,
	     G,
	     J,
	     K,
	     A,
	     @ @ @0).

spoj(K, B, M, sz, A, J) :-
	rozne(A, [ani, przec]),
	goal(fzdkor(C, bp, H, E, F, I, ni, O),
	     B,
	     D,
	     N),
	rowne(C, [dopóki, zanim]),
	goal(przec, D, G, P),
	goal(fzdj(C,
		  bp,
		  R,
		  E,
		  F,
		  S,
		  ni,
		  A,
		  T),
	     G,
	     L,
	     Q),
	register(fzdj(C,
		      bp,
		      H,
		      E,
		      F,
		      I,
		      J,
		      A,
		      @ @ @0),
		 K,
		 L,
		 zd27,
		 
		 [ M/spoj(sz, A, J),
		   B,
		   N/fzdkor(C, bp, H, E, F, I, ni, O),
		   D,
		   P/przec,
		   G,
		   Q/fzdj(C, bp, R, E, F, S, ni, A, T)
		 ],
		 U),
	fzdj(K,
	     L,
	     U,
	     C,
	     bp,
	     H,
	     E,
	     F,
	     I,
	     J,
	     A,
	     @ @ @0).

spoj(L, B, N, sz, A, K) :-
	rozne(A, [ani, przec]),
	goal(fzdkor(C, bp, H, F, I, J, ni, P),
	     B,
	     D,
	     O),
	rowne(C, [aż2, gdy]),
	goal(przec, D, E, Q),
	goal(spoj(sz, A, ni), E, G, R),
	goal(fzdkor(C, bp, T, F, U, V, ni, W),
	     G,
	     M,
	     S),
	register(fzdj(C,
		      bp,
		      H,
		      F,
		      I,
		      J,
		      K,
		      A,
		      @ @ @0),
		 L,
		 M,
		 zd30,
		 
		 [ N/spoj(sz, A, K),
		   B,
		   O/fzdkor(C, bp, H, F, I, J, ni, P),
		   D,
		   Q/przec,
		   E,
		   R/spoj(sz, A, ni),
		   G,
		   S/fzdkor(C, bp, T, F, U, V, ni, W)
		 ],
		 X),
	fzdj(L,
	     M,
	     X,
	     C,
	     bp,
	     H,
	     F,
	     I,
	     J,
	     K,
	     A,
	     @ @ @0).

spoj(K, B, M, sz, A, J) :-
	rozne(A, [ani, przec]),
	goal(fzdkor(C, bp, G, E, H, I, ni, O),
	     B,
	     D,
	     N),
	rowne(C, [aż2, gdy]),
	goal(przec, D, F, P),
	goal(fzdj(C,
		  bp,
		  R,
		  E,
		  S,
		  T,
		  ni,
		  A,
		  U),
	     F,
	     L,
	     Q),
	register(fzdj(C,
		      bp,
		      G,
		      E,
		      H,
		      I,
		      J,
		      A,
		      @ @ @0),
		 K,
		 L,
		 zd31,
		 
		 [ M/spoj(sz, A, J),
		   B,
		   N/fzdkor(C, bp, G, E, H, I, ni, O),
		   D,
		   P/przec,
		   F,
		   Q/fzdj(C, bp, R, E, S, T, ni, A, U)
		 ],
		 V),
	fzdj(K,
	     L,
	     V,
	     C,
	     bp,
	     G,
	     E,
	     H,
	     I,
	     J,
	     A,
	     @ @ @0).

spoj(L, B, N, sz, A, ni) :-
	rozne(A, [ani, przec]),
	goal(fzdkor(C,
		    bp,
		    H,
		    I,
		    J,
		    K,
		    F,
		    P),
	     B,
	     D,
	     O),
	rowne(C, [co, jaki, kto, który]),
	goal(przec, D, E, Q),
	goal(spoj(sz, A, ni), E, G, R),
	goal(fzdkor(C,
		    bp,
		    T,
		    U,
		    V,
		    W,
		    F,
		    X),
	     G,
	     M,
	     S),
	register(fzdj(C,
		      bp,
		      H,
		      I,
		      J,
		      K,
		      F,
		      A,
		      @ @ @0),
		 L,
		 M,
		 zd34,
		 
		 [ N/spoj(sz, A, ni),
		   B,
		   O/fzdkor(C, bp, H, I, J, K, F, P),
		   D,
		   Q/przec,
		   E,
		   R/spoj(sz, A, ni),
		   G,
		   S/fzdkor(C, bp, T, U, V, W, F, X)
		 ],
		 Y),
	fzdj(L,
	     M,
	     Y,
	     C,
	     bp,
	     H,
	     I,
	     J,
	     K,
	     F,
	     A,
	     @ @ @0).

spoj(K, C, M, sz, A, B) :-
	rozne(A, [ani, przec]),
	goal(fzdkor(D,
		    bp,
		    G,
		    H,
		    I,
		    J,
		    B,
		    O),
	     C,
	     E,
	     N),
	rowne(D, [co, jaki, kto, który]),
	goal(przec, E, F, P),
	goal(fzdj(D,
		  bp,
		  R,
		  S,
		  T,
		  U,
		  B,
		  A,
		  V),
	     F,
	     L,
	     Q),
	register(fzdj(D,
		      bp,
		      G,
		      H,
		      I,
		      J,
		      B,
		      A,
		      @ @ @0),
		 K,
		 L,
		 zd35,
		 
		 [ M/spoj(sz, A, B),
		   C,
		   N/fzdkor(D, bp, G, H, I, J, B, O),
		   E,
		   P/przec,
		   F,
		   Q/fzdj(D, bp, R, S, T, U, B, A, V)
		 ],
		 W),
	fzdj(K,
	     L,
	     W,
	     D,
	     bp,
	     G,
	     H,
	     I,
	     J,
	     B,
	     A,
	     @ @ @0).

spoj(J, B, L, po, A, I) :-
	rowne(A,
	      
	      [ aż1,
		aż2,
		chociaż,
		czy,
		dopóki,
		gdy,
		jak,
		jeśli,
		podczas,
		ponieważ,
		zanim,
		że
	      ]),
	goal(zr(N,
		E,
		F,
		G,
		O,
		P,
		H,
		ni,
		z(D, C),
		Q),
	     B,
	     K,
	     M),
	zrowne(C, [A], D),
	register(fzde(A, E, F, G, H, I),
		 J,
		 K,
		 zd42,
		 
		 [ L/spoj(po, A, I),
		   B,
		   M/zr(N, E, F, G, O, P, H, ni, z(D, C), Q)
		 ],
		 R),
	fzde(J,
	     K,
	     R,
	     A,
	     E,
	     F,
	     G,
	     H,
	     I).

spoj(J, B, L, po, A, ni) :-
	rowne(A, [choćby, gdyby, jakby, jakoby, żeby]),
	goal(zr(N,
		E,
		F,
		G,
		O,
		P,
		H,
		I,
		z(D, C),
		Q),
	     B,
	     K,
	     M),
	zrowne(C, [A], D),
	register(fzde(A, E, F, G, H, I),
		 J,
		 K,
		 zd43,
		 
		 [ L/spoj(po, A, ni),
		   B,
		   M/zr(N, E, F, G, O, P, H, I, z(D, C), Q)
		 ],
		 R),
	fzde(J,
	     K,
	     R,
	     A,
	     E,
	     F,
	     G,
	     H,
	     I).

spoj(I, A, K, po, że, H) :-
	goal(zr(M,
		D,
		E,
		F,
		N,
		O,
		G,
		ni,
		z(C, B),
		P),
	     A,
	     J,
	     L),
	zrowne(B, [że], C),
	register(fzde(mie1, D, E, F, G, H),
		 I,
		 J,
		 zd45,
		 
		 [ K/spoj(po, że, H),
		   A,
		   L/zr(M, D, E, F, N, O, G, ni, z(C, B), P)
		 ],
		 Q),
	fzde(I,
	     J,
	     Q,
	     mie1,
	     D,
	     E,
	     F,
	     G,
	     H).

spoj(I, A, K, po, że, H) :-
	goal(zr(M,
		D,
		E,
		F,
		N,
		O,
		G,
		ni,
		z(C, B),
		P),
	     A,
	     J,
	     L),
	zrowne(B, [że], C),
	register(fzde(mie2, D, E, F, G, H),
		 I,
		 J,
		 zd47,
		 
		 [ K/spoj(po, że, H),
		   A,
		   L/zr(M, D, E, F, N, O, G, ni, z(C, B), P)
		 ],
		 Q),
	fzde(I,
	     J,
	     Q,
	     mie2,
	     D,
	     E,
	     F,
	     G,
	     H).

spoj(I, A, K, po, żeby, ni) :-
	goal(zr(M,
		D,
		E,
		F,
		N,
		O,
		G,
		H,
		z(C, B),
		P),
	     A,
	     J,
	     L),
	zrowne(B, [żeby], C),
	register(fzde(mie2, D, E, F, G, H),
		 I,
		 J,
		 zd48,
		 
		 [ K/spoj(po, żeby, ni),
		   A,
		   L/zr(M, D, E, F, N, O, G, H, z(C, B), P)
		 ],
		 Q),
	fzde(I,
	     J,
	     Q,
	     mie2,
	     D,
	     E,
	     F,
	     G,
	     H).

spoj(I, A, K, po, gdy, H) :-
	goal(zr(M,
		D,
		E,
		F,
		N,
		O,
		G,
		ni,
		z(C, B),
		P),
	     A,
	     J,
	     L),
	zrowne(B, [gdy], C),
	register(fzde(mie3, D, E, F, G, H),
		 I,
		 J,
		 zd49,
		 
		 [ K/spoj(po, gdy, H),
		   A,
		   L/zr(M, D, E, F, N, O, G, ni, z(C, B), P)
		 ],
		 Q),
	fzde(I,
	     J,
	     Q,
	     mie3,
	     D,
	     E,
	     F,
	     G,
	     H).

spoj(I, A, K, po, jak, H) :-
	goal(zr(M,
		D,
		E,
		F,
		N,
		O,
		G,
		ni,
		z(C, B),
		P),
	     A,
	     J,
	     L),
	zrowne(B, [jak], C),
	register(fzde(mie3, D, E, F, G, H),
		 I,
		 J,
		 zd50,
		 
		 [ K/spoj(po, jak, H),
		   A,
		   L/zr(M, D, E, F, N, O, G, ni, z(C, B), P)
		 ],
		 Q),
	fzde(I,
	     J,
	     Q,
	     mie3,
	     D,
	     E,
	     F,
	     G,
	     H).

spoj(C, D, E, B, A, ni) :-
	rowne(A, [bowiem, natomiast, więc, zaś]),
	rowne(B, [pi, ri]),
	register(agl(G, 3, A),
		 C,
		 D,
		 agl1e,
		 [E/spoj(B, A, ni)],
		 F),
	agl(C, D, F, G, 3, A).

zj(L, M, N, B, C, D, E, F, G, H, I, J, A, @K) :-
	rozne(A, lub),
	register(zsz(B,
		     C,
		     D,
		     E,
		     F,
		     G,
		     H,
		     I,
		     J,
		     K),
		 L,
		 M,
		 s1,
		 
		 [ N/zj(B, C, D, E, F, G, H, I, J, A, @K)
		 ],
		 O),
	zsz(L,
	    M,
	    O,
	    B,
	    C,
	    D,
	    E,
	    F,
	    G,
	    H,
	    I,
	    J,
	    K).

zj(Q, B, S, G, H, I, J, K, L, M, N, z(pnpp(O), A), przec, T) :-
	oblpnp(A, P),
	goal(spoj(szk, C, ni), B, D, U),
	rozne(C, przec),
	goal(zp(W,
		X,
		Y,
		Z,
		A1,
		B1,
		C1,
		ni,
		z(F, E),
		D1),
	     D,
	     R,
	     V),
	zrowne(E, [p], F),
	register(zsz(G,
		     H,
		     I,
		     J,
		     K,
		     L,
		     M,
		     N,
		     z(O, P),
		     @ @ @ @0),
		 Q,
		 R,
		 s3,
		 
		 [ S/zj(G, H, I, J, K, L, M, N, z(pnpp(O), A), przec, T),
		   B,
		   U/spoj(szk, C, ni),
		   D,
		   V/zp(W, X, Y, Z, A1, B1, C1, ni, z(F, E), D1)
		 ],
		 E1),
	zsz(Q,
	    R,
	    E1,
	    G,
	    H,
	    I,
	    J,
	    K,
	    L,
	    M,
	    N,
	    z(O, P),
	    @ @ @ @0).

zj(S, B, U, J, K, L, M, N, O, H, Q, z(C, A), przec, V) :-
	zrowne(A,
	       
	       [ aż1,
		 bo,
		 bowiem,
		 chociaż,
		 czy,
		 jak,
		 jeśli,
		 np,
		 npt,
		 podczas,
		 ponieważ,
		 że
	       ],
	       F),
	goal(spoj(szk, G, ni), B, D, W),
	goal(zp(Y,
		Z,
		A1,
		B1,
		C1,
		D1,
		I,
		ni,
		z(C, E),
		E1),
	     D,
	     T,
	     X),
	zrowne(E, F, R),
	oblneg(G, P, H, I),
	register(zsz(J,
		     K,
		     L,
		     M,
		     N,
		     O,
		     P,
		     Q,
		     z(C, R),
		     @ @ @ @0),
		 S,
		 T,
		 s5,
		 
		 [ U/zj(J, K, L, M, N, O, H, Q, z(C, A), przec, V),
		   B,
		   W/spoj(szk, G, ni),
		   D,
		   X/zp(Y, Z, A1, B1, C1, D1, I, ni, z(C, E), E1)
		 ],
		 F1),
	zsz(S,
	    T,
	    F1,
	    J,
	    K,
	    L,
	    M,
	    N,
	    O,
	    P,
	    Q,
	    z(C, R),
	    @ @ @ @0).

zj(S, B, U, C, K, L, M, N, O, I, Q, z(D, A), przec, V) :-
	zrowne(A, [byxx, choćby, czyżby, gdyby, jakby, jakoby, żeby], G),
	goal(spoj(szk, H, ni), B, E, W),
	goal(zp(C,
		Y,
		Z,
		A1,
		B1,
		3,
		J,
		ni,
		z(D, F),
		C1),
	     E,
	     T,
	     X),
	zrowne(F, G, R),
	oblneg(H, P, I, J),
	register(zsz(C,
		     K,
		     L,
		     M,
		     N,
		     O,
		     P,
		     Q,
		     z(D, R),
		     @ @ @ @0),
		 S,
		 T,
		 s7,
		 
		 [ U/zj(C, K, L, M, N, O, I, Q, z(D, A), przec, V),
		   B,
		   W/spoj(szk, H, ni),
		   E,
		   X/zp(C, Y, Z, A1, B1, 3, J, ni, z(D, F), C1)
		 ],
		 D1),
	zsz(S,
	    T,
	    D1,
	    C,
	    K,
	    L,
	    M,
	    N,
	    O,
	    P,
	    Q,
	    z(D, R),
	    @ @ @ @0).

zj(S, B, U, L, M, C, D, N, O, J, Q, z(E, A), przec, V) :-
	zrowne(A,
	       [aż1xx, boxx, dopóki, gdyxx, npxx, npxxt, zanim, zanimxx],
	       H),
	goal(spoj(szk, I, ni), B, F, W),
	goal(zp(Y,
		Z,
		C,
		D,
		A1,
		B1,
		K,
		ni,
		z(E, G),
		C1),
	     F,
	     T,
	     X),
	zrowne(G, H, R),
	oblneg(I, P, J, K),
	register(zsz(L,
		     M,
		     C,
		     D,
		     N,
		     O,
		     P,
		     Q,
		     z(E, R),
		     @ @ @ @0),
		 S,
		 T,
		 s9,
		 
		 [ U/zj(L, M, C, D, N, O, J, Q, z(E, A), przec, V),
		   B,
		   W/spoj(szk, I, ni),
		   F,
		   X/zp(Y, Z, C, D, A1, B1, K, ni, z(E, G), C1)
		 ],
		 D1),
	zsz(S,
	    T,
	    D1,
	    L,
	    M,
	    C,
	    D,
	    N,
	    O,
	    P,
	    Q,
	    z(E, R),
	    @ @ @ @0).

zj(S, B, U, K, L, C, M, N, O, I, Q, z(D, A), przec, V) :-
	zrowne(A, [aż2, box, gdy, npx, npxt], G),
	goal(spoj(szk, H, ni), B, E, W),
	goal(zp(Y,
		Z,
		C,
		A1,
		B1,
		C1,
		J,
		ni,
		z(D, F),
		D1),
	     E,
	     T,
	     X),
	zrowne(F, G, R),
	oblneg(H, P, I, J),
	register(zsz(K,
		     L,
		     C,
		     M,
		     N,
		     O,
		     P,
		     Q,
		     z(D, R),
		     @ @ @ @0),
		 S,
		 T,
		 s11,
		 
		 [ U/zj(K, L, C, M, N, O, I, Q, z(D, A), przec, V),
		   B,
		   W/spoj(szk, H, ni),
		   E,
		   X/zp(Y, Z, C, A1, B1, C1, J, ni, z(D, F), D1)
		 ],
		 E1),
	zsz(S,
	    T,
	    E1,
	    K,
	    L,
	    C,
	    M,
	    N,
	    O,
	    P,
	    Q,
	    z(D, R),
	    @ @ @ @0).

zp(P, B, R, F, G, H, I, J, K, L, M, z(pnpp(N), A), S) :-
	oblpnp(A, O),
	goal(zj(U,
		V,
		W,
		X,
		Y,
		Z,
		A1,
		ni,
		z(D, C),
		E,
		B1),
	     B,
	     Q,
	     T),
	zrowne(C, [p], D),
	rozne(E, przec),
	register(zsz(F,
		     G,
		     H,
		     I,
		     J,
		     K,
		     L,
		     M,
		     z(N, O),
		     @ @ @ @0),
		 P,
		 Q,
		 s2,
		 
		 [ R/zp(F, G, H, I, J, K, L, M, z(pnpp(N), A), S),
		   B,
		   T/zj(U, V, W, X, Y, Z, A1, ni, z(D, C), E, B1)
		 ],
		 C1),
	zsz(P,
	    Q,
	    C1,
	    F,
	    G,
	    H,
	    I,
	    J,
	    K,
	    L,
	    M,
	    z(N, O),
	    @ @ @ @0).

zp(R, C, T, I, J, K, L, M, N, G, P, z(B, A), U) :-
	zrowne(A,
	       
	       [ aż1,
		 bo,
		 bowiem,
		 chociaż,
		 czy,
		 jak,
		 jeśli,
		 np,
		 npt,
		 podczas,
		 ponieważ,
		 że
	       ],
	       E),
	goal(zj(W,
		X,
		Y,
		Z,
		A1,
		B1,
		H,
		ni,
		z(B, D),
		F,
		C1),
	     C,
	     S,
	     V),
	zrowne(D, E, Q),
	rozne(F, przec),
	oblneg(F, O, G, H),
	register(zsz(I,
		     J,
		     K,
		     L,
		     M,
		     N,
		     O,
		     P,
		     z(B, Q),
		     @ @ @ @0),
		 R,
		 S,
		 s4,
		 
		 [ T/zp(I, J, K, L, M, N, G, P, z(B, A), U),
		   C,
		   V/zj(W, X, Y, Z, A1, B1, H, ni, z(B, D), F, C1)
		 ],
		 D1),
	zsz(R,
	    S,
	    D1,
	    I,
	    J,
	    K,
	    L,
	    M,
	    N,
	    O,
	    P,
	    z(B, Q),
	    @ @ @ @0).

zp(R, D, T, B, J, K, L, M, N, H, P, z(C, A), U) :-
	zrowne(A, [byxx, choćby, czyżby, gdyby, jakby, jakoby, żeby], F),
	goal(zj(B,
		W,
		X,
		Y,
		Z,
		3,
		I,
		ni,
		z(C, E),
		G,
		A1),
	     D,
	     S,
	     V),
	zrowne(E, F, Q),
	rozne(G, przec),
	oblneg(G, O, H, I),
	register(zsz(B,
		     J,
		     K,
		     L,
		     M,
		     N,
		     O,
		     P,
		     z(C, Q),
		     @ @ @ @0),
		 R,
		 S,
		 s6,
		 
		 [ T/zp(B, J, K, L, M, N, H, P, z(C, A), U),
		   D,
		   V/zj(B, W, X, Y, Z, 3, I, ni, z(C, E), G, A1)
		 ],
		 B1),
	zsz(R,
	    S,
	    B1,
	    B,
	    J,
	    K,
	    L,
	    M,
	    N,
	    O,
	    P,
	    z(C, Q),
	    @ @ @ @0).

zp(R, E, T, K, L, B, C, M, N, I, P, z(D, A), U) :-
	zrowne(A,
	       [aż1xx, boxx, dopóki, gdyxx, npxx, npxxt, zanim, zanimxx],
	       G),
	goal(zj(W,
		X,
		B,
		C,
		Y,
		Z,
		J,
		ni,
		z(D, F),
		H,
		A1),
	     E,
	     S,
	     V),
	zrowne(F, G, Q),
	rozne(H, przec),
	oblneg(H, O, I, J),
	register(zsz(K,
		     L,
		     B,
		     C,
		     M,
		     N,
		     O,
		     P,
		     z(D, Q),
		     @ @ @ @0),
		 R,
		 S,
		 s8,
		 
		 [ T/zp(K, L, B, C, M, N, I, P, z(D, A), U),
		   E,
		   V/zj(W, X, B, C, Y, Z, J, ni, z(D, F), H, A1)
		 ],
		 B1),
	zsz(R,
	    S,
	    B1,
	    K,
	    L,
	    B,
	    C,
	    M,
	    N,
	    O,
	    P,
	    z(D, Q),
	    @ @ @ @0).

zp(R, D, T, J, K, B, L, M, N, H, P, z(C, A), U) :-
	zrowne(A, [aż2, box, gdy, npx, npxt], F),
	goal(zj(W,
		X,
		B,
		Y,
		Z,
		A1,
		I,
		ni,
		z(C, E),
		G,
		B1),
	     D,
	     S,
	     V),
	zrowne(E, F, Q),
	rozne(G, przec),
	oblneg(G, O, H, I),
	register(zsz(J,
		     K,
		     B,
		     L,
		     M,
		     N,
		     O,
		     P,
		     z(C, Q),
		     @ @ @ @0),
		 R,
		 S,
		 s10,
		 
		 [ T/zp(J, K, B, L, M, N, H, P, z(C, A), U),
		   D,
		   V/zj(W, X, B, Y, Z, A1, I, ni, z(C, E), G, B1)
		 ],
		 C1),
	zsz(R,
	    S,
	    C1,
	    J,
	    K,
	    B,
	    L,
	    M,
	    N,
	    O,
	    P,
	    z(C, Q),
	    @ @ @ @0).

zp(K, L, M, A, B, C, D, E, F, G, H, I, @J) :-
	register(zj(A,
		    B,
		    C,
		    D,
		    E,
		    F,
		    G,
		    H,
		    I,
		    przec,
		    J),
		 K,
		 L,
		 j1,
		 
		 [ M/zp(A, B, C, D, E, F, G, H, I, @J)
		 ],
		 N),
	zj(K,
	   L,
	   N,
	   A,
	   B,
	   C,
	   D,
	   E,
	   F,
	   G,
	   H,
	   I,
	   przec,
	   J).

zp(P, B, R, G, H, I, J, K, L, M, N, z(pnpp(C), A), S) :-
	oblpnp(A, F),
	goal(spoj(sz, przec, ni), B, D, T),
	goal(zp(V,
		W,
		X,
		Y,
		Z,
		A1,
		B1,
		ni,
		z(C, E),
		C1),
	     D,
	     Q,
	     U),
	zrowne(E, F, O),
	register(zj(G,
		    H,
		    I,
		    J,
		    K,
		    L,
		    M,
		    N,
		    z(C, O),
		    przec,
		    @ @ @ @0),
		 P,
		 Q,
		 j2,
		 
		 [ R/zp(G, H, I, J, K, L, M, N, z(pnpp(C), A), S),
		   B,
		   T/spoj(sz, przec, ni),
		   D,
		   U/zp(V, W, X, Y, Z, A1, B1, ni, z(C, E), C1)
		 ],
		 D1),
	zj(P,
	   Q,
	   D1,
	   G,
	   H,
	   I,
	   J,
	   K,
	   L,
	   M,
	   N,
	   z(C, O),
	   przec,
	   @ @ @ @0).

zp(P, B, R, G, H, I, J, K, L, M, N, z(pnpp(C), A), S) :-
	oblpnp(A, F),
	goal(spoj(sz, przec, ni), B, D, T),
	goal(zj(V,
		W,
		X,
		Y,
		Z,
		A1,
		B1,
		ni,
		z(C, E),
		przec,
		C1),
	     D,
	     Q,
	     U),
	zrowne(E, F, O),
	register(zj(G,
		    H,
		    I,
		    J,
		    K,
		    L,
		    M,
		    N,
		    z(C, O),
		    przec,
		    @ @ @ @0),
		 P,
		 Q,
		 j3,
		 
		 [ R/zp(G, H, I, J, K, L, M, N, z(pnpp(C), A), S),
		   B,
		   T/spoj(sz, przec, ni),
		   D,
		   U/zj(V, W, X, Y, Z, A1, B1, ni, z(C, E), przec, C1)
		 ],
		 D1),
	zj(P,
	   Q,
	   D1,
	   G,
	   H,
	   I,
	   J,
	   K,
	   L,
	   M,
	   N,
	   z(C, O),
	   przec,
	   @ @ @ @0).

zp(R, B, T, I, J, K, L, M, N, G, P, z(C, A), U) :-
	zrowne(A,
	       
	       [ aż1,
		 bo,
		 bowiem,
		 chociaż,
		 czy,
		 jak,
		 jeśli,
		 np,
		 npt,
		 podczas,
		 ponieważ,
		 pz,
		 że
	       ],
	       F),
	goal(spoj(sz, przec, ni), B, D, V),
	goal(zj(X,
		Y,
		Z,
		A1,
		B1,
		C1,
		H,
		ni,
		z(C, E),
		przec,
		D1),
	     D,
	     S,
	     W),
	zrowne(E, F, Q),
	oblneg(_, O, G, H),
	register(zj(I,
		    J,
		    K,
		    L,
		    M,
		    N,
		    O,
		    P,
		    z(C, Q),
		    przec,
		    @ @ @ @0),
		 R,
		 S,
		 j7,
		 
		 [ T/zp(I, J, K, L, M, N, G, P, z(C, A), U),
		   B,
		   V/spoj(sz, przec, ni),
		   D,
		   W/zj(X, Y, Z, A1, B1, C1, H, ni, z(C, E), przec, D1)
		 ],
		 E1),
	zj(R,
	   S,
	   E1,
	   I,
	   J,
	   K,
	   L,
	   M,
	   N,
	   O,
	   P,
	   z(C, Q),
	   przec,
	   @ @ @ @0).

zp(R, B, T, C, J, K, L, M, N, H, P, z(D, A), U) :-
	zrowne(A, [byxx, choćby, czyżby, gdyby, jakby, jakoby, żeby], G),
	goal(spoj(szk, przec, ni), B, E, V),
	goal(zp(C,
		X,
		Y,
		Z,
		A1,
		3,
		I,
		ni,
		z(D, F),
		B1),
	     E,
	     S,
	     W),
	zrowne(F, G, Q),
	oblneg(_, O, H, I),
	register(zj(C,
		    J,
		    K,
		    L,
		    M,
		    N,
		    O,
		    P,
		    z(D, Q),
		    przec,
		    @ @ @ @0),
		 R,
		 S,
		 j10,
		 
		 [ T/zp(C, J, K, L, M, N, H, P, z(D, A), U),
		   B,
		   V/spoj(szk, przec, ni),
		   E,
		   W/zp(C, X, Y, Z, A1, 3, I, ni, z(D, F), B1)
		 ],
		 C1),
	zj(R,
	   S,
	   C1,
	   C,
	   J,
	   K,
	   L,
	   M,
	   N,
	   O,
	   P,
	   z(D, Q),
	   przec,
	   @ @ @ @0).

zp(R, B, T, C, J, K, L, M, N, H, P, z(D, A), U) :-
	zrowne(A, [byxx, choćby, czyżby, gdyby, jakby, jakoby, żeby], G),
	goal(spoj(szk, przec, ni), B, E, V),
	goal(zj(C,
		X,
		Y,
		Z,
		A1,
		3,
		I,
		ni,
		z(D, F),
		przec,
		B1),
	     E,
	     S,
	     W),
	zrowne(F, G, Q),
	oblneg(_, O, H, I),
	register(zj(C,
		    J,
		    K,
		    L,
		    M,
		    N,
		    O,
		    P,
		    z(D, Q),
		    przec,
		    @ @ @ @0),
		 R,
		 S,
		 j11,
		 
		 [ T/zp(C, J, K, L, M, N, H, P, z(D, A), U),
		   B,
		   V/spoj(szk, przec, ni),
		   E,
		   W/zj(C, X, Y, Z, A1, 3, I, ni, z(D, F), przec, B1)
		 ],
		 C1),
	zj(R,
	   S,
	   C1,
	   C,
	   J,
	   K,
	   L,
	   M,
	   N,
	   O,
	   P,
	   z(D, Q),
	   przec,
	   @ @ @ @0).

zp(R, B, T, K, L, C, D, M, N, I, P, z(E, A), U) :-
	zrowne(A,
	       [aż1xx, boxx, dopóki, gdyxx, npxx, npxxt, zanim, zanimxx],
	       H),
	goal(spoj(szk, przec, ni), B, F, V),
	goal(zp(X,
		Y,
		C,
		D,
		Z,
		A1,
		J,
		ni,
		z(E, G),
		B1),
	     F,
	     S,
	     W),
	zrowne(G, H, Q),
	oblneg(_, O, I, J),
	register(zj(K,
		    L,
		    C,
		    D,
		    M,
		    N,
		    O,
		    P,
		    z(E, Q),
		    przec,
		    @ @ @ @0),
		 R,
		 S,
		 j14,
		 
		 [ T/zp(K, L, C, D, M, N, I, P, z(E, A), U),
		   B,
		   V/spoj(szk, przec, ni),
		   F,
		   W/zp(X, Y, C, D, Z, A1, J, ni, z(E, G), B1)
		 ],
		 C1),
	zj(R,
	   S,
	   C1,
	   K,
	   L,
	   C,
	   D,
	   M,
	   N,
	   O,
	   P,
	   z(E, Q),
	   przec,
	   @ @ @ @0).

zp(R, B, T, K, L, C, D, M, N, I, P, z(E, A), U) :-
	zrowne(A,
	       [aż1xx, boxx, dopóki, gdyxx, npxx, npxxt, zanim, zanimxx],
	       H),
	goal(spoj(szk, przec, ni), B, F, V),
	goal(zj(X,
		Y,
		C,
		D,
		Z,
		A1,
		J,
		ni,
		z(E, G),
		przec,
		B1),
	     F,
	     S,
	     W),
	zrowne(G, H, Q),
	oblneg(_, O, I, J),
	register(zj(K,
		    L,
		    C,
		    D,
		    M,
		    N,
		    O,
		    P,
		    z(E, Q),
		    przec,
		    @ @ @ @0),
		 R,
		 S,
		 j15,
		 
		 [ T/zp(K, L, C, D, M, N, I, P, z(E, A), U),
		   B,
		   V/spoj(szk, przec, ni),
		   F,
		   W/zj(X, Y, C, D, Z, A1, J, ni, z(E, G), przec, B1)
		 ],
		 C1),
	zj(R,
	   S,
	   C1,
	   K,
	   L,
	   C,
	   D,
	   M,
	   N,
	   O,
	   P,
	   z(E, Q),
	   przec,
	   @ @ @ @0).

zp(R, B, T, J, K, C, L, M, N, H, P, z(D, A), U) :-
	zrowne(A, [aż2, box, gdy, npx, npxt], G),
	goal(spoj(szk, przec, ni), B, E, V),
	goal(zp(X,
		Y,
		C,
		Z,
		A1,
		B1,
		I,
		ni,
		z(D, F),
		C1),
	     E,
	     S,
	     W),
	zrowne(F, G, Q),
	oblneg(_, O, H, I),
	register(zj(J,
		    K,
		    C,
		    L,
		    M,
		    N,
		    O,
		    P,
		    z(D, Q),
		    przec,
		    @ @ @ @0),
		 R,
		 S,
		 j18,
		 
		 [ T/zp(J, K, C, L, M, N, H, P, z(D, A), U),
		   B,
		   V/spoj(szk, przec, ni),
		   E,
		   W/zp(X, Y, C, Z, A1, B1, I, ni, z(D, F), C1)
		 ],
		 D1),
	zj(R,
	   S,
	   D1,
	   J,
	   K,
	   C,
	   L,
	   M,
	   N,
	   O,
	   P,
	   z(D, Q),
	   przec,
	   @ @ @ @0).

zp(R, B, T, J, K, C, L, M, N, H, P, z(D, A), U) :-
	zrowne(A, [aż2, box, gdy, npx, npxt], G),
	goal(spoj(szk, przec, ni), B, E, V),
	goal(zj(X,
		Y,
		C,
		Z,
		A1,
		B1,
		I,
		ni,
		z(D, F),
		przec,
		C1),
	     E,
	     S,
	     W),
	zrowne(F, G, Q),
	oblneg(_, O, H, I),
	register(zj(J,
		    K,
		    C,
		    L,
		    M,
		    N,
		    O,
		    P,
		    z(D, Q),
		    przec,
		    @ @ @ @0),
		 R,
		 S,
		 j19,
		 
		 [ T/zp(J, K, C, L, M, N, H, P, z(D, A), U),
		   B,
		   V/spoj(szk, przec, ni),
		   E,
		   W/zj(X, Y, C, Z, A1, B1, I, ni, z(D, F), przec, C1)
		 ],
		 D1),
	zj(R,
	   S,
	   D1,
	   J,
	   K,
	   C,
	   L,
	   M,
	   N,
	   O,
	   P,
	   z(D, Q),
	   przec,
	   @ @ @ @0).

ze(K, L, M, A, B, C, D, E, F, N, G, H, I, br, @J) :-
	register(zp(A,
		    B,
		    C,
		    D,
		    E,
		    F,
		    G,
		    H,
		    I,
		    J),
		 K,
		 L,
		 p1,
		 
		 [ M/ze(A, B, C, D, E, F, N, G, H, I, br, @J)
		 ],
		 O),
	zp(K,
	   L,
	   O,
	   A,
	   B,
	   C,
	   D,
	   E,
	   F,
	   G,
	   H,
	   I,
	   J).

ze(Q, B, S, G, H, I, J, K, L, T, M, N, z(npp(O), A), br, U) :-
	oblnp(A, P),
	goal(przec, B, C, V),
	goal(spoj(pc, bo, ni), C, D, W),
	goal(ze(Y,
		Z,
		A1,
		B1,
		C1,
		D1,
		E1,
		F1,
		ni,
		z(F, E),
		br,
		G1),
	     D,
	     R,
	     X),
	zrowne(E, [p], F),
	register(zp(G,
		    H,
		    I,
		    J,
		    K,
		    L,
		    M,
		    N,
		    z(O, P),
		    @ @ @ @0),
		 Q,
		 R,
		 p9,
		 
		 [ S/ze(G, H, I, J, K, L, T, M, N, z(npp(O), A), br, U),
		   B,
		   V/przec,
		   C,
		   W/spoj(pc, bo, ni),
		   D,
		   X/ze(Y, Z, A1, B1, C1, D1, E1, F1, ni, z(F, E), br, G1)
		 ],
		 H1),
	zp(Q,
	   R,
	   H1,
	   G,
	   H,
	   I,
	   J,
	   K,
	   L,
	   M,
	   N,
	   z(O, P),
	   @ @ @ @0).

ze(R, C, T, H, I, J, K, L, M, U, N, O, z(npp(P), A), więc, V) :-
	oblzal(A, B, więc),
	oblnp(B, Q),
	goal(przec, C, D, W),
	goal(spoj(pc, więc, ni), D, E, X),
	goal(ze(Z,
		A1,
		B1,
		C1,
		D1,
		E1,
		F1,
		G1,
		ni,
		z(G, F),
		br,
		H1),
	     E,
	     S,
	     Y),
	zrowne(F, [p], G),
	register(zp(H,
		    I,
		    J,
		    K,
		    L,
		    M,
		    N,
		    O,
		    z(P, Q),
		    @ @ @ @0),
		 R,
		 S,
		 p10,
		 
		 [ T/ze(H, I, J, K, L, M, U, N, O, z(npp(P), A), więc, V),
		   C,
		   W/przec,
		   D,
		   X/spoj(pc, więc, ni),
		   E,
		   Y/ze(Z, A1, B1, C1, D1, E1, F1, G1, ni, z(G, F), br, H1)
		 ],
		 I1),
	zp(R,
	   S,
	   I1,
	   H,
	   I,
	   J,
	   K,
	   L,
	   M,
	   N,
	   O,
	   z(P, Q),
	   @ @ @ @0).

ze(O, A, Q, F, G, H, I, J, K, R, L, M, N, br, S) :-
	goal(przec, A, B, T),
	goal(spoj(pc, bo, ni), B, C, U),
	goal(ze(W,
		X,
		Y,
		Z,
		A1,
		B1,
		C1,
		D1,
		ni,
		z(E, D),
		br,
		E1),
	     C,
	     P,
	     V),
	zrowne(D, [bo], E),
	register(zp(F,
		    G,
		    H,
		    I,
		    J,
		    K,
		    L,
		    M,
		    N,
		    @ @ @ @0),
		 O,
		 P,
		 p11,
		 
		 [ Q/ze(F, G, H, I, J, K, R, L, M, N, br, S),
		   A,
		   T/przec,
		   B,
		   U/spoj(pc, bo, ni),
		   C,
		   V/ze(W, X, Y, Z, A1, B1, C1, D1, ni, z(E, D), br, E1)
		 ],
		 F1),
	zp(O,
	   P,
	   F1,
	   F,
	   G,
	   H,
	   I,
	   J,
	   K,
	   L,
	   M,
	   N,
	   @ @ @ @0).

ze(R, C, T, H, I, J, K, L, M, U, N, O, z(P, A), więc, V) :-
	oblzal(A, B, więc),
	zrozne(B,
	       
	       [ byxx,
		 choćby,
		 co,
		 czyżby,
		 gdyby,
		 jakby,
		 jaki,
		 jakoby,
		 kto,
		 który,
		 p,
		 px,
		 pxx,
		 pz,
		 żeby
	       ],
	       Q),
	goal(przec, C, D, W),
	goal(spoj(pc, więc, ni), D, E, X),
	goal(ze(Z,
		A1,
		B1,
		C1,
		D1,
		E1,
		F1,
		G1,
		ni,
		z(G, F),
		br,
		H1),
	     E,
	     S,
	     Y),
	zrowne(F, [np], G),
	register(zp(H,
		    I,
		    J,
		    K,
		    L,
		    M,
		    N,
		    O,
		    z(P, Q),
		    @ @ @ @0),
		 R,
		 S,
		 p12,
		 
		 [ T/ze(H, I, J, K, L, M, U, N, O, z(P, A), więc, V),
		   C,
		   W/przec,
		   D,
		   X/spoj(pc, więc, ni),
		   E,
		   Y/ze(Z, A1, B1, C1, D1, E1, F1, G1, ni, z(G, F), br, H1)
		 ],
		 I1),
	zp(R,
	   S,
	   I1,
	   H,
	   I,
	   J,
	   K,
	   L,
	   M,
	   N,
	   O,
	   z(P, Q),
	   @ @ @ @0).

ze(P, B, R, F, G, H, I, J, K, S, L, M, z(npp(N), A), br, T) :-
	oblnp(A, O),
	goal(przec, B, C, U),
	goal(ze(W,
		X,
		Y,
		Z,
		A1,
		B1,
		C1,
		D1,
		bowiem,
		z(E, D),
		br,
		E1),
	     C,
	     Q,
	     V),
	zrowne(D, [p], E),
	register(zp(F,
		    G,
		    H,
		    I,
		    J,
		    K,
		    L,
		    M,
		    z(N, O),
		    @ @ @ @0),
		 P,
		 Q,
		 p13,
		 
		 [ R/ze(F, G, H, I, J, K, S, L, M, z(npp(N), A), br, T),
		   B,
		   U/przec,
		   C,
		   V/ze(W, X, Y, Z, A1, B1, C1, D1, bowiem, z(E, D), br, E1)
		 ],
		 F1),
	zp(P,
	   Q,
	   F1,
	   F,
	   G,
	   H,
	   I,
	   J,
	   K,
	   L,
	   M,
	   z(N, O),
	   @ @ @ @0).

ze(Q, C, S, G, H, I, J, K, L, T, M, N, z(npp(O), A), więc, U) :-
	oblzal(A, B, więc),
	oblnp(B, P),
	goal(przec, C, D, V),
	goal(ze(X,
		Y,
		Z,
		A1,
		B1,
		C1,
		D1,
		E1,
		więc,
		z(F, E),
		br,
		F1),
	     D,
	     R,
	     W),
	zrowne(E, [p], F),
	register(zp(G,
		    H,
		    I,
		    J,
		    K,
		    L,
		    M,
		    N,
		    z(O, P),
		    @ @ @ @0),
		 Q,
		 R,
		 p14,
		 
		 [ S/ze(G, H, I, J, K, L, T, M, N, z(npp(O), A), więc, U),
		   C,
		   V/przec,
		   D,
		   W/ze(X, Y, Z, A1, B1, C1, D1, E1, więc, z(F, E), br, F1)
		 ],
		 G1),
	zp(Q,
	   R,
	   G1,
	   G,
	   H,
	   I,
	   J,
	   K,
	   L,
	   M,
	   N,
	   z(O, P),
	   @ @ @ @0).

ze(N, A, P, E, F, G, H, I, J, Q, K, L, M, br, R) :-
	goal(przec, A, B, S),
	goal(ze(U,
		V,
		W,
		X,
		Y,
		Z,
		A1,
		B1,
		bowiem,
		z(D, C),
		br,
		C1),
	     B,
	     O,
	     T),
	zrowne(C, [bowiem], D),
	register(zp(E,
		    F,
		    G,
		    H,
		    I,
		    J,
		    K,
		    L,
		    M,
		    @ @ @ @0),
		 N,
		 O,
		 p15,
		 
		 [ P/ze(E, F, G, H, I, J, Q, K, L, M, br, R),
		   A,
		   S/przec,
		   B,
		   T/ze(U, V, W, X, Y, Z, A1, B1, bowiem, z(D, C), br, C1)
		 ],
		 D1),
	zp(N,
	   O,
	   D1,
	   E,
	   F,
	   G,
	   H,
	   I,
	   J,
	   K,
	   L,
	   M,
	   @ @ @ @0).

ze(Q, C, S, G, H, I, J, K, L, T, M, N, z(O, A), więc, U) :-
	oblzal(A, B, więc),
	zrozne(B,
	       
	       [ byxx,
		 choćby,
		 co,
		 czyżby,
		 gdyby,
		 jakby,
		 jaki,
		 jakoby,
		 kto,
		 który,
		 p,
		 px,
		 pxx,
		 pz,
		 żeby
	       ],
	       P),
	goal(przec, C, D, V),
	goal(ze(X,
		Y,
		Z,
		A1,
		B1,
		C1,
		D1,
		E1,
		więc,
		z(F, E),
		br,
		F1),
	     D,
	     R,
	     W),
	zrowne(E, [np], F),
	register(zp(G,
		    H,
		    I,
		    J,
		    K,
		    L,
		    M,
		    N,
		    z(O, P),
		    @ @ @ @0),
		 Q,
		 R,
		 p16,
		 
		 [ S/ze(G, H, I, J, K, L, T, M, N, z(O, A), więc, U),
		   C,
		   V/przec,
		   D,
		   W/ze(X, Y, Z, A1, B1, C1, D1, E1, więc, z(F, E), br, F1)
		 ],
		 G1),
	zp(Q,
	   R,
	   G1,
	   G,
	   H,
	   I,
	   J,
	   K,
	   L,
	   M,
	   N,
	   z(O, P),
	   @ @ @ @0).

fzd(P, B, R, A, nk, S, T, U, V, M, W) :-
	rowne(A, [choćby, gdyby]),
	goal(przec, B, C, X),
	goal(spoj(pp, A, ni), C, D, Y),
	goal(ze(G,
		H,
		przy,
		I,
		J,
		K,
		A1,
		L,
		ni,
		z(N, E),
		A,
		B1),
	     D,
	     Q,
	     Z),
	oblzal(E, F, A),
	zrozne(F,
	       
	       [ byxx,
		 choćby,
		 co,
		 czyżby,
		 gdyby,
		 jakby,
		 jaki,
		 jakoby,
		 kto,
		 który,
		 pz,
		 żeby
	       ],
	       O),
	register(zp(G,
		    H,
		    przy,
		    I,
		    J,
		    K,
		    L,
		    M,
		    z(N, O),
		    @ @ @ @0),
		 P,
		 Q,
		 p2,
		 
		 [ R/fzd(A, nk, S, T, U, V, M, W),
		   B,
		   X/przec,
		   C,
		   Y/spoj(pp, A, ni),
		   D,
		   Z/ze(G, H, przy, I, J, K, A1, L, ni, z(N, E), A, B1)
		 ],
		 C1),
	zp(P,
	   Q,
	   C1,
	   G,
	   H,
	   przy,
	   I,
	   J,
	   K,
	   L,
	   M,
	   z(N, O),
	   @ @ @ @0).

fzd(Q, B, S, A, nk, T, D, U, V, N, W) :-
	rowne(A, [dopóki, gdy]),
	goal(przec, B, C, X),
	goal(spoj(pp, A, ni), C, E, Y),
	goal(ze(H,
		I,
		D,
		J,
		K,
		L,
		A1,
		M,
		ni,
		z(O, F),
		A,
		B1),
	     E,
	     R,
	     Z),
	oblzal(F, G, A),
	zrozne(G,
	       
	       [ byxx,
		 choćby,
		 co,
		 czyżby,
		 gdyby,
		 jakby,
		 jaki,
		 jakoby,
		 kto,
		 który,
		 pz,
		 żeby
	       ],
	       P),
	register(zp(H,
		    I,
		    D,
		    J,
		    K,
		    L,
		    M,
		    N,
		    z(O, P),
		    @ @ @ @0),
		 Q,
		 R,
		 p3,
		 
		 [ S/fzd(A, nk, T, D, U, V, N, W),
		   B,
		   X/przec,
		   C,
		   Y/spoj(pp, A, ni),
		   E,
		   Z/ze(H, I, D, J, K, L, A1, M, ni, z(O, F), A, B1)
		 ],
		 C1),
	zp(Q,
	   R,
	   C1,
	   H,
	   I,
	   D,
	   J,
	   K,
	   L,
	   M,
	   N,
	   z(O, P),
	   @ @ @ @0).

fzd(P, B, R, A, nk, S, T, U, V, M, W) :-
	rowne(A, [chociaż, jeśli]),
	goal(przec, B, C, X),
	goal(spoj(pp, A, ni), C, D, Y),
	goal(ze(F,
		G,
		H,
		I,
		J,
		K,
		A1,
		L,
		ni,
		z(N, E),
		br,
		B1),
	     D,
	     Q,
	     Z),
	zrozne(E,
	       
	       [ byxx,
		 choćby,
		 co,
		 czyżby,
		 gdyby,
		 jakby,
		 jaki,
		 jakoby,
		 kto,
		 który,
		 pz,
		 żeby
	       ],
	       O),
	register(zp(F,
		    G,
		    H,
		    I,
		    J,
		    K,
		    L,
		    M,
		    z(N, O),
		    @ @ @ @0),
		 P,
		 Q,
		 p4,
		 
		 [ R/fzd(A, nk, S, T, U, V, M, W),
		   B,
		   X/przec,
		   C,
		   Y/spoj(pp, A, ni),
		   D,
		   Z/ze(F, G, H, I, J, K, A1, L, ni, z(N, E), br, B1)
		 ],
		 C1),
	zp(P,
	   Q,
	   C1,
	   F,
	   G,
	   H,
	   I,
	   J,
	   K,
	   L,
	   M,
	   z(N, O),
	   @ @ @ @0).

fzd(P, B, R, A, nk, S, T, U, V, M, W) :-
	rowne(A, [choćby, gdyby]),
	goal(przec, B, C, X),
	goal(spoj(pp, A, ni), C, D, Y),
	goal(ze(G,
		H,
		I,
		J,
		K,
		3,
		A1,
		L,
		ni,
		z(N, E),
		A,
		B1),
	     D,
	     Q,
	     Z),
	oblzal(E, F, A),
	zrowne(F, [byxx, choćby, czyżby, gdyby, jakby, jakoby, żeby], O),
	register(zp(G,
		    H,
		    I,
		    J,
		    K,
		    3,
		    L,
		    M,
		    z(N, O),
		    @ @ @ @0),
		 P,
		 Q,
		 p5,
		 
		 [ R/fzd(A, nk, S, T, U, V, M, W),
		   B,
		   X/przec,
		   C,
		   Y/spoj(pp, A, ni),
		   D,
		   Z/ze(G, H, I, J, K, 3, A1, L, ni, z(N, E), A, B1)
		 ],
		 C1),
	zp(P,
	   Q,
	   C1,
	   G,
	   H,
	   I,
	   J,
	   K,
	   3,
	   L,
	   M,
	   z(N, O),
	   @ @ @ @0).

fzd(O, B, Q, A, nk, R, S, T, U, L, V) :-
	rowne(A, [chociaż, jeśli]),
	goal(przec, B, C, W),
	goal(spoj(pp, A, ni), C, D, X),
	goal(ze(F,
		G,
		H,
		I,
		J,
		3,
		Z,
		K,
		ni,
		z(M, E),
		br,
		A1),
	     D,
	     P,
	     Y),
	zrowne(E, [byxx, choćby, czyżby, gdyby, jakby, jakoby, żeby], N),
	register(zp(F,
		    G,
		    H,
		    I,
		    J,
		    3,
		    K,
		    L,
		    z(M, N),
		    @ @ @ @0),
		 O,
		 P,
		 p5x,
		 
		 [ Q/fzd(A, nk, R, S, T, U, L, V),
		   B,
		   W/przec,
		   C,
		   X/spoj(pp, A, ni),
		   D,
		   Y/ze(F, G, H, I, J, 3, Z, K, ni, z(M, E), br, A1)
		 ],
		 B1),
	zp(O,
	   P,
	   B1,
	   F,
	   G,
	   H,
	   I,
	   J,
	   3,
	   K,
	   L,
	   z(M, N),
	   @ @ @ @0).

fzd(P, B, R, A, nk, S, T, U, V, M, W) :-
	rowne(A, [dopóki, gdy]),
	goal(przec, B, C, X),
	goal(spoj(pp, A, ni), C, D, Y),
	goal(ze(G,
		H,
		I,
		J,
		K,
		3,
		A1,
		L,
		ni,
		z(N, E),
		A,
		B1),
	     D,
	     Q,
	     Z),
	oblzal(E, F, A),
	zrowne(F, [byxx, choćby, czyżby, gdyby, jakby, jakoby, żeby], O),
	register(zp(G,
		    H,
		    I,
		    J,
		    K,
		    3,
		    L,
		    M,
		    z(N, O),
		    @ @ @ @0),
		 P,
		 Q,
		 p6,
		 
		 [ R/fzd(A, nk, S, T, U, V, M, W),
		   B,
		   X/przec,
		   C,
		   Y/spoj(pp, A, ni),
		   D,
		   Z/ze(G, H, I, J, K, 3, A1, L, ni, z(N, E), A, B1)
		 ],
		 C1),
	zp(P,
	   Q,
	   C1,
	   G,
	   H,
	   I,
	   J,
	   K,
	   3,
	   L,
	   M,
	   z(N, O),
	   @ @ @ @0).

fzd(E, A, G, B, dop, H, I, J, K, C, L) :-
	goal(przec, A, F, M),
	rowne(B, [aż1, czy, jak, jakby, jakoby, mie1, mie2, mie3, pz, że, żeby]),
	D=[p, np, pz, co, jaki, kto, który],
	register(fw1(sentp(B),
		     bier,
		     O,
		     P,
		     Q,
		     R,
		     nie(S),
		     C,
		     z(T, D)),
		 E,
		 F,
		 wy17,
		 
		 [ G/fzd(B, dop, H, I, J, K, C, L),
		   A,
		   M/przec
		 ],
		 N),
	fw1(E,
	    F,
	    N,
	    sentp(B),
	    bier,
	    O,
	    P,
	    Q,
	    R,
	    nie(S),
	    C,
	    z(T, D)).

fzd(E, A, G, B, bier, H, I, J, K, C, L) :-
	goal(przec, A, F, M),
	rowne(B, [aż1, czy, jak, jakby, jakoby, mie1, mie2, mie3, pz, że, żeby]),
	D=[p, np, pz, co, jaki, kto, który],
	register(fw1(sentp(B),
		     bier,
		     O,
		     P,
		     Q,
		     R,
		     tak,
		     C,
		     z(S, D)),
		 E,
		 F,
		 wy18,
		 
		 [ G/fzd(B, bier, H, I, J, K, C, L),
		   A,
		   M/przec
		 ],
		 N),
	fw1(E,
	    F,
	    N,
	    sentp(B),
	    bier,
	    O,
	    P,
	    Q,
	    R,
	    tak,
	    C,
	    z(S, D)).

fzd(E, A, G, B, nk, H, I, J, K, C, L) :-
	goal(przec, A, F, M),
	rowne(B, [aż1, czy, jak, jakby, jakoby, mie1, mie2, mie3, pz, że, żeby]),
	D=[p, np, pz, co, jaki, kto, który],
	register(fw1(sentp(B),
		     nk,
		     O,
		     P,
		     Q,
		     R,
		     S,
		     C,
		     z(T, D)),
		 E,
		 F,
		 wy19,
		 
		 [ G/fzd(B, nk, H, I, J, K, C, L),
		   A,
		   M/przec
		 ],
		 N),
	fw1(E,
	    F,
	    N,
	    sentp(B),
	    nk,
	    O,
	    P,
	    Q,
	    R,
	    S,
	    C,
	    z(T, D)).

fzd(F, A, H, B, C, I, J, K, L, D, M) :-
	goal(przec, A, G, N),
	rowne(B, [aż1, czy, jak, jakby, jakoby, mie1, mie2, mie3, pz, że, żeby]),
	rozne(C, [bier, bp, nk]),
	E=[p, np, pz, co, jaki, kto, który],
	register(fw1(sentp(C, B),
		     C,
		     P,
		     Q,
		     R,
		     S,
		     T,
		     D,
		     z(U, E)),
		 F,
		 G,
		 wy19a,
		 
		 [ H/fzd(B, C, I, J, K, L, D, M),
		   A,
		   N/przec
		 ],
		 O),
	fw1(F,
	    G,
	    O,
	    sentp(C, B),
	    C,
	    P,
	    Q,
	    R,
	    S,
	    T,
	    D,
	    z(U, E)).

fzd(G, A, I, B, C/D, J, K, L, M, E, N) :-
	goal(przec, A, H, O),
	rowne(B, [aż1, czy, jak, jakby, jakoby, mie1, mie2, mie3, pz, że, żeby]),
	F=[p, np, pz, co, jaki, kto, który],
	register(fw1(sentp(C, D, B),
		     C/D,
		     Q,
		     R,
		     S,
		     T,
		     U,
		     E,
		     z(V, F)),
		 G,
		 H,
		 wy19b,
		 
		 [ I/fzd(B, C/D, J, K, L, M, E, N),
		   A,
		   O/przec
		 ],
		 P),
	fw1(G,
	    H,
	    P,
	    sentp(C, D, B),
	    C/D,
	    Q,
	    R,
	    S,
	    T,
	    U,
	    E,
	    z(V, F)).

fzd(D, A, F, dopóki, nk, G, B, H, I, C, J) :-
	goal(przec, A, E, K),
	register(fl1(nd,
		     B,
		     M,
		     N,
		     tak,
		     C,
		     z(O, [np])),
		 D,
		 E,
		 lu15,
		 
		 [ F/fzd(dopóki, nk, G, B, H, I, C, J),
		   A,
		   K/przec
		 ],
		 L),
	fl1(D,
	    E,
	    L,
	    nd,
	    B,
	    M,
	    N,
	    tak,
	    C,
	    z(O, [np])).

fzd(D, A, F, dopóki, nk, G, B, H, I, C, J) :-
	goal(przec, A, E, K),
	register(fl1(M,
		     B,
		     N,
		     O,
		     nie(nie),
		     C,
		     z(P, [np])),
		 D,
		 E,
		 lu16,
		 
		 [ F/fzd(dopóki, nk, G, B, H, I, C, J),
		   A,
		   K/przec
		 ],
		 L),
	fl1(D,
	    E,
	    L,
	    M,
	    B,
	    N,
	    O,
	    nie(nie),
	    C,
	    z(P, [np])).

fzd(E, A, G, B, nk, H, I, J, K, D, L) :-
	goal(przec, A, F, M),
	rowne(B, [choćby, gdyby]),
	rozne(C, prze),
	register(fl1(O,
		     C,
		     P,
		     Q,
		     R,
		     D,
		     z(S, [np])),
		 E,
		 F,
		 lu17,
		 
		 [ G/fzd(B, nk, H, I, J, K, D, L),
		   A,
		   M/przec
		 ],
		 N),
	fl1(E,
	    F,
	    N,
	    O,
	    C,
	    P,
	    Q,
	    R,
	    D,
	    z(S, [np])).

fzd(E, A, G, B, nk, H, C, I, J, D, K) :-
	goal(przec, A, F, L),
	rowne(B, [aż2, gdy, zanim]),
	register(fl1(N,
		     C,
		     O,
		     P,
		     Q,
		     D,
		     z(R, [np])),
		 E,
		 F,
		 lu18,
		 
		 [ G/fzd(B, nk, H, C, I, J, D, K),
		   A,
		   L/przec
		 ],
		 M),
	fl1(E,
	    F,
	    M,
	    N,
	    C,
	    O,
	    P,
	    Q,
	    D,
	    z(R, [np])).

fzd(D, A, F, B, nk, G, H, I, J, C, K) :-
	goal(przec, A, E, L),
	rowne(B, [bo, co, chociaż, czy, jak, jeśli, podczas, ponieważ]),
	register(fl1(N,
		     O,
		     P,
		     Q,
		     R,
		     C,
		     z(S, [np])),
		 D,
		 E,
		 lu19,
		 
		 [ F/fzd(B, nk, G, H, I, J, C, K),
		   A,
		   L/przec
		 ],
		 M),
	fl1(D,
	    E,
	    M,
	    N,
	    O,
	    P,
	    Q,
	    R,
	    C,
	    z(S, [np])).

fzd(I, J, K, A, B, C, D, E, F, G, @H) :-
	register(fzdkor(A,
			B,
			C,
			D,
			E,
			F,
			G,
			H),
		 I,
		 J,
		 zd41,
		 
		 [ K/fzd(A, B, C, D, E, F, G, @H)
		 ],
		 L),
	fzdkor(I,
	       J,
	       L,
	       A,
	       B,
	       C,
	       D,
	       E,
	       F,
	       G,
	       H).

fl(T, A, V, B, C, D, E, G, P, z(K, J)) :-
	wymagania(W,
		  [],
		  A,
		  U,
		  [],
		  F,
		  L,
		  ff(N,
		     B,
		     C,
		     O,
		     D,
		     E,
		     F,
		     I,
		     G,
		     ni,
		     z(Q, M),
		     S),
		  H/fw(H, I, B, C, D, E, G, ni, z(_, _))/{zrowne(J, [p, np], K)}),
	resztawym(L),
	zrowne(M, [p, px, pxx], R),
	register(ze(N,
		    B,
		    C,
		    O,
		    D,
		    E,
		    F,
		    G,
		    P,
		    z(Q, R),
		    S,
		    @ @ @ @0),
		 T,
		 U,
		 e1,
		 
		 [ V/fl(B, C, D, E, G, P, z(K, J))
		 | W
		 ],
		 X),
	ze(T,
	   U,
	   X,
	   N,
	   B,
	   C,
	   O,
	   D,
	   E,
	   F,
	   G,
	   P,
	   z(Q, R),
	   S,
	   @ @ @ @0).

fl(V, C, X, D, E, F, G, I, R, z(B, A)) :-
	zrowne(A, [np], B),
	wymagania(Y,
		  [],
		  C,
		  W,
		  [],
		  H,
		  N,
		  ff(P,
		     D,
		     E,
		     Q,
		     F,
		     G,
		     H,
		     K,
		     I,
		     ni,
		     z(S, O),
		     U),
		  J/fw(J, K, D, E, F, G, I, ni, z(M, L))/{zrowne(L, [np], M)}),
	resztawym(N),
	zrozne(O,
	       
	       [ byxx,
		 choćby,
		 co,
		 czyżby,
		 gdyby,
		 jakby,
		 jaki,
		 jakoby,
		 kto,
		 który,
		 p,
		 px,
		 pxx,
		 pz,
		 żeby
	       ],
	       T),
	register(ze(P,
		    D,
		    E,
		    Q,
		    F,
		    G,
		    H,
		    I,
		    R,
		    z(S, T),
		    U,
		    @ @ @ @0),
		 V,
		 W,
		 e4,
		 
		 [ X/fl(D, E, F, G, I, R, z(B, A))
		 | Y
		 ],
		 Z),
	ze(V,
	   W,
	   Z,
	   P,
	   D,
	   E,
	   Q,
	   F,
	   G,
	   H,
	   I,
	   R,
	   z(S, T),
	   U,
	   @ @ @ @0).

fl(V, B, X, C, D, E, K, G, S, z(H, A)) :-
	zrowne(A, [byxx, choćby, czyżby, gdyby, jakby, jakoby, żeby], O),
	wymagania(Y,
		  [],
		  B,
		  W,
		  [],
		  F,
		  N,
		  ff(Q,
		     C,
		     D,
		     R,
		     E,
		     3,
		     F,
		     J,
		     G,
		     ni,
		     z(H, P),
		     U),
		  I/fw(I, J, C, D, E, K, G, ni, z(M, L))/{zrowne(L, [np], M)}),
	resztawym(N),
	zrowne(O, P, T),
	register(ze(Q,
		    C,
		    D,
		    R,
		    E,
		    K,
		    F,
		    G,
		    S,
		    z(H, T),
		    U,
		    @ @ @ @0),
		 V,
		 W,
		 e7,
		 
		 [ X/fl(C, D, E, K, G, S, z(H, A))
		 | Y
		 ],
		 Z),
	ze(V,
	   W,
	   Z,
	   Q,
	   C,
	   D,
	   R,
	   E,
	   K,
	   F,
	   G,
	   S,
	   z(H, T),
	   U,
	   @ @ @ @0).

fl(V, B, X, C, D, E, F, H, S, z(I, A)) :-
	zrowne(A, [pz], O),
	wymagania(Y,
		  [],
		  B,
		  W,
		  [],
		  G,
		  N,
		  ff(Q,
		     C,
		     D,
		     R,
		     E,
		     F,
		     G,
		     K,
		     H,
		     ni,
		     z(I, P),
		     U),
		  J/fw(J, K, C, D, E, F, H, ni, z(M, L))/{zrowne(L, [p, np], M)}),
	resztawym(N),
	zrowne(O, P, T),
	register(ze(Q,
		    C,
		    D,
		    R,
		    E,
		    F,
		    G,
		    H,
		    S,
		    z(I, T),
		    U,
		    @ @ @ @0),
		 V,
		 W,
		 e8,
		 
		 [ X/fl(C, D, E, F, H, S, z(I, A))
		 | Y
		 ],
		 Z),
	ze(V,
	   W,
	   Z,
	   Q,
	   C,
	   D,
	   R,
	   E,
	   F,
	   G,
	   H,
	   S,
	   z(I, T),
	   U,
	   @ @ @ @0).

fl(V, B, X, C, D, E, F, H, S, z(I, A)) :-
	zrowne(A, [co, jaki, kto, który], O),
	wymagania(Y,
		  [],
		  B,
		  W,
		  [],
		  G,
		  N,
		  ff(Q,
		     C,
		     D,
		     R,
		     E,
		     F,
		     G,
		     K,
		     H,
		     ni,
		     z(I, P),
		     U),
		  J/fw(J, K, C, D, E, F, H, ni, z(M, L))/{zrowne(L, [np], M)}),
	resztawym(N),
	zrowne(O, P, T),
	register(ze(Q,
		    C,
		    D,
		    R,
		    E,
		    F,
		    G,
		    H,
		    S,
		    z(I, T),
		    U,
		    @ @ @ @0),
		 V,
		 W,
		 e11,
		 
		 [ X/fl(C, D, E, F, H, S, z(I, A))
		 | Y
		 ],
		 Z),
	ze(V,
	   W,
	   Z,
	   Q,
	   C,
	   D,
	   R,
	   E,
	   F,
	   G,
	   H,
	   S,
	   z(I, T),
	   U,
	   @ @ @ @0).

fw(W, C, Y, D, J, E, F, G, H, K, S, z(B, A)) :-
	zrowne(A, [p, np], B),
	wymagania(Z,
		  [],
		  C,
		  X,
		  [D],
		  I,
		  O,
		  ff(Q,
		     E,
		     F,
		     R,
		     G,
		     H,
		     I,
		     J,
		     K,
		     ni,
		     z(T, P),
		     V),
		  L/fw(L, J, E, F, G, H, K, ni, z(N, M))/{zrowne(M, [p, np], N)}),
	resztawym(O),
	zrowne(P, [p, px, pxx], U),
	register(ze(Q,
		    E,
		    F,
		    R,
		    G,
		    H,
		    I,
		    K,
		    S,
		    z(T, U),
		    V,
		    @ @ @ @0),
		 W,
		 X,
		 e2,
		 
		 [ Y/fw(D, J, E, F, G, H, K, S, z(B, A))
		 | Z
		 ],
		 A1),
	ze(W,
	   X,
	   A1,
	   Q,
	   E,
	   F,
	   R,
	   G,
	   H,
	   I,
	   K,
	   S,
	   z(T, U),
	   V,
	   @ @ @ @0).

fw(W, C, Y, D, J, E, F, G, H, K, S, z(B, A)) :-
	zrowne(A, [np], B),
	wymagania(Z,
		  [],
		  C,
		  X,
		  [D],
		  I,
		  O,
		  ff(Q,
		     E,
		     F,
		     R,
		     G,
		     H,
		     I,
		     J,
		     K,
		     ni,
		     z(T, P),
		     V),
		  L/fw(L, J, E, F, G, H, K, ni, z(N, M))/{zrowne(M, [np], N)}),
	resztawym(O),
	zrozne(P,
	       
	       [ byxx,
		 choćby,
		 co,
		 czyżby,
		 gdyby,
		 jakby,
		 jaki,
		 jakoby,
		 kto,
		 który,
		 p,
		 px,
		 pxx,
		 pz,
		 żeby
	       ],
	       U),
	register(ze(Q,
		    E,
		    F,
		    R,
		    G,
		    H,
		    I,
		    K,
		    S,
		    z(T, U),
		    V,
		    @ @ @ @0),
		 W,
		 X,
		 e5,
		 
		 [ Y/fw(D, J, E, F, G, H, K, S, z(B, A))
		 | Z
		 ],
		 A1),
	ze(W,
	   X,
	   A1,
	   Q,
	   E,
	   F,
	   R,
	   G,
	   H,
	   I,
	   K,
	   S,
	   z(T, U),
	   V,
	   @ @ @ @0).

fw(U, C, W, D, I, E, F, G, 3, J, ni, z(B, A)) :-
	zrowne(A, [np], B),
	wymagania(X,
		  [],
		  C,
		  V,
		  [D],
		  H,
		  N,
		  ff(P,
		     E,
		     F,
		     Q,
		     G,
		     3,
		     H,
		     I,
		     J,
		     ni,
		     z(R, O),
		     T),
		  K/fw(K, I, E, F, G, 3, J, ni, z(M, L))/{zrowne(L, [np], M)}),
	resztawym(N),
	zrowne(O, [byxx, choćby, czyżby, gdyby, jakby, jakoby, żeby], S),
	register(ze(P,
		    E,
		    F,
		    Q,
		    G,
		    3,
		    H,
		    J,
		    ni,
		    z(R, S),
		    T,
		    @ @ @ @0),
		 U,
		 V,
		 e7e1,
		 
		 [ W/fw(D, I, E, F, G, 3, J, ni, z(B, A))
		 | X
		 ],
		 Y),
	ze(U,
	   V,
	   Y,
	   P,
	   E,
	   F,
	   Q,
	   G,
	   3,
	   H,
	   J,
	   ni,
	   z(R, S),
	   T,
	   @ @ @ @0).

fw(W, C, Y, D, J, E, F, G, H, K, S, z(B, A)) :-
	zrowne(A, [pz], B),
	wymagania(Z,
		  [],
		  C,
		  X,
		  [D],
		  I,
		  O,
		  ff(Q,
		     E,
		     F,
		     R,
		     G,
		     H,
		     I,
		     J,
		     K,
		     ni,
		     z(T, P),
		     V),
		  L/fw(L, J, E, F, G, H, K, ni, z(N, M))/{zrowne(M, [p, np], N)}),
	resztawym(O),
	zrowne(P, [pz], U),
	register(ze(Q,
		    E,
		    F,
		    R,
		    G,
		    H,
		    I,
		    K,
		    S,
		    z(T, U),
		    V,
		    @ @ @ @0),
		 W,
		 X,
		 e9,
		 
		 [ Y/fw(D, J, E, F, G, H, K, S, z(B, A))
		 | Z
		 ],
		 A1),
	ze(W,
	   X,
	   A1,
	   Q,
	   E,
	   F,
	   R,
	   G,
	   H,
	   I,
	   K,
	   S,
	   z(T, U),
	   V,
	   @ @ @ @0).

fw(W, B, Y, C, I, D, E, F, G, J, T, z(K, A)) :-
	zrowne(A, [co, jaki, kto, który], P),
	wymagania(Z,
		  [],
		  B,
		  X,
		  [C],
		  H,
		  O,
		  ff(R,
		     D,
		     E,
		     S,
		     F,
		     G,
		     H,
		     I,
		     J,
		     ni,
		     z(K, Q),
		     V),
		  L/fw(L, I, D, E, F, G, J, ni, z(N, M))/{zrowne(M, [np], N)}),
	resztawym(O),
	zrowne(P, Q, U),
	register(ze(R,
		    D,
		    E,
		    S,
		    F,
		    G,
		    H,
		    J,
		    T,
		    z(K, U),
		    V,
		    @ @ @ @0),
		 W,
		 X,
		 e12,
		 
		 [ Y/fw(C, I, D, E, F, G, J, T, z(K, A))
		 | Z
		 ],
		 A1),
	ze(W,
	   X,
	   A1,
	   R,
	   D,
	   E,
	   S,
	   F,
	   G,
	   H,
	   J,
	   T,
	   z(K, U),
	   V,
	   @ @ @ @0).

fw(V, C, X, D, J, E, F, G, H, K, S, z(B, A)) :-
	zrowne(A, [p, np], B),
	wymagania(Y,
		  [],
		  C,
		  W,
		  [D],
		  I,
		  P,
		  kweneg(O,
			 E,
			 F,
			 R,
			 G,
			 H,
			 I,
			 J,
			 K,
			 ni,
			 z(T, Q)),
		  L/fw(L, J, E, F, G, H, K, ni, z(N, M))/{zrowne(M, [p, np], N)}),
	rowne(O, [bok, psu, psw]),
	resztawym(P),
	zrowne(Q, [p, px, pxx], U),
	register(fwe(O,
		     E,
		     F,
		     R,
		     G,
		     H,
		     wym(A1, P),
		     J,
		     K,
		     S,
		     z(T, U)),
		 V,
		 W,
		 we3/5/7,
		 
		 [ X/fw(D, J, E, F, G, H, K, S, z(B, A))
		 | Y
		 ],
		 Z),
	fwe(V,
	    W,
	    Z,
	    O,
	    E,
	    F,
	    R,
	    G,
	    H,
	    wym(A1, P),
	    J,
	    K,
	    S,
	    z(T, U)).

fw(V, C, X, D, J, E, F, G, H, K, S, z(B, A)) :-
	zrowne(A, [np], B),
	wymagania(Y,
		  [],
		  C,
		  W,
		  [D],
		  I,
		  P,
		  kweneg(O,
			 E,
			 F,
			 R,
			 G,
			 H,
			 I,
			 J,
			 K,
			 ni,
			 z(T, Q)),
		  L/fw(L, J, E, F, G, H, K, ni, z(N, M))/{zrowne(M, [np], N)}),
	rowne(O, [bok, psu, psw]),
	resztawym(P),
	zrozne(Q, [co, jaki, kto, który, p, px, pxx, pz], U),
	register(fwe(O,
		     E,
		     F,
		     R,
		     G,
		     H,
		     wym(A1, P),
		     J,
		     K,
		     S,
		     z(T, U)),
		 V,
		 W,
		 we9/11/13,
		 
		 [ X/fw(D, J, E, F, G, H, K, S, z(B, A))
		 | Y
		 ],
		 Z),
	fwe(V,
	    W,
	    Z,
	    O,
	    E,
	    F,
	    R,
	    G,
	    H,
	    wym(A1, P),
	    J,
	    K,
	    S,
	    z(T, U)).

fw(V, B, X, C, I, D, E, F, G, J, T, z(K, A)) :-
	zrowne(A, [pz], R),
	wymagania(Y,
		  [],
		  B,
		  W,
		  [C],
		  H,
		  P,
		  kweneg(O,
			 D,
			 E,
			 S,
			 F,
			 G,
			 H,
			 I,
			 J,
			 ni,
			 z(K, Q)),
		  L/fw(L, I, D, E, F, G, J, ni, z(N, M))/{zrowne(M, [p, np], N)}),
	rowne(O, [bok, psu, psw]),
	resztawym(P),
	zrowne(Q, R, U),
	register(fwe(O,
		     D,
		     E,
		     S,
		     F,
		     G,
		     wym(A1, P),
		     I,
		     J,
		     T,
		     z(K, U)),
		 V,
		 W,
		 we14/15/16,
		 
		 [ X/fw(C, I, D, E, F, G, J, T, z(K, A))
		 | Y
		 ],
		 Z),
	fwe(V,
	    W,
	    Z,
	    O,
	    D,
	    E,
	    S,
	    F,
	    G,
	    wym(A1, P),
	    I,
	    J,
	    T,
	    z(K, U)).

fw(V, B, X, C, I, D, E, F, G, J, T, z(K, A)) :-
	zrowne(A, [co, jaki, kto, który], R),
	wymagania(Y,
		  [],
		  B,
		  W,
		  [C],
		  H,
		  P,
		  kweneg(O,
			 D,
			 E,
			 S,
			 F,
			 G,
			 H,
			 I,
			 J,
			 ni,
			 z(K, Q)),
		  L/fw(L, I, D, E, F, G, J, ni, z(N, M))/{zrowne(M, [np], N)}),
	rowne(O, [bok, psu, psw]),
	resztawym(P),
	zrowne(Q, R, U),
	register(fwe(O,
		     D,
		     E,
		     S,
		     F,
		     G,
		     wym(A1, P),
		     I,
		     J,
		     T,
		     z(K, U)),
		 V,
		 W,
		 we17/18/19,
		 
		 [ X/fw(C, I, D, E, F, G, J, T, z(K, A))
		 | Y
		 ],
		 Z),
	fwe(V,
	    W,
	    Z,
	    O,
	    D,
	    E,
	    S,
	    F,
	    G,
	    wym(A1, P),
	    I,
	    J,
	    T,
	    z(K, U)).

ff(T, B, V, N, F, G, O, H, I, C, E, J, P, z(Q, A), S) :-
	zrowne(A, [p, px, pxx], R),
	wymagane(W,
		 [],
		 B,
		 U,
		 C,
		 M,
		 D/fw(D, E, F, G, H, I, J, ni, z(L, K))/{zrowne(K, [p, np], L)}),
	resztawym(M),
	register(ze(N,
		    F,
		    G,
		    O,
		    H,
		    I,
		    C,
		    J,
		    P,
		    z(Q, R),
		    S,
		    @ @ @ @0),
		 T,
		 U,
		 e3,
		 
		 [ V/ff(N, F, G, O, H, I, C, E, J, P, z(Q, A), S)
		 | W
		 ],
		 X),
	ze(T,
	   U,
	   X,
	   N,
	   F,
	   G,
	   O,
	   H,
	   I,
	   C,
	   J,
	   P,
	   z(Q, R),
	   S,
	   @ @ @ @0).

ff(T, B, V, N, F, G, O, H, I, C, E, J, P, z(Q, A), S) :-
	zrozne(A,
	       
	       [ byxx,
		 choćby,
		 co,
		 czyżby,
		 gdyby,
		 jakby,
		 jaki,
		 jakoby,
		 kto,
		 który,
		 p,
		 px,
		 pxx,
		 pz,
		 żeby
	       ],
	       R),
	wymagane(W,
		 [],
		 B,
		 U,
		 C,
		 M,
		 D/fw(D, E, F, G, H, I, J, ni, z(L, K))/{zrowne(K, [np], L)}),
	resztawym(M),
	register(ze(N,
		    F,
		    G,
		    O,
		    H,
		    I,
		    C,
		    J,
		    P,
		    z(Q, R),
		    S,
		    @ @ @ @0),
		 T,
		 U,
		 e6,
		 
		 [ V/ff(N, F, G, O, H, I, C, E, J, P, z(Q, A), S)
		 | W
		 ],
		 X),
	ze(T,
	   U,
	   X,
	   N,
	   F,
	   G,
	   O,
	   H,
	   I,
	   C,
	   J,
	   P,
	   z(Q, R),
	   S,
	   @ @ @ @0).

ff(R, B, T, M, F, G, N, H, 3, C, E, I, ni, z(O, A), Q) :-
	zrowne(A, [byxx, choćby, czyżby, gdyby, jakby, jakoby, żeby], P),
	wymagane(U,
		 [],
		 B,
		 S,
		 C,
		 L,
		 D/fw(D, E, F, G, H, 3, I, ni, z(K, J))/{zrowne(J, [np], K)}),
	resztawym(L),
	register(ze(M,
		    F,
		    G,
		    N,
		    H,
		    3,
		    C,
		    I,
		    ni,
		    z(O, P),
		    Q,
		    @ @ @ @0),
		 R,
		 S,
		 e7e2,
		 
		 [ T/ff(M, F, G, N, H, 3, C, E, I, ni, z(O, A), Q)
		 | U
		 ],
		 V),
	ze(R,
	   S,
	   V,
	   M,
	   F,
	   G,
	   N,
	   H,
	   3,
	   C,
	   I,
	   ni,
	   z(O, P),
	   Q,
	   @ @ @ @0).

ff(T, B, V, N, F, G, O, H, I, C, E, J, P, z(Q, A), S) :-
	zrowne(A, [pz], R),
	wymagane(W,
		 [],
		 B,
		 U,
		 C,
		 M,
		 D/fw(D, E, F, G, H, I, J, ni, z(L, K))/{zrowne(K, [p, np], L)}),
	resztawym(M),
	register(ze(N,
		    F,
		    G,
		    O,
		    H,
		    I,
		    C,
		    J,
		    P,
		    z(Q, R),
		    S,
		    @ @ @ @0),
		 T,
		 U,
		 e10,
		 
		 [ V/ff(N, F, G, O, H, I, C, E, J, P, z(Q, A), S)
		 | W
		 ],
		 X),
	ze(T,
	   U,
	   X,
	   N,
	   F,
	   G,
	   O,
	   H,
	   I,
	   C,
	   J,
	   P,
	   z(Q, R),
	   S,
	   @ @ @ @0).

pyt(M, A, O, czyżby, ni) :-
	goal(zr(D,
		E,
		F,
		G,
		H,
		I,
		J,
		K,
		z(C, B),
		Q),
	     A,
	     N,
	     P),
	zrowne(B, [czyżby], C),
	L=[p, px, pxx],
	register(ze(D,
		    E,
		    F,
		    G,
		    H,
		    I,
		    S,
		    J,
		    K,
		    z(T, L),
		    U,
		    @ @ @ @0),
		 M,
		 N,
		 e14,
		 
		 [ O/pyt(czyżby, ni),
		   A,
		   P/zr(D, E, F, G, H, I, J, K, z(C, B), Q)
		 ],
		 R),
	ze(M,
	   N,
	   R,
	   D,
	   E,
	   F,
	   G,
	   H,
	   I,
	   S,
	   J,
	   K,
	   z(T, L),
	   U,
	   @ @ @ @0).

pyt(M, A, O, czy, K) :-
	goal(zr(D,
		E,
		F,
		G,
		H,
		I,
		J,
		ni,
		z(C, B),
		Q),
	     A,
	     N,
	     P),
	zrowne(B, [npt], C),
	L=[p, px, pxx, pz],
	register(ze(D,
		    E,
		    F,
		    G,
		    H,
		    I,
		    S,
		    J,
		    K,
		    z(T, L),
		    U,
		    @ @ @ @0),
		 M,
		 N,
		 e17,
		 
		 [ O/pyt(czy, K),
		   A,
		   P/zr(D, E, F, G, H, I, J, ni, z(C, B), Q)
		 ],
		 R),
	ze(M,
	   N,
	   R,
	   D,
	   E,
	   F,
	   G,
	   H,
	   I,
	   S,
	   J,
	   K,
	   z(T, L),
	   U,
	   @ @ @ @0).

ff1(M, N, O, A, B, C, D, E, F, G, H, I, J, K, L) :-
	register(ff(A,
		    B,
		    C,
		    D,
		    E,
		    F,
		    G,
		    H,
		    I,
		    J,
		    K,
		    L),
		 M,
		 N,
		 fi1,
		 
		 [ O/ff1(A, B, C, D, E, F, G, H, I, J, K, L)
		 ],
		 P),
	ff(M,
	   N,
	   P,
	   A,
	   B,
	   C,
	   D,
	   E,
	   F,
	   G,
	   H,
	   I,
	   J,
	   K,
	   L).

ff1(R, G, T, J, B, C, K, D, E, L, M, F, N, z(O, A), Q) :-
	zrowne(A, [p, px, pxx, pz], P),
	goal(fl(B, C, D, E, F, ni, z(I, H)),
	     G,
	     S,
	     U),
	zrowne(H, [np, p], I),
	register(ff(J,
		    B,
		    C,
		    K,
		    D,
		    E,
		    L,
		    M,
		    F,
		    N,
		    z(O, P),
		    Q),
		 R,
		 S,
		 fi2,
		 
		 [ T/ff1(J, B, C, K, D, E, L, M, F, N, z(O, A), Q),
		   G,
		   U/fl(B, C, D, E, F, ni, z(I, H))
		 ],
		 V),
	ff(R,
	   S,
	   V,
	   J,
	   B,
	   C,
	   K,
	   D,
	   E,
	   L,
	   M,
	   F,
	   N,
	   z(O, P),
	   Q).

ff1(R, G, T, J, B, C, K, D, E, L, M, F, N, z(O, A), Q) :-
	zrozne(A, [p, px, pxx, pz], P),
	goal(fl(B, C, D, E, F, ni, z(I, H)),
	     G,
	     S,
	     U),
	zrowne(H, [np], I),
	register(ff(J,
		    B,
		    C,
		    K,
		    D,
		    E,
		    L,
		    M,
		    F,
		    N,
		    z(O, P),
		    Q),
		 R,
		 S,
		 fi3,
		 
		 [ T/ff1(J, B, C, K, D, E, L, M, F, N, z(O, A), Q),
		   G,
		   U/fl(B, C, D, E, F, ni, z(I, H))
		 ],
		 V),
	ff(R,
	   S,
	   V,
	   J,
	   B,
	   C,
	   K,
	   D,
	   E,
	   L,
	   M,
	   F,
	   N,
	   z(O, P),
	   Q).

kweneg(N, O, P, A, B, C, D, E, F, G, H, I, J, z(ow(K, M), L)) :-
	rowne(A, [os, bos, bok]),
	register(ff1(A,
		     B,
		     C,
		     D,
		     E,
		     F,
		     G,
		     H,
		     I,
		     J,
		     z(K, L),
		     M),
		 N,
		 O,
		 fi4,
		 
		 [ P/kweneg(A, B, C, D, E, F, G, H, I, J, z(ow(K, M), L))
		 ],
		 Q),
	ff1(N,
	    O,
	    Q,
	    A,
	    B,
	    C,
	    D,
	    E,
	    F,
	    G,
	    H,
	    I,
	    J,
	    z(K, L),
	    M).

kweneg(N, O, P, A, C, D, E, F, G, H, I, J, K, z(L, B)) :-
	rowne(A, [bok, psu, psw]),
	zrowne(B, [pz, co, jaki, kto, który], M),
	register(fwe(A,
		     C,
		     D,
		     E,
		     F,
		     G,
		     H,
		     I,
		     J,
		     K,
		     z(L, M)),
		 N,
		 O,
		 we1,
		 
		 [ P/kweneg(A, C, D, E, F, G, H, I, J, K, z(L, B))
		 ],
		 Q),
	fwe(N,
	    O,
	    Q,
	    A,
	    C,
	    D,
	    E,
	    F,
	    G,
	    H,
	    I,
	    J,
	    K,
	    z(L, M)).

kweneg(S, C, U, A, G, H, O, I, J, D, F, K, P, z(Q, B)) :-
	rowne(A, [bok, psu, psw]),
	zrowne(B, [p, px, pxx], R),
	wymagane(V,
		 [],
		 C,
		 T,
		 D,
		 N,
		 E/fw(E, F, G, H, I, J, K, ni, z(M, L))/{zrowne(L, [p, np], M)}),
	resztawym(N),
	register(fwe(A,
		     G,
		     H,
		     O,
		     I,
		     J,
		     wym(X, N),
		     F,
		     K,
		     P,
		     z(Q, R)),
		 S,
		 T,
		 we2/4/6,
		 
		 [ U/kweneg(A, G, H, O, I, J, D, F, K, P, z(Q, B))
		 | V
		 ],
		 W),
	fwe(S,
	    T,
	    W,
	    A,
	    G,
	    H,
	    O,
	    I,
	    J,
	    wym(X, N),
	    F,
	    K,
	    P,
	    z(Q, R)).

kweneg(S, C, U, A, G, H, O, I, J, D, F, K, P, z(Q, B)) :-
	rowne(A, [bok, psu, psw]),
	zrozne(B, [co, jaki, kto, który, p, px, pxx, pz], R),
	wymagane(V,
		 [],
		 C,
		 T,
		 D,
		 N,
		 E/fw(E, F, G, H, I, J, K, ni, z(M, L))/{zrowne(L, [np], M)}),
	resztawym(N),
	register(fwe(A,
		     G,
		     H,
		     O,
		     I,
		     J,
		     wym(X, N),
		     F,
		     K,
		     P,
		     z(Q, R)),
		 S,
		 T,
		 we8/10/12,
		 
		 [ U/kweneg(A, G, H, O, I, J, D, F, K, P, z(Q, B))
		 | V
		 ],
		 W),
	fwe(S,
	    T,
	    W,
	    A,
	    G,
	    H,
	    O,
	    I,
	    J,
	    wym(X, N),
	    F,
	    K,
	    P,
	    z(Q, R)).

fw1(J, K, L, A, B, C, D, E, F, G, H, I) :-
	register(fw(A,
		    B,
		    C,
		    D,
		    E,
		    F,
		    G,
		    H,
		    I),
		 J,
		 K,
		 wy1,
		 
		 [ L/fw1(A, B, C, D, E, F, G, H, I)
		 ],
		 M),
	fw(J,
	   K,
	   M,
	   A,
	   B,
	   C,
	   D,
	   E,
	   F,
	   G,
	   H,
	   I).

fw1(N, F, P, K, L, A, B, C, D, E, M, z(I, G)) :-
	goal(fl(A, B, C, D, E, ni, z(J, H)),
	     F,
	     O,
	     Q),
	zplubnp(G, H, I, J),
	register(fw(K,
		    L,
		    A,
		    B,
		    C,
		    D,
		    E,
		    M,
		    z(S, [p])),
		 N,
		 O,
		 wy2,
		 
		 [ P/fw1(K, L, A, B, C, D, E, M, z(I, G)),
		   F,
		   Q/fl(A, B, C, D, E, ni, z(J, H))
		 ],
		 R),
	fw(N,
	   O,
	   R,
	   K,
	   L,
	   A,
	   B,
	   C,
	   D,
	   E,
	   M,
	   z(S, [p])).

fw1(O, G, Q, J, K, B, C, D, E, F, L, z(M, A)) :-
	zrowne(A, [pz], N),
	goal(fl(B, C, D, E, F, ni, z(I, H)),
	     G,
	     P,
	     R),
	zrowne(H, [np, p], I),
	register(fw(J,
		    K,
		    B,
		    C,
		    D,
		    E,
		    F,
		    L,
		    z(M, N)),
		 O,
		 P,
		 wy3,
		 
		 [ Q/fw1(J, K, B, C, D, E, F, L, z(M, A)),
		   G,
		   R/fl(B, C, D, E, F, ni, z(I, H))
		 ],
		 S),
	fw(O,
	   P,
	   S,
	   J,
	   K,
	   B,
	   C,
	   D,
	   E,
	   F,
	   L,
	   z(M, N)).

fw1(O, G, Q, J, K, B, C, D, E, F, L, z(M, A)) :-
	zrozne(A, [p, pz], N),
	goal(fl(B, C, D, E, F, ni, z(I, H)),
	     G,
	     P,
	     R),
	zrowne(H, [np], I),
	register(fw(J,
		    K,
		    B,
		    C,
		    D,
		    E,
		    F,
		    L,
		    z(M, N)),
		 O,
		 P,
		 wy4,
		 
		 [ Q/fw1(J, K, B, C, D, E, F, L, z(M, A)),
		   G,
		   R/fl(B, C, D, E, F, ni, z(I, H))
		 ],
		 S),
	fw(O,
	   P,
	   S,
	   J,
	   K,
	   B,
	   C,
	   D,
	   E,
	   F,
	   L,
	   z(M, N)).

fwe(G, H, I, bok, A, C, J, K, L, wym([], M), B, D, E, F) :-
	register(fw1(infp(A),
		     B,
		     O,
		     C,
		     P,
		     Q,
		     D,
		     E,
		     F),
		 G,
		 H,
		 wy6,
		 
		 [ I/fwe(bok, A, C, J, K, L, wym([], M), B, D, E, F)
		 ],
		 N),
	fw1(G,
	    H,
	    N,
	    infp(A),
	    B,
	    O,
	    C,
	    P,
	    Q,
	    D,
	    E,
	    F).

fpm(F, G, H, A, B, C, D, E, I) :-
	register(fw1(prepnp(A, B),
		     K,
		     L,
		     M,
		     N,
		     O,
		     C,
		     D,
		     E),
		 F,
		 G,
		 wy7,
		 
		 [ H/fpm(A, B, C, D, E, I)
		 ],
		 J),
	fw1(F,
	    G,
	    J,
	    prepnp(A, B),
	    K,
	    L,
	    M,
	    N,
	    O,
	    C,
	    D,
	    E).

fpm(F, G, H, I, J, B, C, z(D, A), K) :-
	zrozne(A, [byxx, choćby, czyżby, gdyby, jakby, jakoby, żeby], E),
	register(fl1(M,
		     N,
		     O,
		     P,
		     B,
		     C,
		     z(D, E)),
		 F,
		 G,
		 lu5,
		 
		 [ H/fpm(I, J, B, C, z(D, A), K)
		 ],
		 L),
	fl1(F,
	    G,
	    L,
	    M,
	    N,
	    O,
	    P,
	    B,
	    C,
	    z(D, E)).

fpm(N, A, P, Q, R, S, L, z(E, C), F) :-
	goal(knoatr(H,
		    I,
		    J,
		    K,
		    ni,
		    z(D, B),
		    G,
		    U),
	     A,
	     O,
	     T),
	zplubnp(B, C, D, E),
	oblkl(M, F, G),
	register(knopm(H,
		       I,
		       J,
		       K,
		       L,
		       z(W, [p]),
		       M,
		       @ @ @ @ @0),
		 N,
		 O,
		 no14,
		 
		 [ P/fpm(Q, R, S, L, z(E, C), F),
		   A,
		   T/knoatr(H, I, J, K, ni, z(D, B), G, U)
		 ],
		 V),
	knopm(N,
	      O,
	      V,
	      H,
	      I,
	      J,
	      K,
	      L,
	      z(W, [p]),
	      M,
	      @ @ @ @ @0).

fpm(O, B, Q, R, S, T, K, z(L, A), E) :-
	zrowne(A, [co, jaki, kto, który, np], M),
	goal(knoatr(G,
		    H,
		    I,
		    J,
		    ni,
		    z(D, C),
		    F,
		    V),
	     B,
	     P,
	     U),
	zrowne(C, [np], D),
	oblkl(N, E, F),
	register(knopm(G,
		       H,
		       I,
		       J,
		       K,
		       z(L, M),
		       N,
		       @ @ @ @ @0),
		 O,
		 P,
		 no16,
		 
		 [ Q/fpm(R, S, T, K, z(L, A), E),
		   B,
		   U/knoatr(G, H, I, J, ni, z(D, C), F, V)
		 ],
		 W),
	knopm(O,
	      P,
	      W,
	      G,
	      H,
	      I,
	      J,
	      K,
	      z(L, M),
	      N,
	      @ @ @ @ @0).

fpm(O, B, Q, R, S, T, K, z(L, A), E) :-
	zrowne(A, [pz], M),
	goal(knoatr(G,
		    H,
		    I,
		    J,
		    ni,
		    z(D, C),
		    F,
		    V),
	     B,
	     P,
	     U),
	zrowne(C, [np, p], D),
	oblkl(N, E, F),
	register(knopm(G,
		       H,
		       I,
		       J,
		       K,
		       z(L, M),
		       N,
		       @ @ @ @ @0),
		 O,
		 P,
		 no18,
		 
		 [ Q/fpm(R, S, T, K, z(L, A), E),
		   B,
		   U/knoatr(G, H, I, J, ni, z(D, C), F, V)
		 ],
		 W),
	knopm(O,
	      P,
	      W,
	      G,
	      H,
	      I,
	      J,
	      K,
	      z(L, M),
	      N,
	      @ @ @ @ @0).

fpm(L, A, N, O, P, Q, J, B, D) :-
	goal(kptps(F,
		   G,
		   H,
		   I,
		   ni,
		   C,
		   E,
		   S),
	     A,
	     M,
	     R),
	zplubnp(B, C, _, _),
	oblkl(K, D, E),
	register(kptpm(F,
		       G,
		       H,
		       I,
		       J,
		       z(U, [p]),
		       K,
		       @ @ @ @ @0),
		 L,
		 M,
		 pt12,
		 
		 [ N/fpm(O, P, Q, J, B, D),
		   A,
		   R/kptps(F, G, H, I, ni, C, E, S)
		 ],
		 T),
	kptpm(L,
	      M,
	      T,
	      F,
	      G,
	      H,
	      I,
	      J,
	      z(U, [p]),
	      K,
	      @ @ @ @ @0).

fpm(O, B, Q, R, S, T, K, z(L, A), E) :-
	zrowne(A, [co, jaki, kto, który, np], M),
	goal(kptps(G,
		   H,
		   I,
		   J,
		   ni,
		   z(D, C),
		   F,
		   V),
	     B,
	     P,
	     U),
	zrowne(C, [np], D),
	oblkl(N, E, F),
	register(kptpm(G,
		       H,
		       I,
		       J,
		       K,
		       z(L, M),
		       N,
		       @ @ @ @ @0),
		 O,
		 P,
		 pt14,
		 
		 [ Q/fpm(R, S, T, K, z(L, A), E),
		   B,
		   U/kptps(G, H, I, J, ni, z(D, C), F, V)
		 ],
		 W),
	kptpm(O,
	      P,
	      W,
	      G,
	      H,
	      I,
	      J,
	      K,
	      z(L, M),
	      N,
	      @ @ @ @ @0).

fpm(N, B, P, Q, R, S, J, z(K, A), D) :-
	zrowne(A, [pz], L),
	goal(kptps(F,
		   G,
		   H,
		   I,
		   ni,
		   z(C, U),
		   E,
		   V),
	     B,
	     O,
	     T),
	zrowne(A, [np, p], C),
	oblkl(M, D, E),
	register(kptpm(F,
		       G,
		       H,
		       I,
		       J,
		       z(K, L),
		       M,
		       @ @ @ @ @0),
		 N,
		 O,
		 pt16,
		 
		 [ P/fpm(Q, R, S, J, z(K, A), D),
		   B,
		   T/kptps(F, G, H, I, ni, z(C, U), E, V)
		 ],
		 W),
	kptpm(N,
	      O,
	      W,
	      F,
	      G,
	      H,
	      I,
	      J,
	      z(K, L),
	      M,
	      @ @ @ @ @0).

fpm(L, A, N, O, P, Q, J, z(D, B), F) :-
	goal(kpsps(H, I, ni, z(E, C), G, S),
	     A,
	     M,
	     R),
	zplubnp(B, C, D, E),
	oblkl(K, F, G),
	register(kpspm(H,
		       I,
		       J,
		       z(U, [p]),
		       K,
		       @ @ @ @0),
		 L,
		 M,
		 ps5,
		 
		 [ N/fpm(O, P, Q, J, z(D, B), F),
		   A,
		   R/kpsps(H, I, ni, z(E, C), G, S)
		 ],
		 T),
	kpspm(L,
	      M,
	      T,
	      H,
	      I,
	      J,
	      z(U, [p]),
	      K,
	      @ @ @ @0).

fpm(M, B, O, P, Q, R, I, z(J, A), E) :-
	zrozne(A, [co, jaki, kto, który, np], K),
	goal(kpsps(G, H, ni, z(D, C), F, T),
	     B,
	     N,
	     S),
	zrowne(C, [np], D),
	oblkl(L, E, F),
	register(kpspm(G,
		       H,
		       I,
		       z(J, K),
		       L,
		       @ @ @ @0),
		 M,
		 N,
		 ps7,
		 
		 [ O/fpm(P, Q, R, I, z(J, A), E),
		   B,
		   S/kpsps(G, H, ni, z(D, C), F, T)
		 ],
		 U),
	kpspm(M,
	      N,
	      U,
	      G,
	      H,
	      I,
	      z(J, K),
	      L,
	      @ @ @ @0).

fpm(M, B, O, P, Q, R, I, z(J, A), E) :-
	zrowne(A, [pz], K),
	goal(kpsps(G, H, ni, z(D, C), F, T),
	     B,
	     N,
	     S),
	zrowne(C, [np, p], D),
	oblkl(L, E, F),
	register(kpspm(G,
		       H,
		       I,
		       z(J, K),
		       L,
		       @ @ @ @0),
		 M,
		 N,
		 ps9,
		 
		 [ O/fpm(P, Q, R, I, z(J, A), E),
		   B,
		   S/kpsps(G, H, ni, z(D, C), F, T)
		 ],
		 U),
	kpspm(M,
	      N,
	      U,
	      G,
	      H,
	      I,
	      z(J, K),
	      L,
	      @ @ @ @0).

fno(F, G, H, mian, A, B, C, D, E, I, J) :-
	register(fw1(subj,
		     L,
		     M,
		     N,
		     A,
		     B,
		     C,
		     D,
		     E),
		 F,
		 G,
		 wy8,
		 
		 [ H/fno(mian, A, B, C, D, E, I, J)
		 ],
		 K),
	fw1(F,
	    G,
	    K,
	    subj,
	    L,
	    M,
	    N,
	    A,
	    B,
	    C,
	    D,
	    E).

fno(D, E, F, dop, G, H, nie(A), B, C, I, J) :-
	register(fw1(np(bier),
		     L,
		     M,
		     N,
		     O,
		     P,
		     nie(A),
		     B,
		     C),
		 D,
		 E,
		 wy9,
		 
		 [ F/fno(dop, G, H, nie(A), B, C, I, J)
		 ],
		 K),
	fw1(D,
	    E,
	    K,
	    np(bier),
	    L,
	    M,
	    N,
	    O,
	    P,
	    nie(A),
	    B,
	    C).

fno(C, D, E, bier, F, G, tak, A, B, H, I) :-
	register(fw1(np(bier),
		     K,
		     L,
		     M,
		     N,
		     O,
		     tak,
		     A,
		     B),
		 C,
		 D,
		 wy10,
		 
		 [ E/fno(bier, F, G, tak, A, B, H, I)
		 ],
		 J),
	fw1(C,
	    D,
	    J,
	    np(bier),
	    K,
	    L,
	    M,
	    N,
	    O,
	    tak,
	    A,
	    B).

fno(E, F, G, A, H, I, B, C, D, J, K) :-
	rozne(A, [mian, bier, miej, wol]),
	register(fw1(np(A),
		     M,
		     N,
		     O,
		     P,
		     Q,
		     B,
		     C,
		     D),
		 E,
		 F,
		 wy11,
		 
		 [ G/fno(A, H, I, B, C, D, J, K)
		 ],
		 L),
	fw1(E,
	    F,
	    L,
	    np(A),
	    M,
	    N,
	    O,
	    P,
	    Q,
	    B,
	    C,
	    D).

fno(G, H, I, A, J, K, C, D, z(E, B), L, M) :-
	rozne(A, [mian, miej, wol]),
	zrozne(B, [byxx, choćby, czyżby, gdyby, jakby, jakoby, żeby], F),
	register(fl1(O,
		     P,
		     Q,
		     R,
		     C,
		     D,
		     z(E, F)),
		 G,
		 H,
		 lu6,
		 
		 [ I/fno(A, J, K, C, D, z(E, B), L, M)
		 ],
		 N),
	fl1(G,
	    H,
	    N,
	    O,
	    P,
	    Q,
	    R,
	    C,
	    D,
	    z(E, F)).

fno(N, B, P, dop, Q, 3, R, L, z(F, D), A, S) :-
	rozne(A, kto),
	goal(knopm(H,
		   I,
		   J,
		   K,
		   ni,
		   z(E, C),
		   G,
		   U),
	     B,
	     O,
	     T),
	zplubnp(C, D, E, F),
	rozne(G, os),
	oblkl(M, A, G),
	register(knodop(H,
			I,
			J,
			K,
			L,
			z(W, [p]),
			M,
			@ @ @ @ @0),
		 N,
		 O,
		 no7,
		 
		 [ P/fno(dop, Q, 3, R, L, z(F, D), A, S),
		   B,
		   T/knopm(H, I, J, K, ni, z(E, C), G, U)
		 ],
		 V),
	knodop(N,
	       O,
	       V,
	       H,
	       I,
	       J,
	       K,
	       L,
	       z(W, [p]),
	       M,
	       @ @ @ @ @0).

fno(O, C, Q, dop, R, 3, S, K, z(L, A), B, T) :-
	zrowne(A, [co, jaki, który, np], M),
	rozne(B, kto),
	goal(knopm(G,
		   H,
		   I,
		   J,
		   ni,
		   z(E, D),
		   F,
		   V),
	     C,
	     P,
	     U),
	zrowne(D, [np], E),
	rozne(F, os),
	oblkl(N, B, F),
	register(knodop(G,
			H,
			I,
			J,
			K,
			z(L, M),
			N,
			@ @ @ @ @0),
		 O,
		 P,
		 no9,
		 
		 [ Q/fno(dop, R, 3, S, K, z(L, A), B, T),
		   C,
		   U/knopm(G, H, I, J, ni, z(E, D), F, V)
		 ],
		 W),
	knodop(O,
	       P,
	       W,
	       G,
	       H,
	       I,
	       J,
	       K,
	       z(L, M),
	       N,
	       @ @ @ @ @0).

fno(O, C, Q, dop, R, 3, S, K, z(L, B), A, T) :-
	rozne(A, kto),
	zrowne(B, [pz], M),
	goal(knopm(G,
		   H,
		   I,
		   J,
		   ni,
		   z(E, D),
		   F,
		   V),
	     C,
	     P,
	     U),
	zrowne(D, [np, p], E),
	rozne(F, os),
	oblkl(N, A, F),
	register(knodop(G,
			H,
			I,
			J,
			K,
			z(L, M),
			N,
			@ @ @ @ @0),
		 O,
		 P,
		 no11,
		 
		 [ Q/fno(dop, R, 3, S, K, z(L, B), A, T),
		   C,
		   U/knopm(G, H, I, J, ni, z(E, D), F, V)
		 ],
		 W),
	knodop(O,
	       P,
	       W,
	       G,
	       H,
	       I,
	       J,
	       K,
	       z(L, M),
	       N,
	       @ @ @ @ @0).

fno(H, I, J, A, B, C, D, ni, E, F, @G) :-
	register(knom(A, B, C, D, E, F, G),
		 H,
		 I,
		 no48,
		 
		 [ J/fno(A, B, C, D, ni, E, F, @G)
		 ],
		 K),
	knom(H,
	     I,
	     K,
	     A,
	     B,
	     C,
	     D,
	     E,
	     F,
	     G).

fno(N, A, P, Q, R, S, T, L, z(D, B), F, U) :-
	goal(kptpm(H,
		   I,
		   J,
		   K,
		   ni,
		   z(E, C),
		   G,
		   W),
	     A,
	     O,
	     V),
	zplubnp(B, C, D, E),
	oblkl(M, F, G),
	register(kptno(H,
		       I,
		       J,
		       K,
		       L,
		       z(Y, [p]),
		       M,
		       @ @ @ @ @0),
		 N,
		 O,
		 pt5,
		 
		 [ P/fno(Q, R, S, T, L, z(D, B), F, U),
		   A,
		   V/kptpm(H, I, J, K, ni, z(E, C), G, W)
		 ],
		 X),
	kptno(N,
	      O,
	      X,
	      H,
	      I,
	      J,
	      K,
	      L,
	      z(Y, [p]),
	      M,
	      @ @ @ @ @0).

fno(O, B, Q, R, S, T, U, K, z(L, A), E, V) :-
	zrowne(A, [co, jaki, kto, który, np], M),
	goal(kptpm(G,
		   H,
		   I,
		   J,
		   ni,
		   z(D, C),
		   F,
		   X),
	     B,
	     P,
	     W),
	zrowne(C, [np], D),
	oblkl(N, E, F),
	register(kptno(G,
		       H,
		       I,
		       J,
		       K,
		       z(L, M),
		       N,
		       @ @ @ @ @0),
		 O,
		 P,
		 pt7,
		 
		 [ Q/fno(R, S, T, U, K, z(L, A), E, V),
		   B,
		   W/kptpm(G, H, I, J, ni, z(D, C), F, X)
		 ],
		 Y),
	kptno(O,
	      P,
	      Y,
	      G,
	      H,
	      I,
	      J,
	      K,
	      z(L, M),
	      N,
	      @ @ @ @ @0).

fno(O, B, Q, R, S, T, U, K, z(L, A), E, V) :-
	zrowne(A, [pz], M),
	goal(kptpm(G,
		   H,
		   I,
		   J,
		   ni,
		   z(D, C),
		   F,
		   X),
	     B,
	     P,
	     W),
	zrowne(C, [np, p], D),
	oblkl(N, E, F),
	register(kptno(G,
		       H,
		       I,
		       J,
		       K,
		       z(L, M),
		       N,
		       @ @ @ @ @0),
		 O,
		 P,
		 pt9,
		 
		 [ Q/fno(R, S, T, U, K, z(L, A), E, V),
		   B,
		   W/kptpm(G, H, I, J, ni, z(D, C), F, X)
		 ],
		 Y),
	kptno(O,
	      P,
	      Y,
	      G,
	      H,
	      I,
	      J,
	      K,
	      z(L, M),
	      N,
	      @ @ @ @ @0).

terminal(A, B, C, morf(D, się, qub)) :-
	register(fw1(sie,
		     F,
		     G,
		     H,
		     I,
		     J,
		     K,
		     ni,
		     z(L, [np])),
		 A,
		 B,
		 wy20,
		 [C/terminal(morf(D, się, qub))],
		 E),
	fw1(A,
	    B,
	    E,
	    sie,
	    F,
	    G,
	    H,
	    I,
	    J,
	    K,
	    ni,
	    z(L, [np])).

terminal(A, B, C, morf(D, się, qub)) :-
	register(fw1(subj,
		     F,
		     G,
		     H,
		     r(mn(n), nmo(np(n)))/poj,
		     3,
		     I,
		     ni,
		     z(J, [np])),
		 A,
		 B,
		 wy21,
		 [C/terminal(morf(D, się, qub))],
		 E),
	fw1(A,
	    B,
	    E,
	    subj,
	    F,
	    G,
	    H,
	    r(mn(n), nmo(np(n)))/poj,
	    3,
	    I,
	    ni,
	    z(J, [np])).

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

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

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

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(np),
		 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, np).

terminal(A, B, C, morf('', '', przecsp)) :-
	register(przecsp,
		 A,
		 B,
		 int5,
		 [C/terminal(morf('', '', przecsp))],
		 D),
	przecsp(A, B, D).

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

terminal(F, G, H, morf(C, być, aglt:A:B:I:J)) :-
	liczba(A, D),
	osoba(B, E),
	register(morfagl(C, L/D, E),
		 F,
		 G,
		 jel1,
		 
		 [ H/terminal(morf(C, być, aglt:A:B:I:J))
		 ],
		 K),
	morfagl(F, G, K, C, L/D, E).

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

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

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

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

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

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

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

terminal(B, C, D, morf(E, A, conj)) :-
	register(spojnik(A),
		 B,
		 C,
		 jel4,
		 [D/terminal(morf(E, A, conj))],
		 F),
	spojnik(B, C, F, A).

terminal(B, C, D, morf(E, A, comp)) :-
	register(spojnik(A),
		 B,
		 C,
		 jel4a,
		 [D/terminal(morf(E, A, comp))],
		 F),
	spojnik(B, C, F, A).

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),
		 H,
		 I,
		 jel5,
		 
		 [ J/terminal(morf(K, D, psubst:A:B:C))
		 ],
		 L),
	zaimrzecz(H, I, L, D, E, F/G).

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),
		 H,
		 I,
		 jel6,
		 
		 [ J/terminal(morf(K, D, padj:A:B:C:pos))
		 ],
		 L),
	zaimprzym(H, I, L, D, E, F/G).

terminal(B, C, D, morf(E, A, padv)) :-
	register(zaimprzys(A),
		 B,
		 C,
		 jel7,
		 [D/terminal(morf(E, A, padv))],
		 F),
	zaimprzys(B, C, F, A).

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

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

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

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

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

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

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

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

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

terminal(C, D, E, morf(F, G, adv:A)) :-
	stopien(A, B),
	register(formaprzysl(B),
		 C,
		 D,
		 n_ps,
		 [E/terminal(morf(F, G, adv:A))],
		 H),
	formaprzysl(C, D, H, B).

terminal(A, B, C, morf(D, E, advndm)) :-
	register(formaprzysl(row),
		 A,
		 B,
		 n_ps2,
		 [C/terminal(morf(D, E, advndm))],
		 F),
	formaprzysl(A, B, F, row).

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

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

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

terminal(J, A, L, morf(M, się, qub)) :-
	goal(formaczas1(s,
			B,
			C,
			D,
			E,
			F,
			G,
			H,
			I),
	     A,
	     K,
	     N),
	register(formaczas(B,
			   C,
			   D,
			   E,
			   F,
			   G,
			   H,
			   I),
		 J,
		 K,
		 n_cz3,
		 
		 [ L/terminal(morf(M, się, qub)),
		   A,
		   N/formaczas1(s, B, C, D, E, F, G, H, I)
		 ],
		 O),
	formaczas(J,
		  K,
		  O,
		  B,
		  C,
		  D,
		  E,
		  F,
		  G,
		  H,
		  I).

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

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

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

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

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

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, P),
	     E,
	     J,
	     O),
	register(formaczas1(n,
			    os,
			    nd,
			    przy,
			    ozn,
			    F/D,
			    G,
			    H,
			    R),
		 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, P)
		 ],
		 Q),
	formaczas1(I,
		   J,
		   Q,
		   n,
		   os,
		   nd,
		   przy,
		   ozn,
		   F/D,
		   G,
		   H,
		   R).

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

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

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

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),
		 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).

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

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

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

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

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

terminal(G, H, I, morf(J, B, imps:A)) :-
	aspekt(A, E),
	rekcja(B, D, C),
	wykluczpodmiot(C, F),
	register(formaczas1(D,
			    bos,
			    E,
			    prze,
			    ozn,
			    L,
			    M,
			    F,
			    N),
		 G,
		 H,
		 n_cz19,
		 [I/terminal(morf(J, B, imps:A))],
		 K),
	formaczas1(G,
		   H,
		   K,
		   D,
		   bos,
		   E,
		   prze,
		   ozn,
		   L,
		   M,
		   F,
		   N).

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

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

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(D, s, E),
	wykluczpodmiot(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),
	rekcja(D, s, E),
	wykluczpodmiot(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(G, H, I, morf(J, B, inf:A)) :-
	aspekt(A, E),
	rekcja(B, D, C),
	wykluczpodmiot(C, F),
	register(formaczas1(D,
			    bok,
			    E,
			    L,
			    M,
			    N,
			    O,
			    F,
			    P),
		 G,
		 H,
		 n_cz24,
		 [I/terminal(morf(J, B, inf:A))],
		 K),
	formaczas1(G,
		   H,
		   K,
		   D,
		   bok,
		   E,
		   L,
		   M,
		   N,
		   O,
		   F,
		   P).

terminal(G, H, I, morf(J, B, pant:A)) :-
	aspekt(A, E),
	rekcja(B, D, C),
	wykluczpodmiot(C, F),
	register(formaczas1(D,
			    psu,
			    E,
			    L,
			    M,
			    N,
			    O,
			    F,
			    P),
		 G,
		 H,
		 n_cz25,
		 [I/terminal(morf(J, B, pant:A))],
		 K),
	formaczas1(G,
		   H,
		   K,
		   D,
		   psu,
		   E,
		   L,
		   M,
		   N,
		   O,
		   F,
		   P).

terminal(G, H, I, morf(J, B, pcon:A)) :-
	aspekt(A, E),
	rekcja(B, D, C),
	wykluczpodmiot(C, F),
	register(formaczas1(D,
			    psw,
			    E,
			    L,
			    M,
			    N,
			    O,
			    F,
			    P),
		 G,
		 H,
		 n_cz26,
		 [I/terminal(morf(J, B, pcon:A))],
		 K),
	formaczas1(G,
		   H,
		   K,
		   D,
		   psw,
		   E,
		   L,
		   M,
		   N,
		   O,
		   F,
		   P).

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

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

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

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

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

terminal(E, A, G, morf(H, B, pred)) :-
	goal(terminal(morf(J, by, qub)), A, F, I),
	rekcja(B, C, D),
	register(formaczas1(C,
			    os,
			    nd,
			    L,
			    war,
			    M,
			    N,
			    D,
			    O),
		 E,
		 F,
		 n_cz32,
		 
		 [ G/terminal(morf(H, B, pred)),
		   A,
		   I/terminal(morf(J, by, qub))
		 ],
		 K),
	formaczas1(E,
		   F,
		   K,
		   C,
		   os,
		   nd,
		   L,
		   war,
		   M,
		   N,
		   D,
		   O).

terminal(E, A, G, morf(H, by, qub)) :-
	goal(terminal(morf(J, B, pred)), A, F, I),
	rekcja(B, C, D),
	register(formaczas1(C,
			    os,
			    nd,
			    L,
			    war,
			    M,
			    N,
			    D,
			    O),
		 E,
		 F,
		 n_cz33,
		 
		 [ G/terminal(morf(H, by, qub)),
		   A,
		   I/terminal(morf(J, B, pred))
		 ],
		 K),
	formaczas1(E,
		   F,
		   K,
		   C,
		   os,
		   nd,
		   L,
		   war,
		   M,
		   N,
		   D,
		   O).

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

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

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

fpt(E, F, G, mian, A, H, B, C, D, I, J) :-
	register(fw1(adjp(mian),
		     L,
		     M,
		     N,
		     A,
		     O,
		     B,
		     C,
		     D),
		 E,
		 F,
		 wy12,
		 
		 [ G/fpt(mian, A, H, B, C, D, I, J)
		 ],
		 K),
	fw1(E,
	    F,
	    K,
	    adjp(mian),
	    L,
	    M,
	    N,
	    A,
	    O,
	    B,
	    C,
	    D).

fpt(E, F, G, dop, A, H, nie(B), C, D, I, J) :-
	register(fw1(adjp(bier),
		     L,
		     M,
		     N,
		     A,
		     O,
		     nie(B),
		     C,
		     D),
		 E,
		 F,
		 wy13,
		 
		 [ G/fpt(dop, A, H, nie(B), C, D, I, J)
		 ],
		 K),
	fw1(E,
	    F,
	    K,
	    adjp(bier),
	    L,
	    M,
	    N,
	    A,
	    O,
	    nie(B),
	    C,
	    D).

fpt(D, E, F, bier, A, G, tak, B, C, H, I) :-
	register(fw1(adjp(bier),
		     K,
		     L,
		     M,
		     A,
		     N,
		     tak,
		     B,
		     C),
		 D,
		 E,
		 wy14,
		 
		 [ F/fpt(bier, A, G, tak, B, C, H, I)
		 ],
		 J),
	fw1(D,
	    E,
	    J,
	    adjp(bier),
	    K,
	    L,
	    M,
	    A,
	    N,
	    tak,
	    B,
	    C).

fpt(E, F, G, narz, A, H, B, C, D, I, J) :-
	register(fw1(adjp(narz),
		     L,
		     M,
		     N,
		     A,
		     O,
		     B,
		     C,
		     D),
		 E,
		 F,
		 wy15,
		 
		 [ G/fpt(narz, A, H, B, C, D, I, J)
		 ],
		 K),
	fw1(E,
	    F,
	    K,
	    adjp(narz),
	    L,
	    M,
	    N,
	    A,
	    O,
	    B,
	    C,
	    D).

fpt(N, C, P, A, B, Q, R, L, z(G, E), I, S) :-
	goal(knoink(A,
		    B,
		    J,
		    K,
		    ni,
		    z(F, D),
		    H,
		    U),
	     C,
	     O,
	     T),
	zplubnp(D, E, F, G),
	rozne(H, co),
	oblkl(M, I, H),
	register(knoatr(A,
			B,
			J,
			K,
			L,
			z(W, [p]),
			M,
			@ @ @ @ @0),
		 N,
		 O,
		 no23,
		 
		 [ P/fpt(A, B, Q, R, L, z(G, E), I, S),
		   C,
		   T/knoink(A, B, J, K, ni, z(F, D), H, U)
		 ],
		 V),
	knoatr(N,
	       O,
	       V,
	       A,
	       B,
	       J,
	       K,
	       L,
	       z(W, [p]),
	       M,
	       @ @ @ @ @0).

fpt(M, B, O, dop, A, P, Q, K, z(G, E), H, R) :-
	goal(knoink(C,
		    A,
		    I,
		    J,
		    ni,
		    z(F, D),
		    co,
		    T),
	     B,
	     N,
	     S),
	rowne(C, [mian, bier]),
	zplubnp(D, E, F, G),
	oblkl(L, H, _),
	register(knoatr(C,
			A,
			I,
			J,
			K,
			z(V, [p]),
			L,
			@ @ @ @ @0),
		 M,
		 N,
		 no24,
		 
		 [ O/fpt(dop, A, P, Q, K, z(G, E), H, R),
		   B,
		   S/knoink(C, A, I, J, ni, z(F, D), co, T)
		 ],
		 U),
	knoatr(M,
	       N,
	       U,
	       C,
	       A,
	       I,
	       J,
	       K,
	       z(V, [p]),
	       L,
	       @ @ @ @ @0).

fpt(M, C, O, A, B, P, Q, K, z(G, E), H, R) :-
	goal(knoink(A,
		    B,
		    I,
		    J,
		    ni,
		    z(F, D),
		    co,
		    T),
	     C,
	     N,
	     S),
	rozne(A, [mian, bier]),
	zplubnp(D, E, F, G),
	oblkl(L, H, _),
	register(knoatr(A,
			B,
			I,
			J,
			K,
			z(V, [p]),
			L,
			@ @ @ @ @0),
		 M,
		 N,
		 no25,
		 
		 [ O/fpt(A, B, P, Q, K, z(G, E), H, R),
		   C,
		   S/knoink(A, B, I, J, ni, z(F, D), co, T)
		 ],
		 U),
	knoatr(M,
	       N,
	       U,
	       A,
	       B,
	       I,
	       J,
	       K,
	       z(V, [p]),
	       L,
	       @ @ @ @ @0).

fpt(O, D, Q, B, C, R, S, K, z(L, A), H, T) :-
	zrowne(A, [co, jaki, kto, który, np], M),
	goal(knoink(B,
		    C,
		    I,
		    J,
		    ni,
		    z(F, E),
		    G,
		    V),
	     D,
	     P,
	     U),
	zrowne(E, [np], F),
	rozne(G, [co, os, wz]),
	oblkl(N, H, G),
	register(knoatr(B,
			C,
			I,
			J,
			K,
			z(L, M),
			N,
			@ @ @ @ @0),
		 O,
		 P,
		 no27,
		 
		 [ Q/fpt(B, C, R, S, K, z(L, A), H, T),
		   D,
		   U/knoink(B, C, I, J, ni, z(F, E), G, V)
		 ],
		 W),
	knoatr(O,
	       P,
	       W,
	       B,
	       C,
	       I,
	       J,
	       K,
	       z(L, M),
	       N,
	       @ @ @ @ @0).

fpt(N, D, P, dop, C, Q, R, J, z(B, A), G, S) :-
	zrowne(A, [np], B),
	goal(knoink(E,
		    C,
		    H,
		    I,
		    ni,
		    z(K, F),
		    co,
		    U),
	     D,
	     O,
	     T),
	rowne(E, [mian, bier]),
	zrowne(F, [np], L),
	oblkl(M, G, _),
	register(knoatr(E,
			C,
			H,
			I,
			J,
			z(K, L),
			M,
			@ @ @ @ @0),
		 N,
		 O,
		 no30,
		 
		 [ P/fpt(dop, C, Q, R, J, z(B, A), G, S),
		   D,
		   T/knoink(E, C, H, I, ni, z(K, F), co, U)
		 ],
		 V),
	knoatr(N,
	       O,
	       V,
	       E,
	       C,
	       H,
	       I,
	       J,
	       z(K, L),
	       M,
	       @ @ @ @ @0).

fpt(N, E, P, A, D, Q, R, J, z(C, B), G, S) :-
	rozne(A, [mian, bier]),
	zrowne(B, [np], C),
	goal(knoink(A,
		    D,
		    H,
		    I,
		    ni,
		    z(K, F),
		    co,
		    U),
	     E,
	     O,
	     T),
	zrowne(F, [np], L),
	oblkl(M, G, _),
	register(knoatr(A,
			D,
			H,
			I,
			J,
			z(K, L),
			M,
			@ @ @ @ @0),
		 N,
		 O,
		 no31,
		 
		 [ P/fpt(A, D, Q, R, J, z(C, B), G, S),
		   E,
		   T/knoink(A, D, H, I, ni, z(K, F), co, U)
		 ],
		 V),
	knoatr(N,
	       O,
	       V,
	       A,
	       D,
	       H,
	       I,
	       J,
	       z(K, L),
	       M,
	       @ @ @ @ @0).

fpt(O, D, Q, B, C, R, S, K, z(L, A), H, T) :-
	zrowne(A, [pz], M),
	goal(knoink(B,
		    C,
		    I,
		    J,
		    ni,
		    z(G, F),
		    E,
		    V),
	     D,
	     P,
	     U),
	rozne(E, co),
	zrowne(F, [np, p], G),
	oblkl(N, H, E),
	register(knoatr(B,
			C,
			I,
			J,
			K,
			z(L, M),
			N,
			@ @ @ @ @0),
		 O,
		 P,
		 no35,
		 
		 [ Q/fpt(B, C, R, S, K, z(L, A), H, T),
		   D,
		   U/knoink(B, C, I, J, ni, z(G, F), E, V)
		 ],
		 W),
	knoatr(O,
	       P,
	       W,
	       B,
	       C,
	       I,
	       J,
	       K,
	       z(L, M),
	       N,
	       @ @ @ @ @0).

fpt(N, C, P, dop, B, Q, R, J, z(K, A), G, S) :-
	zrowne(A, [pz], L),
	goal(knoink(D,
		    B,
		    H,
		    I,
		    ni,
		    z(F, E),
		    co,
		    U),
	     C,
	     O,
	     T),
	rowne(D, [mian, bier]),
	zrowne(E, [np, p], F),
	oblkl(M, G, _),
	register(knoatr(D,
			B,
			H,
			I,
			J,
			z(K, L),
			M,
			@ @ @ @ @0),
		 N,
		 O,
		 no36,
		 
		 [ P/fpt(dop, B, Q, R, J, z(K, A), G, S),
		   C,
		   T/knoink(D, B, H, I, ni, z(F, E), co, U)
		 ],
		 V),
	knoatr(N,
	       O,
	       V,
	       D,
	       B,
	       H,
	       I,
	       J,
	       z(K, L),
	       M,
	       @ @ @ @ @0).

fpt(N, D, P, B, C, Q, R, J, z(K, A), G, S) :-
	zrowne(A, [pz], L),
	rozne(B, [mian, bier]),
	goal(knoink(B,
		    C,
		    H,
		    I,
		    ni,
		    z(F, E),
		    co,
		    U),
	     D,
	     O,
	     T),
	zrowne(E, [np, p], F),
	oblkl(M, G, _),
	register(knoatr(B,
			C,
			H,
			I,
			J,
			z(K, L),
			M,
			@ @ @ @ @0),
		 N,
		 O,
		 no37,
		 
		 [ P/fpt(B, C, Q, R, J, z(K, A), G, S),
		   D,
		   T/knoink(B, C, H, I, ni, z(F, E), co, U)
		 ],
		 V),
	knoatr(N,
	       O,
	       V,
	       B,
	       C,
	       H,
	       I,
	       J,
	       z(K, L),
	       M,
	       @ @ @ @ @0).

fpt(H, I, J, A, B, C, D, ni, E, F, @G) :-
	register(kprzym(A,
			B,
			C,
			D,
			E,
			F,
			G),
		 H,
		 I,
		 pt32,
		 
		 [ J/fpt(A, B, C, D, ni, E, F, @G)
		 ],
		 K),
	kprzym(H,
	       I,
	       K,
	       A,
	       B,
	       C,
	       D,
	       E,
	       F,
	       G).

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

fps(F, G, H, I, B, C, z(D, A), J, K) :-
	zrozne(A, [byxx, choćby, czyżby, gdyby, jakby, jakoby, żeby], E),
	register(fl1(M,
		     N,
		     O,
		     P,
		     B,
		     C,
		     z(D, E)),
		 F,
		 G,
		 lu7,
		 
		 [ H/fps(I, B, C, z(D, A), J, K)
		 ],
		 L),
	fl1(F,
	    G,
	    L,
	    M,
	    N,
	    O,
	    P,
	    B,
	    C,
	    z(D, E)).

fps(L, A, N, O, P, J, B, D, Q) :-
	goal(kptink(F,
		    G,
		    H,
		    I,
		    ni,
		    C,
		    E,
		    S),
	     A,
	     M,
	     R),
	zplubnp(B, C, _, _),
	oblkl(K, D, E),
	register(kptps(F,
		       G,
		       H,
		       I,
		       J,
		       z(U, [p]),
		       K,
		       @ @ @ @ @0),
		 L,
		 M,
		 pt19,
		 
		 [ N/fps(O, P, J, B, D, Q),
		   A,
		   R/kptink(F, G, H, I, ni, C, E, S)
		 ],
		 T),
	kptps(L,
	      M,
	      T,
	      F,
	      G,
	      H,
	      I,
	      J,
	      z(U, [p]),
	      K,
	      @ @ @ @ @0).

fps(O, B, Q, R, S, K, z(L, A), E, T) :-
	zrowne(A, [co, jaki, kto, który, np], M),
	goal(kptink(G,
		    H,
		    I,
		    J,
		    ni,
		    z(D, C),
		    F,
		    V),
	     B,
	     P,
	     U),
	zrowne(C, [np], D),
	oblkl(N, E, F),
	register(kptps(G,
		       H,
		       I,
		       J,
		       K,
		       z(L, M),
		       N,
		       @ @ @ @ @0),
		 O,
		 P,
		 pt21,
		 
		 [ Q/fps(R, S, K, z(L, A), E, T),
		   B,
		   U/kptink(G, H, I, J, ni, z(D, C), F, V)
		 ],
		 W),
	kptps(O,
	      P,
	      W,
	      G,
	      H,
	      I,
	      J,
	      K,
	      z(L, M),
	      N,
	      @ @ @ @ @0).

fps(O, B, Q, R, S, K, z(L, A), E, T) :-
	zrowne(A, [pz], M),
	goal(kptink(G,
		    H,
		    I,
		    J,
		    ni,
		    z(D, C),
		    F,
		    V),
	     B,
	     P,
	     U),
	zrowne(C, [np], D),
	oblkl(N, E, F),
	register(kptps(G,
		       H,
		       I,
		       J,
		       K,
		       z(L, M),
		       N,
		       @ @ @ @ @0),
		 O,
		 P,
		 pt23,
		 
		 [ Q/fps(R, S, K, z(L, A), E, T),
		   B,
		   U/kptink(G, H, I, J, ni, z(D, C), F, V)
		 ],
		 W),
	kptps(O,
	      P,
	      W,
	      G,
	      H,
	      I,
	      J,
	      K,
	      z(L, M),
	      N,
	      @ @ @ @ @0).

fps(L, A, N, O, P, J, z(D, B), F, Q) :-
	goal(kpsink(H, I, ni, z(E, C), G, S),
	     A,
	     M,
	     R),
	zplubnp(B, C, D, E),
	oblkl(K, F, G),
	register(kpsps(H,
		       I,
		       J,
		       z(U, [p]),
		       K,
		       @ @ @ @0),
		 L,
		 M,
		 ps12,
		 
		 [ N/fps(O, P, J, z(D, B), F, Q),
		   A,
		   R/kpsink(H, I, ni, z(E, C), G, S)
		 ],
		 T),
	kpsps(L,
	      M,
	      T,
	      H,
	      I,
	      J,
	      z(U, [p]),
	      K,
	      @ @ @ @0).

fps(M, B, O, P, Q, I, z(J, A), E, R) :-
	zrowne(A, [co, jaki, kto, który, np], K),
	goal(kpsink(G, H, ni, z(D, C), F, T),
	     B,
	     N,
	     S),
	zrowne(C, [np], D),
	oblkl(L, E, F),
	register(kpsps(G,
		       H,
		       I,
		       z(J, K),
		       L,
		       @ @ @ @0),
		 M,
		 N,
		 ps14,
		 
		 [ O/fps(P, Q, I, z(J, A), E, R),
		   B,
		   S/kpsink(G, H, ni, z(D, C), F, T)
		 ],
		 U),
	kpsps(M,
	      N,
	      U,
	      G,
	      H,
	      I,
	      z(J, K),
	      L,
	      @ @ @ @0).

fps(M, B, O, P, Q, I, z(J, A), E, R) :-
	zrowne(A, [pz], K),
	goal(kpsink(G, H, ni, z(D, C), F, T),
	     B,
	     N,
	     S),
	zrowne(C, [np, p], D),
	oblkl(L, E, F),
	register(kpsps(G,
		       H,
		       I,
		       z(J, K),
		       L,
		       @ @ @ @0),
		 M,
		 N,
		 ps16,
		 
		 [ O/fps(P, Q, I, z(J, A), E, R),
		   B,
		   S/kpsink(G, H, ni, z(D, C), F, T)
		 ],
		 U),
	kpsps(M,
	      N,
	      U,
	      G,
	      H,
	      I,
	      z(J, K),
	      L,
	      @ @ @ @0).

fps(F, G, H, A, B, ni, C, D, @E) :-
	register(kprzysl(A, B, C, D, E),
		 F,
		 G,
		 ps23,
		 [H/fps(A, B, ni, C, D, @E)],
		 I),
	kprzysl(F,
		G,
		I,
		A,
		B,
		C,
		D,
		E).

fl1(H, I, J, A, B, C, D, E, F, G) :-
	register(fl(A, B, C, D, E, F, G),
		 H,
		 I,
		 lu1,
		 
		 [ J/fl1(A, B, C, D, E, F, G)
		 ],
		 K),
	fl(H,
	   I,
	   K,
	   A,
	   B,
	   C,
	   D,
	   E,
	   F,
	   G).

fl1(L, F, N, A, B, C, D, E, K, z(I, G)) :-
	goal(fl(A, B, C, D, E, ni, z(J, H)),
	     F,
	     M,
	     O),
	zplubnp(G, H, I, J),
	register(fl(A,
		    B,
		    C,
		    D,
		    E,
		    K,
		    z(Q, [p])),
		 L,
		 M,
		 lu2,
		 
		 [ N/fl1(A, B, C, D, E, K, z(I, G)),
		   F,
		   O/fl(A, B, C, D, E, ni, z(J, H))
		 ],
		 P),
	fl(L,
	   M,
	   P,
	   A,
	   B,
	   C,
	   D,
	   E,
	   K,
	   z(Q, [p])).

fl1(M, G, O, B, C, D, E, F, J, z(K, A)) :-
	zrowne(A, [pz], L),
	goal(fl(B, C, D, E, F, ni, z(I, H)),
	     G,
	     N,
	     P),
	zrowne(H, [p, np], I),
	register(fl(B,
		    C,
		    D,
		    E,
		    F,
		    J,
		    z(K, L)),
		 M,
		 N,
		 lu3,
		 
		 [ O/fl1(B, C, D, E, F, J, z(K, A)),
		   G,
		   P/fl(B, C, D, E, F, ni, z(I, H))
		 ],
		 Q),
	fl(M,
	   N,
	   Q,
	   B,
	   C,
	   D,
	   E,
	   F,
	   J,
	   z(K, L)).

fl1(M, G, O, B, C, D, E, F, J, z(K, A)) :-
	zrozne(A, [p, pz], L),
	goal(fl(B, C, D, E, F, ni, z(I, H)),
	     G,
	     N,
	     P),
	zrowne(H, [np], I),
	register(fl(B,
		    C,
		    D,
		    E,
		    F,
		    J,
		    z(K, L)),
		 M,
		 N,
		 lu4,
		 
		 [ O/fl1(B, C, D, E, F, J, z(K, A)),
		   G,
		   P/fl(B, C, D, E, F, ni, z(I, H))
		 ],
		 Q),
	fl(M,
	   N,
	   Q,
	   B,
	   C,
	   D,
	   E,
	   F,
	   J,
	   z(K, L)).

agl(E, F, G, A, B, C) :-
	D=[byxx, choćby, czyżby, gdyby, jakby, jakoby, żeby],
	register(fl1(I,
		     J,
		     A,
		     B,
		     K,
		     C,
		     z(L, D)),
		 E,
		 F,
		 lu8,
		 [G/agl(A, B, C)],
		 H),
	fl1(E,
	    F,
	    H,
	    I,
	    J,
	    A,
	    B,
	    K,
	    C,
	    z(L, D)).

przec(I, A, K) :-
	goal(fwe(psw,
		 M,
		 D,
		 N,
		 O,
		 P,
		 wym([], Q),
		 R,
		 E,
		 F,
		 z(G, B)),
	     A,
	     C,
	     L),
	zrowne(B, [np], H),
	goal(przec, C, J, S),
	register(fl1(U,
		     D,
		     V,
		     W,
		     E,
		     F,
		     z(G, H)),
		 I,
		 J,
		 lu9,
		 
		 [ K/przec,
		   A,
		   L/fwe(psw, M, D, N, O, P, wym([], Q), R, E, F, z(G, B)),
		   C,
		   S/przec
		 ],
		 T),
	fl1(I,
	    J,
	    T,
	    U,
	    D,
	    V,
	    W,
	    E,
	    F,
	    z(G, H)).

przec(H, A, J) :-
	goal(fwe(psu,
		 L,
		 prze,
		 M,
		 N,
		 O,
		 wym([], P),
		 Q,
		 D,
		 E,
		 z(F, B)),
	     A,
	     C,
	     K),
	zrowne(B, [np], G),
	goal(przec, C, I, R),
	register(fl1(T,
		     U,
		     V,
		     W,
		     D,
		     E,
		     z(F, G)),
		 H,
		 I,
		 lu10,
		 
		 [ J/przec,
		   A,
		   K/fwe(psu, L, prze, M, N, O, wym([], P), Q, D, E, z(F, B)),
		   C,
		   R/przec
		 ],
		 S),
	fl1(H,
	    I,
	    S,
	    T,
	    U,
	    V,
	    W,
	    D,
	    E,
	    z(F, G)).

przec(H, A, J) :-
	goal(fwe(psu,
		 L,
		 M,
		 N,
		 O,
		 P,
		 wym([], Q),
		 R,
		 D,
		 E,
		 z(F, B)),
	     A,
	     C,
	     K),
	zrowne(B, [np], G),
	goal(przec, C, I, S),
	register(fl1(U,
		     przy,
		     V,
		     W,
		     D,
		     E,
		     z(F, G)),
		 H,
		 I,
		 lu11,
		 
		 [ J/przec,
		   A,
		   K/fwe(psu, L, M, N, O, P, wym([], Q), R, D, E, z(F, B)),
		   C,
		   S/przec
		 ],
		 T),
	fl1(H,
	    I,
	    T,
	    U,
	    przy,
	    V,
	    W,
	    D,
	    E,
	    z(F, G)).

przec(G, A, I) :-
	goal(fno(wol,
		 D,
		 K,
		 L,
		 ni,
		 z(E, B),
		 M,
		 N),
	     A,
	     C,
	     J),
	zrowne(B, [np], F),
	goal(przec, C, H, O),
	register(fl1(Q,
		     R,
		     D,
		     2,
		     S,
		     ni,
		     z(E, F)),
		 G,
		 H,
		 lu12,
		 
		 [ I/przec,
		   A,
		   J/fno(wol, D, K, L, ni, z(E, B), M, N),
		   C,
		   O/przec
		 ],
		 P),
	fl1(G,
	    H,
	    P,
	    Q,
	    R,
	    D,
	    2,
	    S,
	    ni,
	    z(E, F)).

przec(G, A, I) :-
	goal(fno(wol,
		 K,
		 L,
		 M,
		 ni,
		 z(E, B),
		 N,
		 O),
	     A,
	     C,
	     J),
	zrowne(B, [np], F),
	goal(przec, C, H, P),
	rowne(D, [1, 3]),
	register(fl1(R,
		     S,
		     T,
		     D,
		     U,
		     ni,
		     z(E, F)),
		 G,
		 H,
		 lu13,
		 
		 [ I/przec,
		   A,
		   J/fno(wol, K, L, M, ni, z(E, B), N, O),
		   C,
		   P/przec
		 ],
		 Q),
	fl1(G,
	    H,
	    Q,
	    R,
	    S,
	    T,
	    D,
	    U,
	    ni,
	    z(E, F)).

przec(B, C, D) :-
	rowne(A, [sz, szk]),
	register(spoj1(A, przec),
		 B,
		 C,
		 spoj17,
		 [D/przec],
		 E),
	spoj1(B, C, E, A, przec).

przec(A, B, C) :-
	register(przecsp, A, B, int6, [C/przec], D),
	przecsp(A, B, D).

partykula(R, A, T, nie) :-
	goal(kweink(B,
		    D,
		    E,
		    M,
		    F,
		    G,
		    N,
		    O,
		    P,
		    z(Q, C)),
	     A,
	     H,
	     U),
	rowne(B, [bok, psu, psw]),
	zrowne(C, [p, px, pxx, pz], K),
	goal(fl(D,
		E,
		F,
		G,
		nie(nie),
		ni,
		z(L, I)),
	     H,
	     S,
	     V),
	zrozne(I, [pz], J),
	zrowne(J, [np|K], L),
	register(kweneg(B,
			D,
			E,
			M,
			F,
			G,
			N,
			O,
			nie(nie),
			P,
			z(Q, K)),
		 R,
		 S,
		 we20,
		 
		 [ T/partykula(nie),
		   A,
		   U/kweink(B, D, E, M, F, G, N, O, P, z(Q, C)),
		   H,
		   V/fl(D, E, F, G, nie(nie), ni, z(L, I))
		 ],
		 W),
	kweneg(R,
	       S,
	       W,
	       B,
	       D,
	       E,
	       M,
	       F,
	       G,
	       N,
	       O,
	       nie(nie),
	       P,
	       z(Q, K)).

partykula(Q, A, S, nie) :-
	goal(kweink(B,
		    D,
		    E,
		    K,
		    F,
		    G,
		    L,
		    M,
		    N,
		    z(O, C)),
	     A,
	     H,
	     T),
	rowne(B, [bok, psu, psw]),
	zrozne(C, [p, px, pxx, pz], P),
	goal(fl(D,
		E,
		F,
		G,
		nie(nie),
		ni,
		z(J, I)),
	     H,
	     R,
	     U),
	zrowne(I, [np], J),
	register(kweneg(B,
			D,
			E,
			K,
			F,
			G,
			L,
			M,
			nie(W),
			N,
			z(O, P)),
		 Q,
		 R,
		 we21,
		 
		 [ S/partykula(nie),
		   A,
		   T/kweink(B, D, E, K, F, G, L, M, N, z(O, C)),
		   H,
		   U/fl(D, E, F, G, nie(nie), ni, z(J, I))
		 ],
		 V),
	kweneg(Q,
	       R,
	       V,
	       B,
	       D,
	       E,
	       K,
	       F,
	       G,
	       L,
	       M,
	       nie(W),
	       N,
	       z(O, P)).

partykula(N, A, P, nie) :-
	goal(kweink(C,
		    D,
		    E,
		    F,
		    G,
		    H,
		    I,
		    J,
		    K,
		    z(L, B)),
	     A,
	     O,
	     Q),
	zrowne(B, [p, px, pxx, pz], M),
	register(kweneg(C,
			D,
			E,
			F,
			G,
			H,
			I,
			J,
			nie(nie),
			K,
			z(L, M)),
		 N,
		 O,
		 we20e,
		 
		 [ P/partykula(nie),
		   A,
		   Q/kweink(C, D, E, F, G, H, I, J, K, z(L, B))
		 ],
		 R),
	kweneg(N,
	       O,
	       R,
	       C,
	       D,
	       E,
	       F,
	       G,
	       H,
	       I,
	       J,
	       nie(nie),
	       K,
	       z(L, M)).

partykula(N, A, P, nie) :-
	goal(kweink(C,
		    D,
		    E,
		    F,
		    G,
		    H,
		    I,
		    J,
		    K,
		    z(L, B)),
	     A,
	     O,
	     Q),
	zrozne(B, [p, px, pxx, pz], M),
	register(kweneg(C,
			D,
			E,
			F,
			G,
			H,
			I,
			J,
			nie(S),
			K,
			z(L, M)),
		 N,
		 O,
		 we21e,
		 
		 [ P/partykula(nie),
		   A,
		   Q/kweink(C, D, E, F, G, H, I, J, K, z(L, B))
		 ],
		 R),
	kweneg(N,
	       O,
	       R,
	       C,
	       D,
	       E,
	       F,
	       G,
	       H,
	       I,
	       J,
	       nie(S),
	       K,
	       z(L, M)).

partykula(B, A, D, nie) :-
	goal(partykula(tylko), A, C, E),
	register(spoj1(rl, nietylko),
		 B,
		 C,
		 spoj4,
		 [D/partykula(nie), A, E/partykula(tylko)],
		 F),
	spoj1(B, C, F, rl, nietylko).

partykula(B, A, D, nie) :-
	goal(spojnik(zaś), A, C, E),
	register(spoj1(rc, nie),
		 B,
		 C,
		 spoj13,
		 [D/partykula(nie), A, E/spojnik(zaś)],
		 F),
	spoj1(B, C, F, rc, nie).

partykula(E, A, G, D) :-
	goal(spoj(C, B, ni), A, F, H),
	rowne(B, [bowiem, natomiast, więc, zaś]),
	rowne(C, [pi, ri]),
	register(pyt(D, B),
		 E,
		 F,
		 par1,
		 
		 [ G/partykula(D),
		   A,
		   H/spoj(C, B, ni)
		 ],
		 I),
	pyt(E, F, I, D, B).

partykula(B, C, D, A) :-
	register(pyt(A, ni),
		 B,
		 C,
		 par2,
		 [D/partykula(A)],
		 E),
	pyt(B, C, E, A, ni).

kweink(Q, G, S, A, C, D, L, E, F, M, N, O, z(P, B)) :-
	rowne(A, [bok, psu, psw]),
	zrowne(B, [p, px, pxx, pz], J),
	goal(fl(C, D, E, F, tak, ni, z(K, H)),
	     G,
	     R,
	     T),
	zrozne(H, [pz], I),
	zrowne(I, [np|J], K),
	register(kweneg(A,
			C,
			D,
			L,
			E,
			F,
			M,
			N,
			tak,
			O,
			z(P, J)),
		 Q,
		 R,
		 we22,
		 
		 [ S/kweink(A, C, D, L, E, F, M, N, O, z(P, B)),
		   G,
		   T/fl(C, D, E, F, tak, ni, z(K, H))
		 ],
		 U),
	kweneg(Q,
	       R,
	       U,
	       A,
	       C,
	       D,
	       L,
	       E,
	       F,
	       M,
	       N,
	       tak,
	       O,
	       z(P, J)).

kweink(P, G, R, A, C, D, J, E, F, K, L, M, z(N, B)) :-
	rowne(A, [bok, psu, psw]),
	zrozne(B,
	       [aż1xx, boxx, byxx, dopóki, gdyxx, p, px, pxx, pz, zanimxx],
	       O),
	goal(fl(C, D, E, F, tak, ni, z(I, H)),
	     G,
	     Q,
	     S),
	zrowne(H, [np], I),
	register(kweneg(A,
			C,
			D,
			J,
			E,
			F,
			K,
			L,
			tak,
			M,
			z(N, O)),
		 P,
		 Q,
		 we23,
		 
		 [ R/kweink(A, C, D, J, E, F, K, L, M, z(N, B)),
		   G,
		   S/fl(C, D, E, F, tak, ni, z(I, H))
		 ],
		 T),
	kweneg(P,
	       Q,
	       T,
	       A,
	       C,
	       D,
	       J,
	       E,
	       F,
	       K,
	       L,
	       tak,
	       M,
	       z(N, O)).

kweink(P, G, R, A, C, D, J, E, F, K, L, M, z(N, B)) :-
	rowne(A, [bok, psu, psw]),
	zrowne(B, [aż1xx, boxx, byxx, dopóki, gdyxx, zanimxx], O),
	goal(fl(C, D, E, F, tak, ni, z(I, H)),
	     G,
	     Q,
	     S),
	zrowne(H, [np], I),
	register(kweneg(A,
			nd,
			D,
			J,
			E,
			F,
			K,
			L,
			tak,
			M,
			z(N, O)),
		 P,
		 Q,
		 we24,
		 
		 [ R/kweink(A, C, D, J, E, F, K, L, M, z(N, B)),
		   G,
		   S/fl(C, D, E, F, tak, ni, z(I, H))
		 ],
		 T),
	kweneg(P,
	       Q,
	       T,
	       A,
	       nd,
	       D,
	       J,
	       E,
	       F,
	       K,
	       L,
	       tak,
	       M,
	       z(N, O)).

kweink(M, N, O, B, C, D, E, F, G, H, I, J, z(K, A)) :-
	zrozne(A, [aż1xx, boxx, byxx, dopóki, gdyxx, zanimxx], L),
	register(kweneg(B,
			C,
			D,
			E,
			F,
			G,
			H,
			I,
			tak,
			J,
			z(K, L)),
		 M,
		 N,
		 we22e,
		 
		 [ O/kweink(B, C, D, E, F, G, H, I, J, z(K, A))
		 ],
		 P),
	kweneg(M,
	       N,
	       P,
	       B,
	       C,
	       D,
	       E,
	       F,
	       G,
	       H,
	       I,
	       tak,
	       J,
	       z(K, L)).

kweink(L, M, N, B, O, C, D, E, F, G, H, I, z(J, A)) :-
	zrowne(A, [aż1xx, boxx, byxx, dopóki, gdyxx, zanimxx], K),
	register(kweneg(B,
			nd,
			C,
			D,
			E,
			F,
			G,
			H,
			tak,
			I,
			z(J, K)),
		 L,
		 M,
		 we24e,
		 
		 [ N/kweink(B, O, C, D, E, F, G, H, I, z(J, A))
		 ],
		 P),
	kweneg(L,
	       M,
	       P,
	       B,
	       nd,
	       C,
	       D,
	       E,
	       F,
	       G,
	       H,
	       tak,
	       I,
	       z(J, K)).

kwer(M, A, O, D, E, F, G, H, I, J, K, L) :-
	goal(spoj(C, B, ni), A, N, P),
	rowne(B, [bowiem, natomiast, więc, zaś]),
	rowne(C, [pi, ri]),
	register(kweink(D,
			E,
			F,
			G,
			H,
			I,
			J,
			K,
			B,
			L),
		 M,
		 N,
		 we25,
		 
		 [ O/kwer(D, E, F, G, H, I, J, K, L),
		   A,
		   P/spoj(C, B, ni)
		 ],
		 Q),
	kweink(M,
	       N,
	       Q,
	       D,
	       E,
	       F,
	       G,
	       H,
	       I,
	       J,
	       K,
	       B,
	       L).

kwer(J, K, L, A, B, C, D, E, F, G, H, I) :-
	register(kweink(A,
			B,
			C,
			D,
			E,
			F,
			G,
			H,
			ni,
			I),
		 J,
		 K,
		 we26,
		 
		 [ L/kwer(A, B, C, D, E, F, G, H, I)
		 ],
		 M),
	kweink(J,
	       K,
	       M,
	       A,
	       B,
	       C,
	       D,
	       E,
	       F,
	       G,
	       H,
	       ni,
	       I).

kwer1(G, H, I, bos, A, prze, B, C, 3, D, E, F) :-
	register(kwer(bos,
		      A,
		      prze,
		      B,
		      C,
		      3,
		      D,
		      E,
		      F),
		 G,
		 H,
		 we27,
		 
		 [ I/kwer1(bos, A, prze, B, C, 3, D, E, F)
		 ],
		 J),
	kwer(G,
	     H,
	     J,
	     bos,
	     A,
	     prze,
	     B,
	     C,
	     3,
	     D,
	     E,
	     F).

kwer1(I, J, K, A, B, C, D, E, 3, F, G, H) :-
	rowne(A, [bok, psu, psw]),
	register(kwer(A,
		      B,
		      C,
		      D,
		      E,
		      3,
		      F,
		      G,
		      H),
		 I,
		 J,
		 we28,
		 
		 [ K/kwer1(A, B, C, D, E, 3, F, G, H)
		 ],
		 L),
	kwer(I,
	     J,
	     L,
	     A,
	     B,
	     C,
	     D,
	     E,
	     3,
	     F,
	     G,
	     H).

kwer1(I, J, K, os, A, B, C, D, E, F, G, H) :-
	register(kwer(os,
		      A,
		      B,
		      C,
		      D,
		      E,
		      F,
		      G,
		      H),
		 I,
		 J,
		 we29,
		 
		 [ K/kwer1(os, A, B, C, D, E, F, G, H)
		 ],
		 L),
	kwer(I,
	     J,
	     L,
	     os,
	     A,
	     B,
	     C,
	     D,
	     E,
	     F,
	     G,
	     H).

formaczas(N, O, P, D, H, F, A, J, K, L, M) :-
	(   A\==roz
	->  B=[npt, npxt, npxxt, p, px, pxx, pz|C]
	;   B=C
	),
	(   A\==roz,
	    D\==bok
	->  C=[aż1xx, aż2, bo, box, boxx, bowiem, chociaż, co, czy, dopóki, gdy, gdyxx, jak, jaki, jeśli, kto, który, podczas, ponieważ, że|E]
	;   C=E
	),
	(   A\==roz,
	    D\==bok,
	    F==przy
	->  E=[aż1|G]
	;   E=G
	),
	(   A\==roz,
	    D\==bok,
	    H==dk
	->  G=[zanim, zanimxx|I]
	;   G=I
	),
	(   D\==bok,
	    F==prze,
	    A==ozn
	->  I=[byxx, choćby, czyżby, gdyby, jakby, jakoby, żeby]
	;   I=[]
	),
	register(kwer1(D,
		       H,
		       F,
		       A,
		       J,
		       K,
		       L,
		       M,
		       z(R, [np, npx, npxx|B])),
		 N,
		 O,
		 we30n,
		 
		 [ P/formaczas(D, H, F, A, J, K, L, M)
		 ],
		 Q),
	kwer1(N,
	      O,
	      Q,
	      D,
	      H,
	      F,
	      A,
	      J,
	      K,
	      L,
	      M,
	      z(R, [np, npx, npxx|B])).

formaczas(F, G, H, bok, A, prze, ozn, B, C, D, E) :-
	register(kwer1(bok,
		       A,
		       prze,
		       ozn,
		       B,
		       C,
		       D,
		       E,
		       z(J, [byxx, choćby, czyżby, gdyby, jakby, jakoby, żeby])),
		 F,
		 G,
		 we35n,
		 
		 [ H/formaczas(bok, A, prze, ozn, B, C, D, E)
		 ],
		 I),
	kwer1(F,
	      G,
	      I,
	      bok,
	      A,
	      prze,
	      ozn,
	      B,
	      C,
	      D,
	      E,
	      z(J, [byxx, choćby, czyżby, gdyby, jakby, jakoby, żeby])).

przyimek(H, B, J, C, A) :-
	goal(fno(A,
		 L,
		 M,
		 D,
		 E,
		 F,
		 G,
		 N),
	     B,
	     I,
	     K),
	register(fpm(C, A, D, E, F, G),
		 H,
		 I,
		 pm1,
		 
		 [ J/przyimek(C, A),
		   B,
		   K/fno(A, L, M, D, E, F, G, N)
		 ],
		 O),
	fpm(H,
	    I,
	    O,
	    C,
	    A,
	    D,
	    E,
	    F,
	    G).

przyimek(B, A, D, mimo, dop) :-
	goal(spojnik(że), A, C, E),
	register(spoj1(po, chociaż),
		 B,
		 C,
		 spoj34,
		 [D/przyimek(mimo, dop), A, E/spojnik(że)],
		 F),
	spoj1(B, C, F, po, chociaż).

przyimek(B, A, D, podczas, dop) :-
	goal(spojnik(gdy), A, C, E),
	register(spoj1(po, podczas),
		 B,
		 C,
		 spoj40,
		 [D/przyimek(podczas, dop), A, E/spojnik(gdy)],
		 F),
	spoj1(B, C, F, po, podczas).

przyimek(G, B, I, F, A) :-
	goal(kor1(A), B, C, J),
	goal(spoj(E, D, ni), C, H, K),
	rowne(D, [bowiem, natomiast, więc, zaś]),
	rowne(E, [pi, ri]),
	register(kor(F/A, D),
		 G,
		 H,
		 kor1,
		 
		 [ I/przyimek(F, A),
		   B,
		   J/kor1(A),
		   C,
		   K/spoj(E, D, ni)
		 ],
		 L),
	kor(G, H, L, F/A, D).

przyimek(D, B, F, C, A) :-
	goal(kor1(A), B, E, G),
	register(kor(C/A, ni),
		 D,
		 E,
		 kor1x,
		 
		 [ F/przyimek(C, A),
		   B,
		   G/kor1(A)
		 ],
		 H),
	kor(D, E, H, C/A, ni).

knodop(I, J, K, A, B, C, D, E, F, G, @H) :-
	register(fno(A,
		     B,
		     C,
		     D,
		     E,
		     F,
		     G,
		     H),
		 I,
		 J,
		 no1,
		 
		 [ K/knodop(A, B, C, D, E, F, G, @H)
		 ],
		 L),
	fno(I,
	    J,
	    L,
	    A,
	    B,
	    C,
	    D,
	    E,
	    F,
	    G,
	    H).

knodop(J, C, L, E, B, F, G, H, I, A, M) :-
	rozne(A, [co, kto, wz]),
	goal(fzd(który,
		 nk,
		 O,
		 P,
		 Q,
		 R,
		 B,
		 S),
	     C,
	     D,
	     N),
	goal(przec, D, K, T),
	register(fno(E,
		     B,
		     F,
		     G,
		     H,
		     I,
		     A,
		     @ @ @ @ @0),
		 J,
		 K,
		 no2,
		 
		 [ L/knodop(E, B, F, G, H, I, A, M),
		   C,
		   N/fzd(który, nk, O, P, Q, R, B, S),
		   D,
		   T/przec
		 ],
		 U),
	fno(J,
	    K,
	    U,
	    E,
	    B,
	    F,
	    G,
	    H,
	    I,
	    A,
	    @ @ @ @ @0).

knodop(K, C, M, F, B, G, H, I, J, A, N) :-
	rowne(A, [co, kto]),
	goal(fzd(D,
		 nk,
		 P,
		 Q,
		 R,
		 S,
		 B,
		 T),
	     C,
	     E,
	     O),
	rowne(D, [A, który]),
	goal(przec, E, L, U),
	register(fno(F,
		     B,
		     G,
		     H,
		     I,
		     J,
		     A,
		     @ @ @ @ @0),
		 K,
		 L,
		 no3,
		 
		 [ M/knodop(F, B, G, H, I, J, A, N),
		   C,
		   O/fzd(D, nk, P, Q, R, S, B, T),
		   E,
		   U/przec
		 ],
		 V),
	fno(K,
	    L,
	    V,
	    F,
	    B,
	    G,
	    H,
	    I,
	    J,
	    A,
	    @ @ @ @ @0).

knodop(J, A, L, D, E, F, G, H, I, tk, M) :-
	goal(fzd(B, nk, O, P, Q, R, ni, S),
	     A,
	     C,
	     N),
	rowne(B, [jakby, jaki, że, żeby]),
	goal(przec, C, K, T),
	register(fno(D,
		     E,
		     F,
		     G,
		     H,
		     I,
		     tk,
		     @ @ @ @ @0),
		 J,
		 K,
		 no4,
		 
		 [ L/knodop(D, E, F, G, H, I, tk, M),
		   A,
		   N/fzd(B, nk, O, P, Q, R, ni, S),
		   C,
		   T/przec
		 ],
		 U),
	fno(J,
	    K,
	    U,
	    D,
	    E,
	    F,
	    G,
	    H,
	    I,
	    tk,
	    @ @ @ @ @0).

knopm(I, J, K, A, B, C, D, E, F, G, @H) :-
	register(knodop(A,
			B,
			C,
			D,
			E,
			F,
			G,
			H),
		 I,
		 J,
		 no5,
		 
		 [ K/knopm(A, B, C, D, E, F, G, @H)
		 ],
		 L),
	knodop(I,
	       J,
	       L,
	       A,
	       B,
	       C,
	       D,
	       E,
	       F,
	       G,
	       H).

knopm(N, B, P, H, I, J, K, L, z(E, C), A, Q) :-
	rozne(A, os),
	goal(fno(dop,
		 S,
		 3,
		 T,
		 ni,
		 z(F, D),
		 G,
		 U),
	     B,
	     O,
	     R),
	zplubnp(C, D, E, F),
	rozne(G, kto),
	oblkl(M, G, A),
	register(knodop(H,
			I,
			J,
			K,
			L,
			z(W, [p]),
			M,
			@ @ @ @ @0),
		 N,
		 O,
		 no6,
		 
		 [ P/knopm(H, I, J, K, L, z(E, C), A, Q),
		   B,
		   R/fno(dop, S, 3, T, ni, z(F, D), G, U)
		 ],
		 V),
	knodop(N,
	       O,
	       V,
	       H,
	       I,
	       J,
	       K,
	       L,
	       z(W, [p]),
	       M,
	       @ @ @ @ @0).

knopm(O, C, Q, G, H, I, J, K, z(L, A), B, R) :-
	zrowne(A, [co, jaki, który, np], M),
	rozne(B, [os, wz]),
	goal(fno(dop,
		 T,
		 3,
		 U,
		 ni,
		 z(E, D),
		 F,
		 V),
	     C,
	     P,
	     S),
	zrowne(D, [np], E),
	rozne(F, kto),
	oblkl(N, F, B),
	register(knodop(G,
			H,
			I,
			J,
			K,
			z(L, M),
			N,
			@ @ @ @ @0),
		 O,
		 P,
		 no8,
		 
		 [ Q/knopm(G, H, I, J, K, z(L, A), B, R),
		   C,
		   S/fno(dop, T, 3, U, ni, z(E, D), F, V)
		 ],
		 W),
	knodop(O,
	       P,
	       W,
	       G,
	       H,
	       I,
	       J,
	       K,
	       z(L, M),
	       N,
	       @ @ @ @ @0).

knopm(O, B, Q, G, H, I, J, K, z(L, A), F, R) :-
	zrowne(A, [pz], M),
	goal(fno(dop,
		 T,
		 3,
		 U,
		 ni,
		 z(D, C),
		 E,
		 V),
	     B,
	     P,
	     S),
	zrowne(C, [np, p], D),
	rozne(E, kto),
	oblkl(N, E, F),
	register(knodop(G,
			H,
			I,
			J,
			K,
			z(L, M),
			N,
			@ @ @ @ @0),
		 O,
		 P,
		 no10,
		 
		 [ Q/knopm(G, H, I, J, K, z(L, A), F, R),
		   B,
		   S/fno(dop, T, 3, U, ni, z(D, C), E, V)
		 ],
		 W),
	knodop(O,
	       P,
	       W,
	       G,
	       H,
	       I,
	       J,
	       K,
	       z(L, M),
	       N,
	       @ @ @ @ @0).

knoatr(I, J, K, A, B, C, D, E, F, G, @H) :-
	register(knopm(A,
		       B,
		       C,
		       D,
		       E,
		       F,
		       G,
		       H),
		 I,
		 J,
		 no12,
		 
		 [ K/knoatr(A, B, C, D, E, F, G, @H)
		 ],
		 L),
	knopm(I,
	      J,
	      L,
	      A,
	      B,
	      C,
	      D,
	      E,
	      F,
	      G,
	      H).

knoatr(N, A, P, H, I, J, K, L, z(D, B), G, Q) :-
	goal(fpm(S, T, U, ni, z(E, C), F),
	     A,
	     O,
	     R),
	zplubnp(B, C, D, E),
	oblkl(M, F, G),
	register(knopm(H,
		       I,
		       J,
		       K,
		       L,
		       z(W, [p]),
		       M,
		       @ @ @ @ @0),
		 N,
		 O,
		 no13,
		 
		 [ P/knoatr(H, I, J, K, L, z(D, B), G, Q),
		   A,
		   R/fpm(S, T, U, ni, z(E, C), F)
		 ],
		 V),
	knopm(N,
	      O,
	      V,
	      H,
	      I,
	      J,
	      K,
	      L,
	      z(W, [p]),
	      M,
	      @ @ @ @ @0).

knoatr(O, B, Q, G, H, I, J, K, z(L, A), F, R) :-
	zrowne(A, [co, jaki, który, np], M),
	goal(fpm(T, U, V, ni, z(D, C), E),
	     B,
	     P,
	     S),
	zrowne(C, [np], D),
	oblkl(N, E, F),
	register(knopm(G,
		       H,
		       I,
		       J,
		       K,
		       z(L, M),
		       N,
		       @ @ @ @ @0),
		 O,
		 P,
		 no15,
		 
		 [ Q/knoatr(G, H, I, J, K, z(L, A), F, R),
		   B,
		   S/fpm(T, U, V, ni, z(D, C), E)
		 ],
		 W),
	knopm(O,
	      P,
	      W,
	      G,
	      H,
	      I,
	      J,
	      K,
	      z(L, M),
	      N,
	      @ @ @ @ @0).

knoatr(O, B, Q, G, H, I, J, K, z(L, A), F, R) :-
	zrowne(A, [pz], M),
	goal(fpm(T, U, V, ni, z(D, C), E),
	     B,
	     P,
	     S),
	zrowne(C, [np, p], D),
	oblkl(N, E, F),
	register(knopm(G,
		       H,
		       I,
		       J,
		       K,
		       z(L, M),
		       N,
		       @ @ @ @ @0),
		 O,
		 P,
		 no17,
		 
		 [ Q/knoatr(G, H, I, J, K, z(L, A), F, R),
		   B,
		   S/fpm(T, U, V, ni, z(D, C), E)
		 ],
		 W),
	knopm(O,
	      P,
	      W,
	      G,
	      H,
	      I,
	      J,
	      K,
	      z(L, M),
	      N,
	      @ @ @ @ @0).

knoink(I, J, K, A, B, C, D, E, F, G, @H) :-
	register(knoatr(A,
			B,
			C,
			D,
			E,
			F,
			G,
			H),
		 I,
		 J,
		 no19,
		 
		 [ K/knoink(A, B, C, D, E, F, G, @H)
		 ],
		 L),
	knoatr(I,
	       J,
	       L,
	       A,
	       B,
	       C,
	       D,
	       E,
	       F,
	       G,
	       H).

knoink(N, C, P, A, B, J, K, L, z(F, D), H, Q) :-
	goal(fpt(A,
		 B,
		 S,
		 T,
		 ni,
		 z(G, E),
		 I,
		 U),
	     C,
	     O,
	     R),
	zplubnp(D, E, F, G),
	rozne(H, co),
	oblkl(M, I, H),
	register(knoatr(A,
			B,
			J,
			K,
			L,
			z(W, [p]),
			M,
			@ @ @ @ @0),
		 N,
		 O,
		 no20,
		 
		 [ P/knoink(A, B, J, K, L, z(F, D), H, Q),
		   C,
		   R/fpt(A, B, S, T, ni, z(G, E), I, U)
		 ],
		 V),
	knoatr(N,
	       O,
	       V,
	       A,
	       B,
	       J,
	       K,
	       L,
	       z(W, [p]),
	       M,
	       @ @ @ @ @0).

knoink(M, C, O, A, B, I, J, K, z(F, D), co, P) :-
	rowne(A, [mian, bier]),
	goal(fpt(dop,
		 B,
		 R,
		 S,
		 ni,
		 z(G, E),
		 H,
		 T),
	     C,
	     N,
	     Q),
	zplubnp(D, E, F, G),
	oblkl(L, H, _),
	register(knoatr(A,
			B,
			I,
			J,
			K,
			z(V, [p]),
			L,
			@ @ @ @ @0),
		 M,
		 N,
		 no21,
		 
		 [ O/knoink(A, B, I, J, K, z(F, D), co, P),
		   C,
		   Q/fpt(dop, B, R, S, ni, z(G, E), H, T)
		 ],
		 U),
	knoatr(M,
	       N,
	       U,
	       A,
	       B,
	       I,
	       J,
	       K,
	       z(V, [p]),
	       L,
	       @ @ @ @ @0).

knoink(M, C, O, A, B, I, J, K, z(F, D), co, P) :-
	rozne(A, [mian, bier]),
	goal(fpt(A,
		 B,
		 R,
		 S,
		 ni,
		 z(G, E),
		 H,
		 T),
	     C,
	     N,
	     Q),
	zplubnp(D, E, F, G),
	oblkl(L, H, _),
	register(knoatr(A,
			B,
			I,
			J,
			K,
			z(V, [p]),
			L,
			@ @ @ @ @0),
		 M,
		 N,
		 no22,
		 
		 [ O/knoink(A, B, I, J, K, z(F, D), co, P),
		   C,
		   Q/fpt(A, B, R, S, ni, z(G, E), H, T)
		 ],
		 U),
	knoatr(M,
	       N,
	       U,
	       A,
	       B,
	       I,
	       J,
	       K,
	       z(V, [p]),
	       L,
	       @ @ @ @ @0).

knoink(O, E, Q, C, D, I, J, K, z(L, A), B, R) :-
	zrowne(A, [co, jaki, kto, który, np], M),
	rozne(B, [co, os, wz]),
	goal(fpt(C,
		 D,
		 T,
		 U,
		 ni,
		 z(G, F),
		 H,
		 V),
	     E,
	     P,
	     S),
	zrowne(F, [np], G),
	oblkl(N, H, B),
	register(knoatr(C,
			D,
			I,
			J,
			K,
			z(L, M),
			N,
			@ @ @ @ @0),
		 O,
		 P,
		 no26,
		 
		 [ Q/knoink(C, D, I, J, K, z(L, A), B, R),
		   E,
		   S/fpt(C, D, T, U, ni, z(G, F), H, V)
		 ],
		 W),
	knoatr(O,
	       P,
	       W,
	       C,
	       D,
	       I,
	       J,
	       K,
	       z(L, M),
	       N,
	       @ @ @ @ @0).

knoink(N, D, P, A, C, H, I, J, z(K, B), co, Q) :-
	rowne(A, [mian, bier]),
	zrowne(B, [np], L),
	goal(fpt(dop,
		 C,
		 S,
		 T,
		 ni,
		 z(F, E),
		 G,
		 U),
	     D,
	     O,
	     R),
	zrowne(E, [np], F),
	oblkl(M, G, _),
	register(knoatr(A,
			C,
			H,
			I,
			J,
			z(K, L),
			M,
			@ @ @ @ @0),
		 N,
		 O,
		 no28,
		 
		 [ P/knoink(A, C, H, I, J, z(K, B), co, Q),
		   D,
		   R/fpt(dop, C, S, T, ni, z(F, E), G, U)
		 ],
		 V),
	knoatr(N,
	       O,
	       V,
	       A,
	       C,
	       H,
	       I,
	       J,
	       z(K, L),
	       M,
	       @ @ @ @ @0).

knoink(N, D, P, A, C, H, I, J, z(K, B), co, Q) :-
	rozne(A, [mian, bier]),
	zrowne(B, [np], L),
	goal(fpt(A,
		 C,
		 S,
		 T,
		 ni,
		 z(F, E),
		 G,
		 U),
	     D,
	     O,
	     R),
	zrowne(E, [np], F),
	oblkl(M, G, _),
	register(knoatr(A,
			C,
			H,
			I,
			J,
			z(K, L),
			M,
			@ @ @ @ @0),
		 N,
		 O,
		 no29,
		 
		 [ P/knoink(A, C, H, I, J, z(K, B), co, Q),
		   D,
		   R/fpt(A, C, S, T, ni, z(F, E), G, U)
		 ],
		 V),
	knoatr(N,
	       O,
	       V,
	       A,
	       C,
	       H,
	       I,
	       J,
	       z(K, L),
	       M,
	       @ @ @ @ @0).

knoink(O, E, Q, C, D, I, J, K, z(L, B), A, R) :-
	rozne(A, [co]),
	zrowne(B, [pz], M),
	goal(fpt(C,
		 D,
		 T,
		 U,
		 ni,
		 z(G, F),
		 H,
		 V),
	     E,
	     P,
	     S),
	zrowne(F, [np, p], G),
	oblkl(N, H, A),
	register(knoatr(C,
			D,
			I,
			J,
			K,
			z(L, M),
			N,
			@ @ @ @ @0),
		 O,
		 P,
		 no32,
		 
		 [ Q/knoink(C, D, I, J, K, z(L, B), A, R),
		   E,
		   S/fpt(C, D, T, U, ni, z(G, F), H, V)
		 ],
		 W),
	knoatr(O,
	       P,
	       W,
	       C,
	       D,
	       I,
	       J,
	       K,
	       z(L, M),
	       N,
	       @ @ @ @ @0).

knoink(N, D, P, A, C, H, I, J, z(K, B), co, Q) :-
	rowne(A, [mian, bier]),
	zrowne(B, [pz], L),
	goal(fpt(dop,
		 C,
		 S,
		 T,
		 ni,
		 z(F, E),
		 G,
		 U),
	     D,
	     O,
	     R),
	zrowne(E, [np, p], F),
	oblkl(M, G, _),
	register(knoatr(A,
			C,
			H,
			I,
			J,
			z(K, L),
			M,
			@ @ @ @ @0),
		 N,
		 O,
		 no33,
		 
		 [ P/knoink(A, C, H, I, J, z(K, B), co, Q),
		   D,
		   R/fpt(dop, C, S, T, ni, z(F, E), G, U)
		 ],
		 V),
	knoatr(N,
	       O,
	       V,
	       A,
	       C,
	       H,
	       I,
	       J,
	       z(K, L),
	       M,
	       @ @ @ @ @0).

knoink(N, D, P, A, C, H, I, J, z(K, B), co, Q) :-
	rozne(A, [mian, bier]),
	zrowne(B, [pz], L),
	goal(fpt(A,
		 C,
		 S,
		 T,
		 ni,
		 z(F, E),
		 G,
		 U),
	     D,
	     O,
	     R),
	zrowne(E, [np, p], F),
	oblkl(M, G, _),
	register(knoatr(A,
			C,
			H,
			I,
			J,
			z(K, L),
			M,
			@ @ @ @ @0),
		 N,
		 O,
		 no34,
		 
		 [ P/knoink(A, C, H, I, J, z(K, B), co, Q),
		   D,
		   R/fpt(A, C, S, T, ni, z(F, E), G, U)
		 ],
		 V),
	knoatr(N,
	       O,
	       V,
	       A,
	       C,
	       H,
	       I,
	       J,
	       z(K, L),
	       M,
	       @ @ @ @ @0).

knom(L, B, N, E, F, G, H, z(I, A), K, O) :-
	zrowne(A, [np, p, pz], J),
	goal(spoj(D, C, ni), B, M, P),
	rowne(C, [bowiem, natomiast, więc, zaś]),
	rowne(D, [pi, ri]),
	register(knoink(E,
			F,
			G,
			H,
			C,
			z(I, J),
			K,
			@ @ @ @ @0),
		 L,
		 M,
		 no39,
		 
		 [ N/knom(E, F, G, H, z(I, A), K, O),
		   B,
		   P/spoj(D, C, ni)
		 ],
		 Q),
	knoink(L,
	       M,
	       Q,
	       E,
	       F,
	       G,
	       H,
	       C,
	       z(I, J),
	       K,
	       @ @ @ @ @0).

knom(J, K, L, B, C, D, E, z(F, A), H, @I) :-
	zrowne(A, [np, p, pz], G),
	register(knoink(B,
			C,
			D,
			E,
			ni,
			z(F, G),
			H,
			I),
		 J,
		 K,
		 no40,
		 
		 [ L/knom(B, C, D, E, z(F, A), H, @I)
		 ],
		 M),
	knoink(J,
	       K,
	       M,
	       B,
	       C,
	       D,
	       E,
	       ni,
	       z(F, G),
	       H,
	       I).

knom(J, K, L, B, C, D, E, z(F, A), H, @I) :-
	rozne(_, [bowiem, natomiast, ni, więc, zaś]),
	zrowne(A, [co, jaki, kto, który], G),
	register(knoink(B,
			C,
			D,
			E,
			C,
			z(F, G),
			H,
			I),
		 J,
		 K,
		 no41,
		 
		 [ L/knom(B, C, D, E, z(F, A), H, @I)
		 ],
		 M),
	knoink(J,
	       K,
	       M,
	       B,
	       C,
	       D,
	       E,
	       C,
	       z(F, G),
	       H,
	       I).

zaimpyt(E, F, G, rzecz, B, C, 3, A) :-
	D=[p, pz],
	rowne(A, [co, kto]),
	register(knom(B,
		      C,
		      3,
		      I,
		      z(J, D),
		      A,
		      @ @ @ @ @0),
		 E,
		 F,
		 no42,
		 [G/zaimpyt(rzecz, B, C, 3, A)],
		 H),
	knom(E,
	     F,
	     H,
	     B,
	     C,
	     3,
	     I,
	     z(J, D),
	     A,
	     @ @ @ @ @0).

zaimpyt(C, D, E, przym, A, B, 3, zaim) :-
	register(kprzym(A,
			B,
			row,
			G,
			z(H, [p, pz]),
			zaim,
			@ @ @ @ @0),
		 C,
		 D,
		 pt27,
		 [E/zaimpyt(przym, A, B, 3, zaim)],
		 F),
	kprzym(C,
	       D,
	       F,
	       A,
	       B,
	       row,
	       G,
	       z(H, [p, pz]),
	       zaim,
	       @ @ @ @ @0).

zaimpyt(B, C, D, przysl, E, F, G, A) :-
	register(kprzysl(row, I, z(J, [p, pz]), A, @ @ @ @0),
		 B,
		 C,
		 ps19,
		 [D/zaimpyt(przysl, E, F, G, A)],
		 H),
	kprzysl(B,
		C,
		H,
		row,
		I,
		z(J, [p, pz]),
		A,
		@ @ @ @0).

zaimno(D, E, F, rzecz, B, C, 3, A) :-
	rowne(A, [co, kto]),
	register(knom(B,
		      C,
		      3,
		      H,
		      z(I, [np]),
		      A,
		      @ @ @ @ @0),
		 D,
		 E,
		 no43,
		 [F/zaimno(rzecz, B, C, 3, A)],
		 G),
	knom(D,
	     E,
	     G,
	     B,
	     C,
	     3,
	     H,
	     z(I, [np]),
	     A,
	     @ @ @ @ @0).

zaimno(D, E, F, przym, B, C, G, A) :-
	rowne(A, [tk, zaim]),
	register(kprzym(B,
			C,
			row,
			I,
			z(J, [np]),
			A,
			@ @ @ @ @0),
		 D,
		 E,
		 pt28,
		 [F/zaimno(przym, B, C, G, A)],
		 H),
	kprzym(D,
	       E,
	       H,
	       B,
	       C,
	       row,
	       I,
	       z(J, [np]),
	       A,
	       @ @ @ @ @0).

zaimno(B, C, D, przysl, E, F, G, A) :-
	register(kprzysl(row, I, z(J, [np]), A, @ @ @ @0),
		 B,
		 C,
		 ps20,
		 [D/zaimno(przysl, E, F, G, A)],
		 H),
	kprzysl(B,
		C,
		H,
		row,
		I,
		z(J, [np]),
		A,
		@ @ @ @0).

zaimneg(D, E, F, rzecz, B, C, 3, A) :-
	rowne(A, [co, kto]),
	register(knom(B,
		      C,
		      3,
		      nie(H),
		      z(I, [np]),
		      A,
		      @ @ @ @ @0),
		 D,
		 E,
		 no44,
		 [F/zaimneg(rzecz, B, C, 3, A)],
		 G),
	knom(D,
	     E,
	     G,
	     B,
	     C,
	     3,
	     nie(H),
	     z(I, [np]),
	     A,
	     @ @ @ @ @0).

zaimneg(C, D, E, przym, A, B, 3, F) :-
	register(kprzym(A,
			B,
			row,
			nie(H),
			z(I, [np]),
			zaim,
			@ @ @ @ @0),
		 C,
		 D,
		 pt29,
		 [E/zaimneg(przym, A, B, 3, F)],
		 G),
	kprzym(C,
	       D,
	       G,
	       A,
	       B,
	       row,
	       nie(H),
	       z(I, [np]),
	       zaim,
	       @ @ @ @ @0).

zaimneg(B, C, D, przysl, E, F, G, A) :-
	register(kprzysl(row, nie(I), z(J, [np]), A, @ @ @ @0),
		 B,
		 C,
		 ps21,
		 [D/zaimneg(przysl, E, F, G, A)],
		 H),
	kprzysl(B,
		C,
		H,
		row,
		nie(I),
		z(J, [np]),
		A,
		@ @ @ @0).

zaimos(D, E, F, A, B, C) :-
	register(knom(A,
		      B,
		      C,
		      H,
		      z(I, [np]),
		      os,
		      @ @ @ @ @0),
		 D,
		 E,
		 no45,
		 [F/zaimos(A, B, C)],
		 G),
	knom(D,
	     E,
	     G,
	     A,
	     B,
	     C,
	     H,
	     z(I, [np]),
	     os,
	     @ @ @ @ @0).

formarzecz(C, D, E, A, B) :-
	register(knom(A,
		      B,
		      3,
		      G,
		      z(H, [np]),
		      rzecz,
		      @ @ @ @ @0),
		 C,
		 D,
		 no46,
		 [E/formarzecz(A, B)],
		 F),
	knom(C,
	     D,
	     F,
	     A,
	     B,
	     3,
	     G,
	     z(H, [np]),
	     rzecz,
	     @ @ @ @ @0).

zaimwzg(D, E, F, rzecz, B, C, 3, A) :-
	rowne(A, [co, kto, który]),
	register(knom(B,
		      C,
		      3,
		      H,
		      z(I, [A]),
		      wz,
		      @ @ @ @ @0),
		 D,
		 E,
		 no47,
		 [F/zaimwzg(rzecz, B, C, 3, A)],
		 G),
	knom(D,
	     E,
	     G,
	     B,
	     C,
	     3,
	     H,
	     z(I, [A]),
	     wz,
	     @ @ @ @ @0).

zaimwzg(C, D, E, przym, A, B, 3, wz) :-
	register(kprzym(A,
			B,
			row,
			G,
			z(H, [jaki]),
			wz,
			@ @ @ @ @0),
		 C,
		 D,
		 pt31,
		 [E/zaimwzg(przym, A, B, 3, wz)],
		 F),
	kprzym(C,
	       D,
	       F,
	       A,
	       B,
	       row,
	       G,
	       z(H, [jaki]),
	       wz,
	       @ @ @ @ @0).

kptno(I, J, K, A, B, C, D, E, F, G, @H) :-
	register(fpt(A,
		     B,
		     C,
		     D,
		     E,
		     F,
		     G,
		     H),
		 I,
		 J,
		 pt1,
		 
		 [ K/kptno(A, B, C, D, E, F, G, @H)
		 ],
		 L),
	fpt(I,
	    J,
	    L,
	    A,
	    B,
	    C,
	    D,
	    E,
	    F,
	    G,
	    H).

kptno(J, A, L, D, E, F, G, H, I, tk, M) :-
	goal(fzd(C, nk, O, P, Q, R, ni, S),
	     A,
	     B,
	     N),
	goal(przec, B, K, T),
	rowne(C, [jakby, jaki, że, żeby]),
	register(fpt(D,
		     E,
		     F,
		     G,
		     H,
		     I,
		     tk,
		     @ @ @ @ @0),
		 J,
		 K,
		 pt2,
		 
		 [ L/kptno(D, E, F, G, H, I, tk, M),
		   A,
		   N/fzd(C, nk, O, P, Q, R, ni, S),
		   B,
		   T/przec
		 ],
		 U),
	fpt(J,
	    K,
	    U,
	    D,
	    E,
	    F,
	    G,
	    H,
	    I,
	    tk,
	    @ @ @ @ @0).

kptpm(I, J, K, A, B, C, D, E, F, G, @H) :-
	register(kptno(A,
		       B,
		       C,
		       D,
		       E,
		       F,
		       G,
		       H),
		 I,
		 J,
		 pt3,
		 
		 [ K/kptpm(A, B, C, D, E, F, G, @H)
		 ],
		 L),
	kptno(I,
	      J,
	      L,
	      A,
	      B,
	      C,
	      D,
	      E,
	      F,
	      G,
	      H).

kptpm(N, A, P, H, I, J, K, L, z(D, B), G, Q) :-
	goal(fno(S,
		 T,
		 U,
		 V,
		 ni,
		 z(E, C),
		 F,
		 W),
	     A,
	     O,
	     R),
	zplubnp(B, C, D, E),
	oblkl(M, F, G),
	register(kptno(H,
		       I,
		       J,
		       K,
		       L,
		       z(Y, [p]),
		       M,
		       @ @ @ @ @0),
		 N,
		 O,
		 pt4,
		 
		 [ P/kptpm(H, I, J, K, L, z(D, B), G, Q),
		   A,
		   R/fno(S, T, U, V, ni, z(E, C), F, W)
		 ],
		 X),
	kptno(N,
	      O,
	      X,
	      H,
	      I,
	      J,
	      K,
	      L,
	      z(Y, [p]),
	      M,
	      @ @ @ @ @0).

kptpm(O, C, Q, G, H, I, J, K, z(L, A), B, R) :-
	zrowne(A, [co, jaki, kto, który, np], M),
	rozne(B, wz),
	goal(fno(T,
		 U,
		 V,
		 W,
		 ni,
		 z(E, D),
		 F,
		 X),
	     C,
	     P,
	     S),
	zrowne(D, [np], E),
	oblkl(N, F, B),
	register(kptno(G,
		       H,
		       I,
		       J,
		       K,
		       z(L, M),
		       N,
		       @ @ @ @ @0),
		 O,
		 P,
		 pt6,
		 
		 [ Q/kptpm(G, H, I, J, K, z(L, A), B, R),
		   C,
		   S/fno(T, U, V, W, ni, z(E, D), F, X)
		 ],
		 Y),
	kptno(O,
	      P,
	      Y,
	      G,
	      H,
	      I,
	      J,
	      K,
	      z(L, M),
	      N,
	      @ @ @ @ @0).

kptpm(O, B, Q, G, H, I, J, K, z(L, A), F, R) :-
	zrowne(A, [pz], M),
	goal(fno(T,
		 U,
		 V,
		 W,
		 ni,
		 z(D, C),
		 E,
		 X),
	     B,
	     P,
	     S),
	zrowne(C, [np, p], D),
	oblkl(N, E, F),
	register(kptno(G,
		       H,
		       I,
		       J,
		       K,
		       z(L, M),
		       N,
		       @ @ @ @ @0),
		 O,
		 P,
		 pt8,
		 
		 [ Q/kptpm(G, H, I, J, K, z(L, A), F, R),
		   B,
		   S/fno(T, U, V, W, ni, z(D, C), E, X)
		 ],
		 Y),
	kptno(O,
	      P,
	      Y,
	      G,
	      H,
	      I,
	      J,
	      K,
	      z(L, M),
	      N,
	      @ @ @ @ @0).

kptps(I, J, K, A, B, C, D, E, F, G, @H) :-
	register(kptpm(A,
		       B,
		       C,
		       D,
		       E,
		       F,
		       G,
		       H),
		 I,
		 J,
		 pt10,
		 
		 [ K/kptps(A, B, C, D, E, F, G, @H)
		 ],
		 L),
	kptpm(I,
	      J,
	      L,
	      A,
	      B,
	      C,
	      D,
	      E,
	      F,
	      G,
	      H).

kptps(L, A, N, F, G, H, I, J, B, E, O) :-
	goal(fpm(Q, R, S, ni, C, D),
	     A,
	     M,
	     P),
	zplubnp(B, C, _, _),
	oblkl(K, D, E),
	register(kptpm(F,
		       G,
		       H,
		       I,
		       J,
		       z(U, [p]),
		       K,
		       @ @ @ @ @0),
		 L,
		 M,
		 pt11,
		 
		 [ N/kptps(F, G, H, I, J, B, E, O),
		   A,
		   P/fpm(Q, R, S, ni, C, D)
		 ],
		 T),
	kptpm(L,
	      M,
	      T,
	      F,
	      G,
	      H,
	      I,
	      J,
	      z(U, [p]),
	      K,
	      @ @ @ @ @0).

kptps(O, B, Q, G, H, I, J, K, z(L, A), F, R) :-
	zrowne(A, [co, jaki, kto, który, np], M),
	goal(fpm(T, U, V, ni, z(D, C), E),
	     B,
	     P,
	     S),
	zrowne(C, [np], D),
	oblkl(N, E, F),
	register(kptpm(G,
		       H,
		       I,
		       J,
		       K,
		       z(L, M),
		       N,
		       @ @ @ @ @0),
		 O,
		 P,
		 pt13,
		 
		 [ Q/kptps(G, H, I, J, K, z(L, A), F, R),
		   B,
		   S/fpm(T, U, V, ni, z(D, C), E)
		 ],
		 W),
	kptpm(O,
	      P,
	      W,
	      G,
	      H,
	      I,
	      J,
	      K,
	      z(L, M),
	      N,
	      @ @ @ @ @0).

kptps(O, B, Q, G, H, I, J, K, z(L, A), F, R) :-
	zrowne(A, [pz], M),
	goal(fpm(T, U, V, ni, z(D, C), E),
	     B,
	     P,
	     S),
	zrowne(C, [np, p], D),
	oblkl(N, E, F),
	register(kptpm(G,
		       H,
		       I,
		       J,
		       K,
		       z(L, M),
		       N,
		       @ @ @ @ @0),
		 O,
		 P,
		 pt15,
		 
		 [ Q/kptps(G, H, I, J, K, z(L, A), F, R),
		   B,
		   S/fpm(T, U, V, ni, z(D, C), E)
		 ],
		 W),
	kptpm(O,
	      P,
	      W,
	      G,
	      H,
	      I,
	      J,
	      K,
	      z(L, M),
	      N,
	      @ @ @ @ @0).

kptink(I, J, K, A, B, C, D, E, F, G, @H) :-
	register(kptps(A,
		       B,
		       C,
		       D,
		       E,
		       F,
		       G,
		       H),
		 I,
		 J,
		 pt17,
		 
		 [ K/kptink(A, B, C, D, E, F, G, @H)
		 ],
		 L),
	kptps(I,
	      J,
	      L,
	      A,
	      B,
	      C,
	      D,
	      E,
	      F,
	      G,
	      H).

kptink(L, A, N, F, G, H, I, J, B, E, O) :-
	goal(fps(Q, R, ni, C, D, S),
	     A,
	     M,
	     P),
	zplubnp(B, C, _, _),
	oblkl(K, D, E),
	register(kptps(F,
		       G,
		       H,
		       I,
		       J,
		       z(U, [p]),
		       K,
		       @ @ @ @ @0),
		 L,
		 M,
		 pt18,
		 
		 [ N/kptink(F, G, H, I, J, B, E, O),
		   A,
		   P/fps(Q, R, ni, C, D, S)
		 ],
		 T),
	kptps(L,
	      M,
	      T,
	      F,
	      G,
	      H,
	      I,
	      J,
	      z(U, [p]),
	      K,
	      @ @ @ @ @0).

kptink(O, B, Q, G, H, I, J, K, z(L, A), F, R) :-
	zrowne(A, [co, jaki, kto, który, np], M),
	goal(fps(T, U, ni, z(D, C), E, V),
	     B,
	     P,
	     S),
	zrowne(C, [np], D),
	oblkl(N, E, F),
	register(kptps(G,
		       H,
		       I,
		       J,
		       K,
		       z(L, M),
		       N,
		       @ @ @ @ @0),
		 O,
		 P,
		 pt20,
		 
		 [ Q/kptink(G, H, I, J, K, z(L, A), F, R),
		   B,
		   S/fps(T, U, ni, z(D, C), E, V)
		 ],
		 W),
	kptps(O,
	      P,
	      W,
	      G,
	      H,
	      I,
	      J,
	      K,
	      z(L, M),
	      N,
	      @ @ @ @ @0).

kptink(N, C, P, H, I, J, K, L, z(B, A), G, Q) :-
	zrowne(A, [co, jaki, kto, który, np], B),
	goal(fps(S, T, ni, z(E, D), F, U),
	     C,
	     O,
	     R),
	zrowne(D, [np, p], E),
	oblkl(M, F, G),
	register(kptps(H,
		       I,
		       J,
		       K,
		       L,
		       z(W, [pz]),
		       M,
		       @ @ @ @ @0),
		 N,
		 O,
		 pt22,
		 
		 [ P/kptink(H, I, J, K, L, z(B, A), G, Q),
		   C,
		   R/fps(S, T, ni, z(E, D), F, U)
		 ],
		 V),
	kptps(N,
	      O,
	      V,
	      H,
	      I,
	      J,
	      K,
	      L,
	      z(W, [pz]),
	      M,
	      @ @ @ @ @0).

kprzym(L, B, N, E, F, G, H, z(I, A), K, O) :-
	zrozne(A, [jaki], J),
	goal(spoj(D, C, ni), B, M, P),
	rowne(C, [bowiem, natomiast, więc, zaś]),
	rowne(D, [pi, ri]),
	register(kptink(E,
			F,
			G,
			H,
			C,
			z(I, J),
			K,
			@ @ @ @ @0),
		 L,
		 M,
		 pt24,
		 
		 [ N/kprzym(E, F, G, H, z(I, A), K, O),
		   B,
		   P/spoj(D, C, ni)
		 ],
		 Q),
	kptink(L,
	       M,
	       Q,
	       E,
	       F,
	       G,
	       H,
	       C,
	       z(I, J),
	       K,
	       @ @ @ @ @0).

kprzym(J, K, L, B, C, D, E, z(F, A), H, @I) :-
	zrozne(A, [jaki], G),
	register(kptink(B,
			C,
			D,
			E,
			ni,
			z(F, G),
			H,
			I),
		 J,
		 K,
		 pt25,
		 
		 [ L/kprzym(B, C, D, E, z(F, A), H, @I)
		 ],
		 M),
	kptink(J,
	       K,
	       M,
	       B,
	       C,
	       D,
	       E,
	       ni,
	       z(F, G),
	       H,
	       I).

kprzym(I, J, K, B, C, D, E, z(F, A), wz, @H) :-
	zrowne(A, [jaki], G),
	register(kptink(B,
			C,
			D,
			E,
			ni,
			z(F, G),
			wz,
			H),
		 I,
		 J,
		 pt26,
		 
		 [ K/kprzym(B, C, D, E, z(F, A), wz, @H)
		 ],
		 L),
	kptink(I,
	       J,
	       L,
	       B,
	       C,
	       D,
	       E,
	       ni,
	       z(F, G),
	       wz,
	       H).

formaprzym(D, E, F, A, B, C) :-
	register(kprzym(A,
			B,
			C,
			H,
			z(I, [np]),
			przym,
			@ @ @ @ @0),
		 D,
		 E,
		 pt30,
		 [F/formaprzym(A, B, C)],
		 G),
	kprzym(D,
	       E,
	       G,
	       A,
	       B,
	       C,
	       H,
	       z(I, [np]),
	       przym,
	       @ @ @ @ @0).

kpspm(G, H, I, A, B, C, D, E, @F) :-
	register(fps(A, B, C, D, E, F),
		 G,
		 H,
		 ps1,
		 
		 [ I/kpspm(A, B, C, D, E, @F)
		 ],
		 J),
	fps(G,
	    H,
	    J,
	    A,
	    B,
	    C,
	    D,
	    E,
	    F).

kpspm(I, A, K, D, E, F, G, H, L) :-
	goal(fzd(C, nk, N, O, P, Q, ni, R),
	     A,
	     B,
	     M),
	goal(przec, B, J, S),
	rowne(C, [jak, jakby, że, żeby]),
	register(fps(D, E, F, G, H, @ @ @ @0),
		 I,
		 J,
		 ps2,
		 
		 [ K/kpspm(D, E, F, G, H, L),
		   A,
		   M/fzd(C, nk, N, O, P, Q, ni, R),
		   B,
		   S/przec
		 ],
		 T),
	fps(I,
	    J,
	    T,
	    D,
	    E,
	    F,
	    G,
	    H,
	    @ @ @ @0).

kpsps(G, H, I, A, B, C, D, E, @F) :-
	register(kpspm(A, B, C, D, E, F),
		 G,
		 H,
		 ps3,
		 
		 [ I/kpsps(A, B, C, D, E, @F)
		 ],
		 J),
	kpspm(G,
	      H,
	      J,
	      A,
	      B,
	      C,
	      D,
	      E,
	      F).

kpsps(L, A, N, H, I, J, z(D, B), G, O) :-
	goal(fpm(Q, R, S, ni, z(E, C), F),
	     A,
	     M,
	     P),
	zplubnp(B, C, D, E),
	oblkl(K, F, G),
	register(kpspm(H,
		       I,
		       J,
		       z(U, [p]),
		       K,
		       @ @ @ @0),
		 L,
		 M,
		 ps4,
		 
		 [ N/kpsps(H, I, J, z(D, B), G, O),
		   A,
		   P/fpm(Q, R, S, ni, z(E, C), F)
		 ],
		 T),
	kpspm(L,
	      M,
	      T,
	      H,
	      I,
	      J,
	      z(U, [p]),
	      K,
	      @ @ @ @0).

kpsps(M, B, O, G, H, I, z(J, A), F, P) :-
	zrowne(A, [co, jaki, kto, który, np], K),
	goal(fpm(R, S, T, ni, z(D, C), E),
	     B,
	     N,
	     Q),
	zrowne(C, [np], D),
	oblkl(L, E, F),
	register(kpspm(G,
		       H,
		       I,
		       z(J, K),
		       L,
		       @ @ @ @0),
		 M,
		 N,
		 ps6,
		 
		 [ O/kpsps(G, H, I, z(J, A), F, P),
		   B,
		   Q/fpm(R, S, T, ni, z(D, C), E)
		 ],
		 U),
	kpspm(M,
	      N,
	      U,
	      G,
	      H,
	      I,
	      z(J, K),
	      L,
	      @ @ @ @0).

kpsps(M, B, O, G, H, I, z(J, A), F, P) :-
	zrowne(A, [pz], K),
	goal(fpm(R, S, T, ni, z(D, C), E),
	     B,
	     N,
	     Q),
	zrowne(C, [np, p], D),
	oblkl(L, E, F),
	register(kpspm(G,
		       H,
		       I,
		       z(J, K),
		       L,
		       @ @ @ @0),
		 M,
		 N,
		 ps8,
		 
		 [ O/kpsps(G, H, I, z(J, A), F, P),
		   B,
		   Q/fpm(R, S, T, ni, z(D, C), E)
		 ],
		 U),
	kpspm(M,
	      N,
	      U,
	      G,
	      H,
	      I,
	      z(J, K),
	      L,
	      @ @ @ @0).

kpsink(G, H, I, A, B, C, D, E, @F) :-
	register(kpsps(A, B, C, D, E, F),
		 G,
		 H,
		 ps10,
		 
		 [ I/kpsink(A, B, C, D, E, @F)
		 ],
		 J),
	kpsps(G,
	      H,
	      J,
	      A,
	      B,
	      C,
	      D,
	      E,
	      F).

kpsink(L, A, N, H, I, J, z(D, B), G, O) :-
	goal(fps(Q, R, ni, z(E, C), F, S),
	     A,
	     M,
	     P),
	zplubnp(B, C, D, E),
	oblkl(K, F, G),
	register(kpsps(H,
		       I,
		       J,
		       z(U, [p]),
		       K,
		       @ @ @ @0),
		 L,
		 M,
		 ps11,
		 
		 [ N/kpsink(H, I, J, z(D, B), G, O),
		   A,
		   P/fps(Q, R, ni, z(E, C), F, S)
		 ],
		 T),
	kpsps(L,
	      M,
	      T,
	      H,
	      I,
	      J,
	      z(U, [p]),
	      K,
	      @ @ @ @0).

kpsink(M, B, O, G, H, I, z(J, A), F, P) :-
	zrowne(A, [co, jaki, kto, który, np], K),
	goal(fps(R, S, ni, z(D, C), E, T),
	     B,
	     N,
	     Q),
	zrowne(C, [np], D),
	oblkl(L, E, F),
	register(kpsps(G,
		       H,
		       I,
		       z(J, K),
		       L,
		       @ @ @ @0),
		 M,
		 N,
		 ps13,
		 
		 [ O/kpsink(G, H, I, z(J, A), F, P),
		   B,
		   Q/fps(R, S, ni, z(D, C), E, T)
		 ],
		 U),
	kpsps(M,
	      N,
	      U,
	      G,
	      H,
	      I,
	      z(J, K),
	      L,
	      @ @ @ @0).

kpsink(M, B, O, G, H, I, z(J, A), F, P) :-
	zrowne(A, [pz], K),
	goal(fps(R, S, ni, z(D, C), E, T),
	     B,
	     N,
	     Q),
	zrowne(C, [np, p], D),
	oblkl(L, E, F),
	register(kpsps(G,
		       H,
		       I,
		       z(J, K),
		       L,
		       @ @ @ @0),
		 M,
		 N,
		 ps15,
		 
		 [ O/kpsink(G, H, I, z(J, A), F, P),
		   B,
		   Q/fps(R, S, ni, z(D, C), E, T)
		 ],
		 U),
	kpsps(M,
	      N,
	      U,
	      G,
	      H,
	      I,
	      z(J, K),
	      L,
	      @ @ @ @0).

kprzysl(J, B, L, E, F, z(G, A), I, M) :-
	zrowne(A, [np, p, pz], H),
	goal(spoj(D, C, ni), B, K, N),
	rowne(C, [bowiem, natomiast, więc, zaś]),
	rowne(D, [pi, ri]),
	register(kpsink(E,
			F,
			C,
			z(G, H),
			I,
			@ @ @ @0),
		 J,
		 K,
		 ps17,
		 
		 [ L/kprzysl(E, F, z(G, A), I, M),
		   B,
		   N/spoj(D, C, ni)
		 ],
		 O),
	kpsink(J,
	       K,
	       O,
	       E,
	       F,
	       C,
	       z(G, H),
	       I,
	       @ @ @ @0).

kprzysl(H, I, J, B, C, z(D, A), F, @G) :-
	zrowne(A, [np, p, pz], E),
	register(kpsink(B, C, ni, z(D, E), F, G),
		 H,
		 I,
		 ps18,
		 
		 [ J/kprzysl(B, C, z(D, A), F, @G)
		 ],
		 K),
	kpsink(H,
	       I,
	       K,
	       B,
	       C,
	       ni,
	       z(D, E),
	       F,
	       G).

formaprzysl(B, C, D, A) :-
	register(kprzysl(A, F, z(G, [np]), H, @ @ @ @0),
		 B,
		 C,
		 ps22,
		 [D/formaprzysl(A)],
		 E),
	kprzysl(B,
		C,
		E,
		A,
		F,
		z(G, [np]),
		H,
		@ @ @ @0).

fzdsz(I, J, K, A, B, C, D, E, F, G, @H) :-
	register(fzd(A,
		     B,
		     C,
		     D,
		     E,
		     F,
		     G,
		     H),
		 I,
		 J,
		 zd1,
		 
		 [ K/fzdsz(A, B, C, D, E, F, G, @H)
		 ],
		 L),
	fzd(I,
	    J,
	    L,
	    A,
	    B,
	    C,
	    D,
	    E,
	    F,
	    G,
	    H).

fzdsz(L, B, N, A, F, G, H, I, J, K, O) :-
	rowne(A, [aż1, chociaż, czy, jak, jeśli, podczas, ponieważ, pz, że]),
	goal(przec, B, C, P),
	goal(spoj(rc, R, ni), C, D, Q),
	goal(fzdsz(A,
		   E,
		   T,
		   U,
		   V,
		   W,
		   ni,
		   X),
	     D,
	     M,
	     S),
	rozne(E, nk),
	rowne(E, [F, bp]),
	register(fzd(A,
		     F,
		     G,
		     H,
		     I,
		     J,
		     K,
		     @ @ @0),
		 L,
		 M,
		 zd3,
		 
		 [ N/fzdsz(A, F, G, H, I, J, K, O),
		   B,
		   P/przec,
		   C,
		   Q/spoj(rc, R, ni),
		   D,
		   S/fzdsz(A, E, T, U, V, W, ni, X)
		 ],
		 Y),
	fzd(L,
	    M,
	    Y,
	    A,
	    F,
	    G,
	    H,
	    I,
	    J,
	    K,
	    @ @ @0).

fzdsz(L, B, N, A, H, I, E, F, J, K, O) :-
	rowne(A, [dopóki, zanim]),
	goal(przec, B, C, P),
	goal(spoj(rc, D, ni), C, G, Q),
	rowne(D, [alei, nie]),
	goal(fzdsz(A, bp, S, E, F, T, ni, U),
	     G,
	     M,
	     R),
	register(fzd(A,
		     H,
		     I,
		     E,
		     F,
		     J,
		     K,
		     @ @ @0),
		 L,
		 M,
		 zd5,
		 
		 [ N/fzdsz(A, H, I, E, F, J, K, O),
		   B,
		   P/przec,
		   C,
		   Q/spoj(rc, D, ni),
		   G,
		   R/fzdsz(A, bp, S, E, F, T, ni, U)
		 ],
		 V),
	fzd(L,
	    M,
	    V,
	    A,
	    H,
	    I,
	    E,
	    F,
	    J,
	    K,
	    @ @ @0).

fzdsz(L, B, N, A, G, H, E, I, J, K, O) :-
	rowne(A, [aż2, gdy]),
	goal(przec, B, C, P),
	goal(spoj(rc, D, ni), C, F, Q),
	rowne(D, [alei, nie]),
	goal(fzdsz(A, bp, S, E, T, U, ni, V),
	     F,
	     M,
	     R),
	register(fzd(A,
		     G,
		     H,
		     E,
		     I,
		     J,
		     K,
		     @ @ @0),
		 L,
		 M,
		 zd7,
		 
		 [ N/fzdsz(A, G, H, E, I, J, K, O),
		   B,
		   P/przec,
		   C,
		   Q/spoj(rc, D, ni),
		   F,
		   R/fzdsz(A, bp, S, E, T, U, ni, V)
		 ],
		 W),
	fzd(L,
	    M,
	    W,
	    A,
	    G,
	    H,
	    E,
	    I,
	    J,
	    K,
	    @ @ @0).

fzdsz(L, B, N, A, G, H, I, J, K, E, O) :-
	rowne(A, [co, jaki, kto, który]),
	goal(przec, B, C, P),
	goal(spoj(rc, D, ni), C, F, Q),
	rowne(D, [alei, nie]),
	goal(fzdsz(A,
		   bp,
		   S,
		   T,
		   U,
		   V,
		   E,
		   W),
	     F,
	     M,
	     R),
	register(fzd(A,
		     G,
		     H,
		     I,
		     J,
		     K,
		     E,
		     @ @ @0),
		 L,
		 M,
		 zd9,
		 
		 [ N/fzdsz(A, G, H, I, J, K, E, O),
		   B,
		   P/przec,
		   C,
		   Q/spoj(rc, D, ni),
		   F,
		   R/fzdsz(A, bp, S, T, U, V, E, W)
		 ],
		 X),
	fzd(L,
	    M,
	    X,
	    A,
	    G,
	    H,
	    I,
	    J,
	    K,
	    E,
	    @ @ @0).

fzdj(J, K, L, B, C, D, E, F, G, H, A, @I) :-
	rozne(A, lub),
	register(fzdsz(B,
		       C,
		       D,
		       E,
		       F,
		       G,
		       H,
		       I),
		 J,
		 K,
		 zd10,
		 
		 [ L/fzdj(B, C, D, E, F, G, H, A, @I)
		 ],
		 M),
	fzdsz(J,
	      K,
	      M,
	      B,
	      C,
	      D,
	      E,
	      F,
	      G,
	      H,
	      I).

fzdj(L, C, N, A, B, G, H, I, J, K, przec, O) :-
	rowne(A, [aż1, chociaż, czy, jak, jeśli, podczas, ponieważ, pz, że]),
	rozne(B, [nk, bp]),
	goal(przec, C, D, P),
	goal(spoj(szk, E, ni), D, F, Q),
	rozne(E, ani),
	goal(fzdkor(A,
		    B,
		    S,
		    T,
		    U,
		    V,
		    ni,
		    W),
	     F,
	     M,
	     R),
	register(fzdsz(A,
		       B,
		       G,
		       H,
		       I,
		       J,
		       K,
		       @ @ @0),
		 L,
		 M,
		 zd12,
		 
		 [ N/fzdj(A, B, G, H, I, J, K, przec, O),
		   C,
		   P/przec,
		   D,
		   Q/spoj(szk, E, ni),
		   F,
		   R/fzdkor(A, B, S, T, U, V, ni, W)
		 ],
		 X),
	fzdsz(L,
	      M,
	      X,
	      A,
	      B,
	      G,
	      H,
	      I,
	      J,
	      K,
	      @ @ @0).

fzdj(K, B, M, A, E, F, G, H, I, J, przec, N) :-
	rowne(A, [aż1, chociaż, czy, jak, jeśli, podczas, ponieważ, pz, że]),
	goal(spoj(szk, C, ni), B, D, O),
	rozne(C, ani),
	goal(fzdkor(A,
		    bp,
		    Q,
		    R,
		    S,
		    T,
		    ni,
		    U),
	     D,
	     L,
	     P),
	register(fzdsz(A,
		       E,
		       F,
		       G,
		       H,
		       I,
		       J,
		       @ @ @0),
		 K,
		 L,
		 zd14,
		 
		 [ M/fzdj(A, E, F, G, H, I, J, przec, N),
		   B,
		   O/spoj(szk, C, ni),
		   D,
		   P/fzdkor(A, bp, Q, R, S, T, ni, U)
		 ],
		 V),
	fzdsz(K,
	      L,
	      V,
	      A,
	      E,
	      F,
	      G,
	      H,
	      I,
	      J,
	      @ @ @0).

fzdj(I, C, K, A, D, E, F, G, H, B, przec, L) :-
	rowne(A, [dopóki, zanim]),
	goal(fzdkor(A,
		    bp,
		    N,
		    O,
		    P,
		    Q,
		    B,
		    R),
	     C,
	     J,
	     M),
	rozne(_, ani),
	register(fzdsz(A,
		       D,
		       E,
		       F,
		       G,
		       H,
		       B,
		       @ @ @0),
		 I,
		 J,
		 zd16,
		 
		 [ K/fzdj(A, D, E, F, G, H, B, przec, L),
		   C,
		   M/fzdkor(A, bp, N, O, P, Q, B, R)
		 ],
		 S),
	fzdsz(I,
	      J,
	      S,
	      A,
	      D,
	      E,
	      F,
	      G,
	      H,
	      B,
	      @ @ @0).

fzdj(I, C, K, A, D, E, F, G, H, B, przec, L) :-
	rowne(A, [aż2, gdy]),
	goal(fzdkor(A,
		    bp,
		    N,
		    O,
		    P,
		    Q,
		    B,
		    R),
	     C,
	     J,
	     M),
	rozne(_, ani),
	register(fzdsz(A,
		       D,
		       E,
		       F,
		       G,
		       H,
		       B,
		       @ @ @0),
		 I,
		 J,
		 zd18,
		 
		 [ K/fzdj(A, D, E, F, G, H, B, przec, L),
		   C,
		   M/fzdkor(A, bp, N, O, P, Q, B, R)
		 ],
		 S),
	fzdsz(I,
	      J,
	      S,
	      A,
	      D,
	      E,
	      F,
	      G,
	      H,
	      B,
	      @ @ @0).

fzdj(I, C, K, A, D, E, F, G, H, B, przec, L) :-
	rowne(A, [co, jaki, kto, który]),
	goal(fzdkor(A,
		    bp,
		    N,
		    O,
		    P,
		    Q,
		    B,
		    R),
	     C,
	     J,
	     M),
	rozne(_, ani),
	register(fzdsz(A,
		       D,
		       E,
		       F,
		       G,
		       H,
		       B,
		       @ @ @0),
		 I,
		 J,
		 zd20,
		 
		 [ K/fzdj(A, D, E, F, G, H, B, przec, L),
		   C,
		   M/fzdkor(A, bp, N, O, P, Q, B, R)
		 ],
		 S),
	fzdsz(I,
	      J,
	      S,
	      A,
	      D,
	      E,
	      F,
	      G,
	      H,
	      B,
	      @ @ @0).

fzdkor(K, C, M, A, B, F, G, H, I, J, N) :-
	rowne(A, [aż1, chociaż, czy, jak, jeśli, podczas, ponieważ, pz, że]),
	rozne(B, [nk, bp]),
	goal(przec, C, D, O),
	goal(fzdj(A,
		  B,
		  Q,
		  R,
		  S,
		  T,
		  ni,
		  E,
		  U),
	     D,
	     L,
	     P),
	rozne(E, [ani, przec]),
	register(fzdsz(A,
		       B,
		       F,
		       G,
		       H,
		       I,
		       J,
		       @ @ @0),
		 K,
		 L,
		 zd11,
		 
		 [ M/fzdkor(A, B, F, G, H, I, J, N),
		   C,
		   O/przec,
		   D,
		   P/fzdj(A, B, Q, R, S, T, ni, E, U)
		 ],
		 V),
	fzdsz(K,
	      L,
	      V,
	      A,
	      B,
	      F,
	      G,
	      H,
	      I,
	      J,
	      @ @ @0).

fzdkor(J, B, L, A, D, E, F, G, H, I, M) :-
	rowne(A, [aż1, chociaż, czy, jak, jeśli, podczas, ponieważ, pz, że]),
	goal(fzdj(A,
		  bp,
		  O,
		  P,
		  Q,
		  R,
		  ni,
		  C,
		  S),
	     B,
	     K,
	     N),
	rozne(C, [ani, przec]),
	register(fzdsz(A,
		       D,
		       E,
		       F,
		       G,
		       H,
		       I,
		       @ @ @0),
		 J,
		 K,
		 zd13,
		 
		 [ L/fzdkor(A, D, E, F, G, H, I, M),
		   B,
		   N/fzdj(A, bp, O, P, Q, R, ni, C, S)
		 ],
		 T),
	fzdsz(J,
	      K,
	      T,
	      A,
	      D,
	      E,
	      F,
	      G,
	      H,
	      I,
	      @ @ @0).

fzdkor(J, D, L, A, F, G, B, C, H, I, M) :-
	rowne(A, [dopóki, zanim]),
	goal(fzdj(A,
		  bp,
		  O,
		  B,
		  C,
		  P,
		  ni,
		  E,
		  Q),
	     D,
	     K,
	     N),
	rozne(E, [ani, przec]),
	register(fzdsz(A,
		       F,
		       G,
		       B,
		       C,
		       H,
		       I,
		       @ @ @0),
		 J,
		 K,
		 zd15,
		 
		 [ L/fzdkor(A, F, G, B, C, H, I, M),
		   D,
		   N/fzdj(A, bp, O, B, C, P, ni, E, Q)
		 ],
		 R),
	fzdsz(J,
	      K,
	      R,
	      A,
	      F,
	      G,
	      B,
	      C,
	      H,
	      I,
	      @ @ @0).

fzdkor(J, C, L, A, E, F, B, G, H, I, M) :-
	rowne(A, [aż2, gdy]),
	goal(fzdj(A,
		  bp,
		  O,
		  B,
		  P,
		  Q,
		  ni,
		  D,
		  R),
	     C,
	     K,
	     N),
	rozne(D, [ani, przec]),
	register(fzdsz(A,
		       E,
		       F,
		       B,
		       G,
		       H,
		       I,
		       @ @ @0),
		 J,
		 K,
		 zd17,
		 
		 [ L/fzdkor(A, E, F, B, G, H, I, M),
		   C,
		   N/fzdj(A, bp, O, B, P, Q, ni, D, R)
		 ],
		 S),
	fzdsz(J,
	      K,
	      S,
	      A,
	      E,
	      F,
	      B,
	      G,
	      H,
	      I,
	      @ @ @0).

fzdkor(J, C, L, A, E, F, G, H, I, B, M) :-
	rowne(A, [co, jaki, kto, który]),
	goal(fzdj(A,
		  bp,
		  O,
		  P,
		  Q,
		  R,
		  B,
		  D,
		  S),
	     C,
	     K,
	     N),
	rozne(D, [ani, przec]),
	register(fzdsz(A,
		       E,
		       F,
		       G,
		       H,
		       I,
		       B,
		       @ @ @0),
		 J,
		 K,
		 zd19,
		 
		 [ L/fzdkor(A, E, F, G, H, I, B, M),
		   C,
		   N/fzdj(A, bp, O, P, Q, R, B, D, S)
		 ],
		 T),
	fzdsz(J,
	      K,
	      T,
	      A,
	      E,
	      F,
	      G,
	      H,
	      I,
	      B,
	      @ @ @0).

fzdkor(I, J, K, A, B, C, D, E, F, G, @H) :-
	register(fzdj(A,
		      B,
		      C,
		      D,
		      E,
		      F,
		      G,
		      przec,
		      H),
		 I,
		 J,
		 zd21,
		 
		 [ K/fzdkor(A, B, C, D, E, F, G, @H)
		 ],
		 L),
	fzdj(I,
	     J,
	     L,
	     A,
	     B,
	     C,
	     D,
	     E,
	     F,
	     G,
	     przec,
	     H).

fzdkor(K, B, M, A, E, F, G, H, I, J, N) :-
	rowne(A, [aż1, chociaż, czy, jak, jeśli, podczas, ponieważ, pz, że]),
	goal(spoj(sz, przec, ni), B, C, O),
	goal(fzdkor(A,
		    D,
		    Q,
		    R,
		    S,
		    T,
		    ni,
		    U),
	     C,
	     L,
	     P),
	rowne(D, [E, bp]),
	register(fzdj(A,
		      E,
		      F,
		      G,
		      H,
		      I,
		      J,
		      przec,
		      @ @ @0),
		 K,
		 L,
		 zd24,
		 
		 [ M/fzdkor(A, E, F, G, H, I, J, N),
		   B,
		   O/spoj(sz, przec, ni),
		   C,
		   P/fzdkor(A, D, Q, R, S, T, ni, U)
		 ],
		 V),
	fzdj(K,
	     L,
	     V,
	     A,
	     E,
	     F,
	     G,
	     H,
	     I,
	     J,
	     przec,
	     @ @ @0).

fzdkor(K, B, M, A, E, F, G, H, I, J, N) :-
	rowne(A, [aż1, chociaż, czy, jak, jeśli, podczas, ponieważ, pz, że]),
	goal(spoj(sz, przec, ni), B, C, O),
	goal(fzdj(A,
		  D,
		  Q,
		  R,
		  S,
		  T,
		  ni,
		  przec,
		  U),
	     C,
	     L,
	     P),
	rowne(D, [E, bp]),
	register(fzdj(A,
		      E,
		      F,
		      G,
		      H,
		      I,
		      J,
		      przec,
		      @ @ @0),
		 K,
		 L,
		 zd25,
		 
		 [ M/fzdkor(A, E, F, G, H, I, J, N),
		   B,
		   O/spoj(sz, przec, ni),
		   C,
		   P/fzdj(A, D, Q, R, S, T, ni, przec, U)
		 ],
		 V),
	fzdj(K,
	     L,
	     V,
	     A,
	     E,
	     F,
	     G,
	     H,
	     I,
	     J,
	     przec,
	     @ @ @0).

fzdkor(J, B, L, A, F, G, C, D, H, I, M) :-
	rowne(A, [dopóki, zanim]),
	goal(spoj(sz, przec, ni), B, E, N),
	goal(fzdkor(A, bp, P, C, D, Q, ni, R),
	     E,
	     K,
	     O),
	register(fzdj(A,
		      F,
		      G,
		      C,
		      D,
		      H,
		      I,
		      przec,
		      @ @ @0),
		 J,
		 K,
		 zd28,
		 
		 [ L/fzdkor(A, F, G, C, D, H, I, M),
		   B,
		   N/spoj(sz, przec, ni),
		   E,
		   O/fzdkor(A, bp, P, C, D, Q, ni, R)
		 ],
		 S),
	fzdj(J,
	     K,
	     S,
	     A,
	     F,
	     G,
	     C,
	     D,
	     H,
	     I,
	     przec,
	     @ @ @0).

fzdkor(J, B, L, A, F, G, C, D, H, I, M) :-
	rowne(A, [dopóki, zanim]),
	goal(spoj(sz, przec, ni), B, E, N),
	goal(fzdj(A,
		  bp,
		  P,
		  C,
		  D,
		  Q,
		  ni,
		  przec,
		  R),
	     E,
	     K,
	     O),
	register(fzdj(A,
		      F,
		      G,
		      C,
		      D,
		      H,
		      I,
		      przec,
		      @ @ @0),
		 J,
		 K,
		 zd29,
		 
		 [ L/fzdkor(A, F, G, C, D, H, I, M),
		   B,
		   N/spoj(sz, przec, ni),
		   E,
		   O/fzdj(A, bp, P, C, D, Q, ni, przec, R)
		 ],
		 S),
	fzdj(J,
	     K,
	     S,
	     A,
	     F,
	     G,
	     C,
	     D,
	     H,
	     I,
	     przec,
	     @ @ @0).

fzdkor(J, B, L, A, E, F, C, G, H, I, M) :-
	rowne(A, [aż2, gdy]),
	goal(spoj(sz, przec, ni), B, D, N),
	goal(fzdkor(A, bp, P, C, Q, R, ni, S),
	     D,
	     K,
	     O),
	register(fzdj(A,
		      E,
		      F,
		      C,
		      G,
		      H,
		      I,
		      przec,
		      @ @ @0),
		 J,
		 K,
		 zd32,
		 
		 [ L/fzdkor(A, E, F, C, G, H, I, M),
		   B,
		   N/spoj(sz, przec, ni),
		   D,
		   O/fzdkor(A, bp, P, C, Q, R, ni, S)
		 ],
		 T),
	fzdj(J,
	     K,
	     T,
	     A,
	     E,
	     F,
	     C,
	     G,
	     H,
	     I,
	     przec,
	     @ @ @0).

fzdkor(J, B, L, A, E, F, C, G, H, I, M) :-
	rowne(A, [aż2, gdy]),
	goal(spoj(sz, przec, ni), B, D, N),
	goal(fzdj(A,
		  bp,
		  P,
		  C,
		  Q,
		  R,
		  ni,
		  przec,
		  S),
	     D,
	     K,
	     O),
	register(fzdj(A,
		      E,
		      F,
		      C,
		      G,
		      H,
		      I,
		      przec,
		      @ @ @0),
		 J,
		 K,
		 zd33,
		 
		 [ L/fzdkor(A, E, F, C, G, H, I, M),
		   B,
		   N/spoj(sz, przec, ni),
		   D,
		   O/fzdj(A, bp, P, C, Q, R, ni, przec, S)
		 ],
		 T),
	fzdj(J,
	     K,
	     T,
	     A,
	     E,
	     F,
	     C,
	     G,
	     H,
	     I,
	     przec,
	     @ @ @0).

fzdkor(J, B, L, A, E, F, G, H, I, C, M) :-
	rowne(A, [co, jaki, kto, który]),
	goal(spoj(sz, przec, ni), B, D, N),
	goal(fzdkor(A,
		    bp,
		    P,
		    Q,
		    R,
		    S,
		    C,
		    T),
	     D,
	     K,
	     O),
	register(fzdj(A,
		      E,
		      F,
		      G,
		      H,
		      I,
		      C,
		      przec,
		      @ @ @0),
		 J,
		 K,
		 zd36,
		 
		 [ L/fzdkor(A, E, F, G, H, I, C, M),
		   B,
		   N/spoj(sz, przec, ni),
		   D,
		   O/fzdkor(A, bp, P, Q, R, S, C, T)
		 ],
		 U),
	fzdj(J,
	     K,
	     U,
	     A,
	     E,
	     F,
	     G,
	     H,
	     I,
	     C,
	     przec,
	     @ @ @0).

fzdkor(J, B, L, A, E, F, G, H, I, C, M) :-
	rowne(A, [co, jaki, kto, który]),
	goal(spoj(sz, przec, ni), B, D, N),
	goal(fzdj(A,
		  bp,
		  P,
		  Q,
		  R,
		  S,
		  C,
		  przec,
		  T),
	     D,
	     K,
	     O),
	register(fzdj(A,
		      E,
		      F,
		      G,
		      H,
		      I,
		      C,
		      przec,
		      @ @ @0),
		 J,
		 K,
		 zd37,
		 
		 [ L/fzdkor(A, E, F, G, H, I, C, M),
		   B,
		   N/spoj(sz, przec, ni),
		   D,
		   O/fzdj(A, bp, P, Q, R, S, C, przec, T)
		 ],
		 U),
	fzdj(J,
	     K,
	     U,
	     A,
	     E,
	     F,
	     G,
	     H,
	     I,
	     C,
	     przec,
	     @ @ @0).

kor(J, A, L, D, I) :-
	goal(przec, A, B, M),
	goal(fzde(C, E, F, G, H, ni),
	     B,
	     K,
	     N),
	register(fzdkor(C,
			D,
			E,
			F,
			G,
			H,
			I,
			@ @ @0),
		 J,
		 K,
		 zd38,
		 
		 [ L/kor(D, I),
		   A,
		   M/przec,
		   B,
		   N/fzde(C, E, F, G, H, ni)
		 ],
		 O),
	fzdkor(J,
	       K,
	       O,
	       C,
	       D,
	       E,
	       F,
	       G,
	       H,
	       I,
	       @ @ @0).

przecsp(H, A, J) :-
	goal(fzde(B, C, D, E, F, G),
	     A,
	     I,
	     K),
	register(fzdkor(B,
			nk,
			C,
			D,
			E,
			F,
			G,
			@ @ @0),
		 H,
		 I,
		 zd39,
		 
		 [ J/przecsp,
		   A,
		   K/fzde(B, C, D, E, F, G)
		 ],
		 L),
	fzdkor(H,
	       I,
	       L,
	       B,
	       nk,
	       C,
	       D,
	       E,
	       F,
	       G,
	       @ @ @0).

fzde(G, H, I, A, B, C, D, E, F) :-
	register(fzdkor(A,
			bp,
			B,
			C,
			D,
			E,
			F,
			@ @ @0),
		 G,
		 H,
		 zd40,
		 
		 [ I/fzde(A, B, C, D, E, F)
		 ],
		 J),
	fzdkor(G,
	       H,
	       J,
	       A,
	       bp,
	       B,
	       C,
	       D,
	       E,
	       F,
	       @ @ @0).

spoj1(F, A, H, D, E) :-
	goal(spoj(C, B, ni), A, G, I),
	rowne(B, [bowiem, natomiast, więc, zaś]),
	rowne(C, [pi, ri]),
	register(spoj(D, E, B),
		 F,
		 G,
		 spoj1,
		 
		 [ H/spoj1(D, E),
		   A,
		   I/spoj(C, B, ni)
		 ],
		 J),
	spoj(F, G, J, D, E, B).

spoj1(C, D, E, A, B) :-
	register(spoj(A, B, ni),
		 C,
		 D,
		 spoj2,
		 [E/spoj1(A, B)],
		 F),
	spoj(C, D, F, A, B, ni).

spojnik(B, C, D, A) :-
	rowne(A, [nie, tak, zarówno]),
	register(spoj1(rl, A),
		 B,
		 C,
		 spoj3,
		 [D/spojnik(A)],
		 E),
	spoj1(B, C, E, rl, A).

spojnik(B, C, D, A) :-
	rowne(A, [ale, lecz]),
	register(spoj1(rp, nie),
		 B,
		 C,
		 spoj5,
		 [D/spojnik(A)],
		 E),
	spoj1(B, C, E, rp, nie).

spojnik(D, A, F, B) :-
	goal(partykula(C), A, E, G),
	rowne(B, [ale, lecz]),
	rowne(C, [i, również, także]),
	register(spoj1(rp, nietylko),
		 D,
		 E,
		 spoj6,
		 [F/spojnik(B), A, G/partykula(C)],
		 H),
	spoj1(D, E, H, rp, nietylko).

spojnik(B, C, D, jak) :-
	rowne(A, [tak, zarówno]),
	register(spoj1(rp, A),
		 B,
		 C,
		 spoj7,
		 [D/spojnik(jak)],
		 E),
	spoj1(B, C, E, rp, A).

spojnik(D, A, F, jak) :-
	goal(partykula(B), A, E, G),
	rowne(C, [tak, zarówno]),
	rowne(B, [i, też]),
	register(spoj1(rp, C),
		 D,
		 E,
		 spoj8,
		 [F/spojnik(jak), A, G/partykula(B)],
		 H),
	spoj1(D, E, H, rp, C).

spojnik(B, C, D, A) :-
	rowne(A, [a, ale, lecz]),
	register(spoj1(rc, a),
		 B,
		 C,
		 spoj9,
		 [D/spojnik(A)],
		 E),
	spoj1(B, C, E, rc, a).

spojnik(D, A, F, B) :-
	goal(partykula(C), A, E, G),
	rowne(B, [a, ale, lecz]),
	rowne(C, [i, nawet, również, także]),
	register(spoj1(rc, alei),
		 D,
		 E,
		 spoj10,
		 [F/spojnik(B), A, G/partykula(C)],
		 H),
	spoj1(D, E, H, rc, alei).

spojnik(A, B, C, natomiast) :-
	register(spoj1(rc, natomiast),
		 A,
		 B,
		 spoj11,
		 [C/spojnik(natomiast)],
		 D),
	spoj1(A, B, D, rc, natomiast).

spojnik(C, A, E, B) :-
	goal(partykula(nie), A, D, F),
	rowne(B, [a, ale]),
	register(spoj1(rc, nie),
		 C,
		 D,
		 spoj12,
		 [E/spojnik(B), A, F/partykula(nie)],
		 G),
	spoj1(C, D, G, rc, nie).

spojnik(B, C, D, A) :-
	rowne(A, [natomiast, zaś]),
	register(spoj1(ri, A),
		 B,
		 C,
		 spoj14,
		 [D/spojnik(A)],
		 E),
	spoj1(B, C, E, ri, A).

spojnik(C, D, E, A) :-
	rowne(B, [sz, szk]),
	rowne(A, [albo, bądź, i, lub]),
	register(spoj1(B, A),
		 C,
		 D,
		 spoj15,
		 [E/spojnik(A)],
		 F),
	spoj1(C, D, F, B, A).

spojnik(C, D, E, A) :-
	rowne(B, [sz, szk]),
	rowne(A, [ani, ni]),
	register(spoj1(B, ani),
		 C,
		 D,
		 spoj16,
		 [E/spojnik(A)],
		 F),
	spoj1(C, D, F, B, ani).

spojnik(D, A, F, B) :-
	goal(partykula(C), A, E, G),
	rowne(B, [albo, bądź, lub]),
	rowne(C, [nawet, też]),
	register(spoj1(szk, B),
		 D,
		 E,
		 spoj18,
		 [F/spojnik(B), A, G/partykula(C)],
		 H),
	spoj1(D, E, H, szk, B).

spojnik(D, A, F, B) :-
	goal(partykula(C), A, E, G),
	rowne(B, [ani, ni]),
	rowne(C, [nawet, też]),
	register(spoj1(szk, ani),
		 D,
		 E,
		 spoj19,
		 [F/spojnik(B), A, G/partykula(C)],
		 H),
	spoj1(D, E, H, szk, ani).

spojnik(C, A, E, i) :-
	goal(partykula(B), A, D, F),
	rowne(B, [nawet, także]),
	register(spoj1(szk, i),
		 C,
		 D,
		 spoj20,
		 [E/spojnik(i), A, F/partykula(B)],
		 G),
	spoj1(C, D, G, szk, i).

spojnik(A, B, C, oraz) :-
	register(spoj1(szk, i),
		 A,
		 B,
		 spoj21,
		 [C/spojnik(oraz)],
		 D),
	spoj1(A, B, D, szk, i).

spojnik(C, D, E, A) :-
	rowne(B, [pl, pp]),
	rowne(A, [dopóty, póty]),
	register(spoj1(B, dopóki),
		 C,
		 D,
		 spoj22,
		 [E/spojnik(A)],
		 F),
	spoj1(C, D, F, B, dopóki).

spojnik(C, D, E, A) :-
	rowne(B, [pl, pp]),
	rowne(A, [wówczas, wtedy]),
	register(spoj1(B, gdy),
		 C,
		 D,
		 spoj23,
		 [E/spojnik(A)],
		 F),
	spoj1(C, D, F, B, gdy).

spojnik(B, C, D, jednak) :-
	rowne(A, [chociaż, choćby]),
	register(spoj1(pp, A),
		 B,
		 C,
		 spoj24,
		 [D/spojnik(jednak)],
		 E),
	spoj1(B, C, E, pp, A).

spojnik(C, A, E, to) :-
	goal(spojnik(jednak), A, D, F),
	rowne(B, [chociaż, choćby]),
	register(spoj1(pp, B),
		 C,
		 D,
		 spoj25,
		 [E/spojnik(to), A, F/spojnik(jednak)],
		 G),
	spoj1(C, D, G, pp, B).

spojnik(B, C, D, to) :-
	rowne(A, [chociaż, choćby, gdyby, jeśli]),
	register(spoj1(pp, A),
		 B,
		 C,
		 spoj26,
		 [D/spojnik(to)],
		 E),
	spoj1(B, C, E, pp, A).

spojnik(B, C, D, A) :-
	rowne(A, [albowiem, bo, gdyż]),
	register(spoj1(pc, bo),
		 B,
		 C,
		 spoj27,
		 [D/spojnik(A)],
		 E),
	spoj1(B, C, E, pc, bo).

spojnik(C, D, E, A) :-
	rowne(B, [pc, pi]),
	rowne(A, [przeto, więc, zatem]),
	register(spoj1(B, więc),
		 C,
		 D,
		 spoj28,
		 [E/spojnik(A)],
		 F),
	spoj1(C, D, F, B, więc).

spojnik(A, B, C, toteż) :-
	register(spoj1(pc, więc),
		 A,
		 B,
		 spoj29,
		 [C/spojnik(toteż)],
		 D),
	spoj1(A, B, D, pc, więc).

spojnik(A, B, C, bowiem) :-
	register(spoj1(pi, bowiem),
		 A,
		 B,
		 spoj30,
		 [C/spojnik(bowiem)],
		 D),
	spoj1(A, B, D, pi, bowiem).

spojnik(B, C, D, aż) :-
	rowne(A, [aż1, aż2]),
	register(spoj1(po, A),
		 B,
		 C,
		 spoj31,
		 [D/spojnik(aż)],
		 E),
	spoj1(B, C, E, po, A).

spojnik(B, C, D, A) :-
	rowne(A, [czy, jak, jakby, jakoby]),
	register(spoj1(po, A),
		 B,
		 C,
		 spoj32,
		 [D/spojnik(A)],
		 E),
	spoj1(B, C, E, po, A).

spojnik(B, C, D, A) :-
	rowne(A, [chociaż, choć]),
	register(spoj1(po, chociaż),
		 B,
		 C,
		 spoj33,
		 [D/spojnik(A)],
		 E),
	spoj1(B, C, E, po, chociaż).

spojnik(B, C, D, A) :-
	rowne(A, [chociażby, choćby]),
	register(spoj1(po, choćby),
		 B,
		 C,
		 spoj35,
		 [D/spojnik(A)],
		 E),
	spoj1(B, C, E, po, choćby).

spojnik(B, C, D, A) :-
	rowne(A, [dopóki, póki]),
	register(spoj1(po, dopóki),
		 B,
		 C,
		 spoj36,
		 [D/spojnik(A)],
		 E),
	spoj1(B, C, E, po, dopóki).

spojnik(B, C, D, A) :-
	rowne(A, [gdy, kiedy]),
	register(spoj1(po, gdy),
		 B,
		 C,
		 spoj37,
		 [D/spojnik(A)],
		 E),
	spoj1(B, C, E, po, gdy).

spojnik(B, C, D, A) :-
	rowne(A, [gdyby, jeśliby, jeżeliby]),
	register(spoj1(po, gdyby),
		 B,
		 C,
		 spoj38,
		 [D/spojnik(A)],
		 E),
	spoj1(B, C, E, po, gdyby).

spojnik(B, C, D, A) :-
	rowne(A, [jeśli, jeżeli]),
	register(spoj1(po, jeśli),
		 B,
		 C,
		 spoj39,
		 [D/spojnik(A)],
		 E),
	spoj1(B, C, E, po, jeśli).

spojnik(B, C, D, A) :-
	rowne(A, [ponieważ, skoro, że]),
	register(spoj1(po, ponieważ),
		 B,
		 C,
		 spoj41,
		 [D/spojnik(A)],
		 E),
	spoj1(B, C, E, po, ponieważ).

spojnik(B, C, D, A) :-
	rowne(A, [nim, zanim]),
	register(spoj1(po, zanim),
		 B,
		 C,
		 spoj42,
		 [D/spojnik(A)],
		 E),
	spoj1(B, C, E, po, zanim).

spojnik(B, C, D, A) :-
	rowne(A, [iż, że]),
	register(spoj1(po, że),
		 B,
		 C,
		 spoj43,
		 [D/spojnik(A)],
		 E),
	spoj1(B, C, E, po, że).

spojnik(B, C, D, A) :-
	rowne(A, [aby, ażeby, by, iżby, żeby]),
	register(spoj1(po, żeby),
		 B,
		 C,
		 spoj44,
		 [D/spojnik(A)],
		 E),
	spoj1(B, C, E, po, żeby).

zaimrzecz(C, D, E, co, A, B) :-
	register(zaimpyt(rzecz, A, B, 3, co),
		 C,
		 D,
		 zaim1n,
		 [E/zaimrzecz(co, A, B)],
		 F),
	zaimpyt(C, D, F, rzecz, A, B, 3, co).

zaimrzecz(C, D, E, kto, A, B) :-
	register(zaimpyt(rzecz, A, B, 3, kto),
		 C,
		 D,
		 zaim5n,
		 [E/zaimrzecz(kto, A, B)],
		 F),
	zaimpyt(C, D, F, rzecz, A, B, 3, kto).

zaimrzecz(C, D, E, co, A, B) :-
	register(zaimwzg(rzecz, A, B, 3, co),
		 C,
		 D,
		 zaim23n,
		 [E/zaimrzecz(co, A, B)],
		 F),
	zaimwzg(C, D, F, rzecz, A, B, 3, co).

zaimrzecz(C, D, E, kto, A, B) :-
	register(zaimwzg(rzecz, A, B, 3, kto),
		 C,
		 D,
		 zaim27n,
		 [E/zaimrzecz(kto, A, B)],
		 F),
	zaimwzg(C, D, F, rzecz, A, B, 3, kto).

zaimrzecz(C, D, E, coś, A, B) :-
	register(zaimno(rzecz, A, B, 3, co),
		 C,
		 D,
		 zaim71,
		 [E/zaimrzecz(coś, A, B)],
		 F),
	zaimno(C, D, F, rzecz, A, B, 3, co).

zaimrzecz(C, D, E, ktoś, A, B) :-
	register(zaimno(rzecz, A, B, 3, kto),
		 C,
		 D,
		 zaim72,
		 [E/zaimrzecz(ktoś, A, B)],
		 F),
	zaimno(C, D, F, rzecz, A, B, 3, kto).

zaimrzecz(C, D, E, nic, A, B) :-
	register(zaimneg(rzecz, A, B, 3, co),
		 C,
		 D,
		 zaim74,
		 [E/zaimrzecz(nic, A, B)],
		 F),
	zaimneg(C, D, F, rzecz, A, B, 3, co).

zaimrzecz(C, D, E, nikt, A, B) :-
	register(zaimneg(rzecz, A, B, 3, kto),
		 C,
		 D,
		 zaim75,
		 [E/zaimrzecz(nikt, A, B)],
		 F),
	zaimneg(C, D, F, rzecz, A, B, 3, kto).

zaimrzecz(B, C, D, to, A, r(mn(n), nmo(np(n)))/poj) :-
	register(kor1(A),
		 B,
		 C,
		 kor3n,
		 [D/zaimrzecz(to, A, r(mn(n), nmo(np(n)))/poj)],
		 E),
	kor1(B, C, E, A).

zaimprzym(D, E, F, A, B, C) :-
	rowne(A, [czyj, jaki, który]),
	register(zaimpyt(przym, B, C, H, I),
		 D,
		 E,
		 zaim9n,
		 [F/zaimprzym(A, B, C)],
		 G),
	zaimpyt(D, E, G, przym, B, C, H, I).

zaimprzym(D, E, F, A, B, C) :-
	rowne(A, [jaki, który]),
	register(zaimwzg(rzecz, B, C, 3, który),
		 D,
		 E,
		 zaim31n,
		 [F/zaimprzym(A, B, C)],
		 G),
	zaimwzg(D, E, G, rzecz, B, C, 3, który).

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(C, D, E, taki, A, B) :-
	register(zaimno(przym, A, B, G, tk),
		 C,
		 D,
		 zaim57n,
		 [E/zaimprzym(taki, A, B)],
		 F),
	zaimno(C, D, F, przym, A, B, G, tk).

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

zaimprzys(B, C, D, A) :-
	rowne(A, [dlaczego, dokąd, gdzie, jak, kiedy, odkąd, skąd]),
	register(zaimpyt(przysl, F, G, H, I),
		 B,
		 C,
		 zaim22,
		 [D/zaimprzys(A)],
		 E),
	zaimpyt(B,
		C,
		E,
		przysl,
		F,
		G,
		H,
		I).

zaimprzys(A, B, C, tak) :-
	register(zaimno(przysl, E, F, G, tk),
		 A,
		 B,
		 zaim70,
		 [C/zaimprzys(tak)],
		 D),
	zaimno(A, B, D, przysl, E, F, G, tk).

zaimprzys(A, B, C, nigdy) :-
	register(zaimneg(przysl, E, F, G, kto),
		 A,
		 B,
		 zaim76n,
		 [C/zaimprzys(nigdy)],
		 D),
	zaimneg(A, B, D, przysl, E, F, G, kto).

agl1(F, A, H, D, E) :-
	goal(spoj(C, B, ni), A, G, I),
	rowne(B, [bowiem, natomiast, więc, zaś]),
	rowne(C, [pi, ri]),
	register(agl(D, E, B),
		 F,
		 G,
		 agl1,
		 
		 [ H/agl1(D, E),
		   A,
		   I/spoj(C, B, ni)
		 ],
		 J),
	agl(F, G, J, D, E, B).

agl1(C, D, E, A, B) :-
	register(agl(A, B, ni),
		 C,
		 D,
		 agl2,
		 [E/agl1(A, B)],
		 F),
	agl(C, D, F, A, B, ni).

morfagl(B, C, D, m, A/poj, 1) :-
	register(agl1(A/poj, 1),
		 B,
		 C,
		 agl3,
		 [D/morfagl(m, A/poj, 1)],
		 E),
	agl1(B, C, E, A/poj, 1).

morfagl(B, C, D, śmy, A/mno, 1) :-
	register(agl1(A/mno, 1),
		 B,
		 C,
		 agl4,
		 [D/morfagl(śmy, A/mno, 1)],
		 E),
	agl1(B, C, E, A/mno, 1).

morfagl(B, C, D, ś, A/poj, 2) :-
	register(agl1(A/poj, 2),
		 B,
		 C,
		 agl5,
		 [D/morfagl(ś, A/poj, 2)],
		 E),
	agl1(B, C, E, A/poj, 2).

morfagl(B, C, D, ście, A/mno, 2) :-
	register(agl1(A/mno, 2),
		 B,
		 C,
		 agl6,
		 [D/morfagl(ście, A/mno, 2)],
		 E),
	agl1(B, C, E, A/mno, 2).

kor1(B, C, D, A) :-
	register(kor(A, ni),
		 B,
		 C,
		 kor2,
		 [D/kor1(A)],
		 E),
	kor(B, C, E, A, ni).

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

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

formaczas1(I, J, K, n, A, B, C, D, E, F, G, H) :-
	register(formaczas(A,
			   B,
			   C,
			   D,
			   E,
			   F,
			   G,
			   H),
		 I,
		 J,
		 n_cz1,
		 
		 [ K/formaczas1(n, A, B, C, D, E, F, G, H)
		 ],
		 L),
	formaczas(I,
		  J,
		  L,
		  A,
		  B,
		  C,
		  D,
		  E,
		  F,
		  G,
		  H).

formaczas1(J, A, L, s, B, C, D, E, F, G, H, I) :-
	goal(terminal(morf(N, się, qub)), A, K, M),
	register(formaczas(B,
			   C,
			   D,
			   E,
			   F,
			   G,
			   H,
			   I),
		 J,
		 K,
		 n_cz2,
		 
		 [ L/formaczas1(s, B, C, D, E, F, G, H, I),
		   A,
		   M/terminal(morf(N, się, qub))
		 ],
		 O),
	formaczas(J,
		  K,
		  O,
		  B,
		  C,
		  D,
		  E,
		  F,
		  G,
		  H,
		  I).

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

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

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

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

